legato_widget_circular_slider.h

Go to the documentation of this file.

/*******************************************************************************
* Copyright (C) 2020 Microchip Technology Inc. and its subsidiaries.
*
* Subject to your compliance with these terms, you may use Microchip software
* and any derivatives exclusively with Microchip products. It is your
* responsibility to comply with third party license terms applicable to your
* use of third party software (including open source software) that may
* accompany Microchip software.
*
* THIS SOFTWARE IS SUPPLIED BY MICROCHIP "AS IS". NO WARRANTIES, WHETHER
* EXPRESS, IMPLIED OR STATUTORY, APPLY TO THIS SOFTWARE, INCLUDING ANY IMPLIED
* WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY, AND FITNESS FOR A
* PARTICULAR PURPOSE.
*
* IN NO EVENT WILL MICROCHIP BE LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE,
* INCIDENTAL OR CONSEQUENTIAL LOSS, DAMAGE, COST OR EXPENSE OF ANY KIND
* WHATSOEVER RELATED TO THE SOFTWARE, HOWEVER CAUSED, EVEN IF MICROCHIP HAS
* BEEN ADVISED OF THE POSSIBILITY OR THE DAMAGES ARE FORESEEABLE. TO THE
* FULLEST EXTENT ALLOWED BY LAW, MICROCHIP'S TOTAL LIABILITY ON ALL CLAIMS IN
* ANY WAY RELATED TO THIS SOFTWARE WILL NOT EXCEED THE AMOUNT OF FEES, IF ANY,
* THAT YOU HAVE PAID DIRECTLY TO MICROCHIP FOR THIS SOFTWARE.
*******************************************************************************/

/*******************************************************************************
 Module for Microchip Graphics Library - Legato User Interface Library

  Company:
    Microchip Technology Inc.

  File Name:
    legato_widget_circular_slider.h

  Summary:


  Description:
    This module implements slider drawing widget functions.
*******************************************************************************/

#ifndef LEGATO_WIDGET_CIRCULAR_SLIDER_H
#define LEGATO_WIDGET_CIRCULAR_SLIDER_H

#include "gfx/legato/common/legato_common.h"

#if LE_CIRCULARSLIDER_WIDGET_ENABLED == 1

#ifdef __cplusplus
extern "C" {
#endif

#include "gfx/legato/widget/legato_widget.h"

// *****************************************************************************
// *****************************************************************************
// Section: Data Types and Constants
// *****************************************************************************
// *****************************************************************************

// *****************************************************************************
/* Structure:
    leCircularSliderButtonState

  Summary:
    State of the slider button

  Description:
    State of the slider button

  Remarks:
    None.
*/
typedef enum leCircularSliderButtonState
{
    LE_CIRCULAR_SLIDER_STATE_UP,
    LE_CIRCULAR_SLIDER_STATE_DOWN,
} leCircularSliderButtonState;

// *****************************************************************************
/* Enumeration:
    leCircularSliderWidgetArcType

  Summary:
    The arcs that compose the circular slider

  Description:
    The arcs that compose the circular slider

  Remarks:
    None.
*/
typedef enum leCircularSliderWidgetArcType
{
    OUTSIDE_CIRCLE_BORDER,
    INSIDE_CIRCLE_BORDER,
    ACTIVE_AREA,
    INACTIVE_AREA,
    CIRCLE_BUTTON,
} leCircularSliderWidgetArcType;

// *****************************************************************************
/* Structure:
    leCircularSliderArc

  Summary:
    Internal structure for the arcs in the circular slider widget

  Description:
    Describs the arc instances in the circular gauge widget

  Remarks:
    None.
*/
typedef struct leCircularSliderArc
{
    leBool visible;
    uint32_t radius;
    uint32_t thickness;
    const leScheme* scheme;
} leCircularSliderArc;

typedef struct leCircularSliderWidget leCircularSliderWidget;

// *****************************************************************************
/* Function Pointer:
    leCircularSliderWidget_PressedEvent

  Summary:
    Button pressed event function callback type
*/
typedef void (*leCircularSliderWidget_PressedEvent)(leCircularSliderWidget *, int32_t);

// *****************************************************************************
/* Function Pointer:
    leCircularSliderWidget_ValueChangedEvent

  Summary:
    Value changed event function callback type
*/
typedef void (*leCircularSliderWidget_ValueChangedEvent)(leCircularSliderWidget *, int32_t);

// *****************************************************************************
/* Function Pointer:
    leCircularSliderWidget_ReleasedEvent

  Summary:
    Button released event function callback type
*/
typedef void (*leCircularSliderWidget_ReleasedEvent)(leCircularSliderWidget *, int32_t);

/* internal use only */
#define LE_CIRCULARSLIDERWIDGET_VTABLE(THIS_TYPE) \
    LE_WIDGET_VTABLE(THIS_TYPE) \
    \
    uint32_t                 (*getRadius)(const THIS_TYPE* _this); \
    leResult                 (*setRadius)(THIS_TYPE* _this, uint32_t rad); \
    int32_t                  (*getStartAngle)(const THIS_TYPE* _this); \
    leResult                 (*setStartAngle)(THIS_TYPE* _this, int32_t ang); \
    int32_t                  (*getSpanAngle)(const THIS_TYPE* _this); \
    leResult                 (*setSpanAngle)(THIS_TYPE* _this, int32_t ang); \
    uint32_t                 (*getArcThickness)(const THIS_TYPE* _this, leCircularSliderWidgetArcType type); \
    leResult                 (*setArcThickness)(THIS_TYPE* _this, leCircularSliderWidgetArcType type, uint32_t thck); \
    uint32_t                 (*getArcRadius)(const THIS_TYPE* _this, leCircularSliderWidgetArcType type); \
    leResult                 (*setArcRadius)(THIS_TYPE* _this, leCircularSliderWidgetArcType type, uint32_t rad); \
    leScheme*                (*getArcScheme)(const THIS_TYPE* _this, leCircularSliderWidgetArcType type); \
    leResult                 (*setArcScheme)(THIS_TYPE* _this, leCircularSliderWidgetArcType type, const leScheme* schm); \
    leBool                   (*getArcVisible)(const THIS_TYPE* _this, leCircularSliderWidgetArcType type); \
    leResult                 (*setArcVisible)(THIS_TYPE* _this, leCircularSliderWidgetArcType type, leBool vis); \
    uint32_t                 (*getValue)(const THIS_TYPE* _this); \
    leResult                 (*setValue)(THIS_TYPE* _this, uint32_t val); \
    leBool                   (*getRoundEdges)(const THIS_TYPE* _this); \
    leResult                 (*setRoundEdges)(THIS_TYPE* _this, leBool rnd); \
    leBool                   (*getStickyButton)(const THIS_TYPE* _this); \
    leResult                 (*setStickyButton)(THIS_TYPE* _this, leBool stk); \
    uint32_t                 (*getSnapDivisions)(const THIS_TYPE* _this); \
    leResult                 (*setSnapDivisions)(THIS_TYPE* _this, uint32_t div); \
    leBool                   (*getTouchOnButtonOnly)(const THIS_TYPE* _this); \
    leResult                 (*setTouchOnButtonOnly)(THIS_TYPE* _this, leBool tch); \
    leRotationDirection      (*getDirection)(const THIS_TYPE* _this); \
    leResult                 (*setDirection)(THIS_TYPE* _this, leRotationDirection dir); \
    leResult                 (*setPressedEventCallback)(THIS_TYPE* _this, leCircularSliderWidget_PressedEvent cb); \
    leResult                 (*setValueChangedEventCallback)(THIS_TYPE* _this, leCircularSliderWidget_ValueChangedEvent cb); \
    leResult                 (*setReleasedEventCallback)(THIS_TYPE* _this, leCircularSliderWidget_ReleasedEvent cb); \

typedef struct leCircularSliderWidgetVTable
{
    LE_CIRCULARSLIDERWIDGET_VTABLE(leCircularSliderWidget)
} leCircularSliderWidgetVTable; 

// *****************************************************************************
/* Structure:
    leCircularSliderWidget

  Summary:
    Implementation of a slider widget.

  Description:
    A slider widget draws a slider of the specified origin and radius inside
    the widget bounds.  All coordinates are expressed in local widget space.

    The color of the slider is determined by the widget scheme's 'foreground'
    color.

  Remarks:
    None.
*/
typedef struct leCircularSliderWidget
{
    leWidget widget; // base widget header

    const leCircularSliderWidgetVTable* fn;

    uint32_t radius; // the radius of the slider

    int32_t startAngle; //the start angle of the slider
    int32_t spanAngle;  //the span angle of the slider

    uint32_t value;      //the value of the slider

    leBool roundEdges; //round edges
    leBool sticky; //snaps to start value before wrapping around
    uint32_t snapDivisions;
    leBool buttonTouch; //only button is active to touch

    leRotationDirection direction;    //the direction of the slider

    leCircularSliderArc activeArc;            //the arc for the slider value
    leCircularSliderArc inActiveArc;          //the arc for the slider remainder
    leCircularSliderArc outsideBorderArc;     //the arc for the outside border
    leCircularSliderArc insideBorderArc;      //the arc for the inside border
    leCircularSliderArc circleButtonArc;      //the arc for the circle button

    leCircularSliderButtonState btnState;   //the state of the circular slider button

    leCircularSliderWidget_PressedEvent pressedCallback;
    leCircularSliderWidget_ValueChangedEvent valueChangedCallback;
    leCircularSliderWidget_ReleasedEvent releasedCallback;
} leCircularSliderWidget;

// *****************************************************************************
// *****************************************************************************
// Section: Routines
// *****************************************************************************
// *****************************************************************************

leCircularSliderWidget* leCircularSliderWidget_New(void);

void leCircularSliderWidget_Constructor(leCircularSliderWidget* wgt);

#ifdef _DOXYGEN_
#define THIS_TYPE struct leWidget

// *****************************************************************************
virtual uint32_t getRadius(const leCircularSliderWidget* _this);


// *****************************************************************************
virtual leResult setRadius(leCircularSliderWidget* _this,
                           uint32_t rad);


// *****************************************************************************
virtual uint32_t getStartAngle(const leCircularSliderWidget* _this);


// *****************************************************************************
virtual leResult setStartAngle(leCircularSliderWidget* _this,
                               int32_t ang);


virtual uint32_t getArcThickness(const leCircularSliderWidget* _this,
                                 leCircularSliderWidgetArcType type);




virtual leResult setArcThickness(leCircularSliderWidget* _this,
                                 leCircularSliderWidgetArcType type,
                                 uint32_t thck);

/ *****************************************************************************
virtual uint32_t getArcRadius(const leCircularSliderWidget* _this,
                              leCircularSliderWidgetArcType type);


// *****************************************************************************
virtual leResult setArcRadius(leCircularSliderWidget* _this,
                              leCircularSliderWidgetArcType type,
                              uint32_t rad);


virtual leScheme* getArcScheme(const leCircularSliderWidget* _this,
                               leCircularSliderWidgetArcType type);

leResult setArcScheme(leCircularSliderWidget* _this,
                      leCircularSliderWidgetArcType type,
                      const leScheme* schm;

* @brief Get arc visibility
* @details Gets arc visilibilty for <span class="param">type</span> using
* <span class="param">_this</span>.
* @code
* leCircularSliderWidget* _this;
* leCircularSliderWidgetArcType type;
* leBool visible = _this->fn->getArcVisible(_this, axis);
* @endcode
* @param _this is the widget to query.
* @param type the type to query.
* @returns LE_TRUE if set, otherwise LE_FALSE;
*/
virtual leBool getArcVisible(const leCircularSliderWidget* _this,
                             leCircularSliderWidgetArcType type);

virtual leBool setArcVisible(const leCircularSliderWidget* _this,
                             leCircularSliderWidgetArcType type);

// *****************************************************************************
virtual uint32_t getStartValue(const leCircularSliderWidget* _this);


// *****************************************************************************
virtual leResult setStartValue(leCircularSliderWidget* _this,
                               uint32_t val);

/ *****************************************************************************
virtual uint32_t getEndValue(const leCircularSliderWidget* _this);


// *****************************************************************************
virtual leResult setEndValue(leCircularSliderWidget* _this,
                             uint32_t val);

// *****************************************************************************
virtual leBool getRoundEdges(const leCircularSliderWidget* _this);


// *****************************************************************************
virtual leResult setRoundEdges(leCircularSliderWidget* _this,
                               leBool rnd);


// *****************************************************************************
virtual leBool getStickyButton(const leCircularSliderWidget* _this);


// *****************************************************************************
virtual leResult setStickyButton(leCircularSliderWidget* _this,
                                 leBool stk);

// *****************************************************************************
virtual leBool getTouchOnButtonOnly(const leCircularSliderWidget* _this);


// *****************************************************************************
virtual leResult setTouchOnButtonOnly(leCircularSliderWidget* _this,
                                      leBool tch);


// *****************************************************************************
virtual leRotationDirection getDirection(const leCircularSliderWidget* _this);


// *****************************************************************************
virtual leResult setDirection(leCircularSliderWidget* _this,
                              leRotationDirection dir);


virtual leResult setPressedEventCallback(leCircularSliderWidget* _this,
                                         leCircularSliderWidget_PressedEvent cb);


leResult setValueChangedEventCallback(leCircularSliderWidget* _this,
                                      leCircularSliderWidget_ValueChangedEvent cb)



virtual leResult setReleasedEventCallback(leCircularSliderWidget* _this,
                                          leCircularSliderWidget_ReleasedEvent cb);

#undef THIS_TYPE
#endif

#ifdef __cplusplus
}
#endif

#endif // LE_CIRCULARSLIDER_WIDGET_ENABLED
#endif /* LEGATO_WIDGET_CIRCULAR_SLIDER_H */