legato_widget_bar_graph.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_bar_graph.h
 
  Summary:
 
 
  Description:
    This module implements bar graph drawing widget functions.
*******************************************************************************/
#ifndef LEGATO_WIDGET_BAR_GRAPH_H
#define LEGATO_WIDGET_BAR_GRAPH_H
 
#include "gfx/legato/common/legato_common.h"
 
#if LE_BARGRAPH_WIDGET_ENABLED
 
#include "gfx/legato/string/legato_dynamicstring.h"
#include "gfx/legato/widget/legato_widget.h"
 
// *****************************************************************************
// *****************************************************************************
// Section: Data Types and Constants
// *****************************************************************************
// *****************************************************************************
 
 
// *****************************************************************************
/* Enumeration:
    leBarGraphValueAxis
 
  Summary:
    The value axis index value
*/
typedef enum leBarGraphValueAxis
{
    BAR_GRAPH_AXIS_0 = 0,
//  BAR_GRAPH_AXIS_1, //unsupported
} leBarGraphValueAxis;
 
// *****************************************************************************
/* Enumeration:
    leBarGraphTickPosition
 
  Summary:
    The tick position relative to axis
*/
typedef enum leBarGraphTickPosition
{
    BAR_GRAPH_TICK_IN,
    BAR_GRAPH_TICK_OUT,
    BAR_GRAPH_TICK_CENTER,
} leBarGraphTickPosition;
 
// *****************************************************************************
/* Structure:
    leBarGraphDataSeries
 
  Summary:
    The data series object that contains the series properties and data
 
  Description:
 
 
  Remarks:
    None.
*/
typedef struct leBarGraphDataSeries
{
    const leScheme* scheme;
    leArray data;
    leBarGraphValueAxis axis;
} leBarGraphDataSeries;
 
typedef struct leBarGraphCategory
{
    const leString* str;
    uint32_t drawX;
} leBarGraphCategory;
 
/* internal use only */typedef struct leBarGraphWidget leBarGraphWidget;
 
#define LE_BARGRAPHWIDGET_VTABLE(THIS_TYPE) \
    LE_WIDGET_VTABLE(THIS_TYPE) \
    \
    uint32_t                (*getTickLength)(const THIS_TYPE* _this); \
    leResult                (*setTickLength)(THIS_TYPE* _this, uint32_t len); \
    uint32_t                (*getMinValue)(const THIS_TYPE* _this, leBarGraphValueAxis axis); \
    leResult                (*setMinValue)(THIS_TYPE* _this, leBarGraphValueAxis axis, int32_t min); \
    uint32_t                (*getMaxValue)(const THIS_TYPE* _this, leBarGraphValueAxis axis); \
    leResult                (*setMaxValue)(THIS_TYPE* _this, leBarGraphValueAxis axis, int32_t max); \
    leBool                  (*getValueAxisLabelsVisible)(const THIS_TYPE* _this, leBarGraphValueAxis axis); \
    leResult                (*setValueAxisLabelsVisible)(THIS_TYPE* _this, leBarGraphValueAxis axis, leBool vis); \
    leBool                  (*getValueAxisTicksVisible)(const THIS_TYPE* _this, leBarGraphValueAxis axis); \
    leResult                (*setValueAxisTicksVisible)(THIS_TYPE* _this, leBarGraphValueAxis axis, leBool vis); \
    uint32_t                (*getValueAxisTicksInterval)(const THIS_TYPE* _this, leBarGraphValueAxis axis); \
    leResult                (*setValueAxisTicksInterval)(THIS_TYPE* _this, leBarGraphValueAxis axis, uint32_t itv); \
    leBarGraphTickPosition  (*getValueAxisTicksPosition)(const THIS_TYPE* _this, leBarGraphValueAxis axis); \
    leResult                (*setValueAxisTicksPosition)(THIS_TYPE* _this, leBarGraphValueAxis axis, leBarGraphTickPosition pos); \
    leBool                  (*getValueAxisSubticksVisible)(const THIS_TYPE* _this, leBarGraphValueAxis axis); \
    leResult                (*setValueAxisSubticksVisible)(THIS_TYPE* _this, leBarGraphValueAxis axis, leBool vis); \
    uint32_t                (*getValueAxisSubticksInterval)(const THIS_TYPE* _this, leBarGraphValueAxis axis); \
    leResult                (*setValueAxisSubticksInterval)(THIS_TYPE* _this, leBarGraphValueAxis axis, uint32_t itv); \
    leBarGraphTickPosition  (*getValueAxisSubticksPosition)(const THIS_TYPE* _this, leBarGraphValueAxis axis); \
    leResult                (*setValueAxisSubticksPosition)(THIS_TYPE* _this, leBarGraphValueAxis axis, leBarGraphTickPosition pos); \
    leBool                  (*getCategoryAxisTicksVisible)(const THIS_TYPE* _this); \
    leResult                (*setCategoryAxisTicksVisible)(THIS_TYPE* _this, leBool vis); \
    leBarGraphTickPosition  (*getCategoryAxisTicksPosition)(const THIS_TYPE* _this); \
    leResult                (*setCategoryAxisTicksPosition)(THIS_TYPE* _this, leBarGraphTickPosition pos); \
    leBool                  (*getCategoryAxisLabelsVisible)(const THIS_TYPE* _this); \
    leResult                (*setCategoryAxisLabelsVisible)(THIS_TYPE* _this, leBool vis); \
    leResult                (*addSeries)(THIS_TYPE* _this, uint32_t* seriesID); \
    leScheme*               (*getSeriesScheme)(const THIS_TYPE* _this, uint32_t seriesID); \
    leResult                (*setSeriesScheme)(THIS_TYPE* _this, uint32_t seriesID, const leScheme* schm); \
    leResult                (*addDataToSeries)(THIS_TYPE* _this, uint32_t seriesID, int32_t val, uint32_t* idx); \
    leResult                (*setDataInSeries)(THIS_TYPE* _this, uint32_t seriesID, uint32_t index, int32_t value); \
    leResult                (*clearData)(THIS_TYPE* _this); \
    leFont*                 (*getTicksLabelFont)(THIS_TYPE* _this); \
    leResult                (*setTicksLabelFont)(THIS_TYPE* _this, const leFont* font); \
    leBool                  (*getGridLinesVisible)(const THIS_TYPE* _this, leBarGraphValueAxis axis); \
    leResult                (*setGridLinesVisible)(THIS_TYPE* _this, leBarGraphValueAxis axis, leBool vis); \
    leResult                (*addCategory)(THIS_TYPE* _this, uint32_t* id); \
    leString*               (*getCategoryString)(const THIS_TYPE* _this, uint32_t id); \
    leResult                (*setCategoryString)(THIS_TYPE* _this, uint32_t id, const leString* str); \
    leBool                  (*getStacked)(const THIS_TYPE* _this); \
    leResult                (*setStacked)(THIS_TYPE* _this, leBool stk); \
    leBool                  (*getFillGraphArea)(const THIS_TYPE* _this); \
    leResult                (*setFillGraphArea)(THIS_TYPE* _this, leBool fill); \
    
    
 
typedef struct leBarGraphWidgetVTable
{
    LE_BARGRAPHWIDGET_VTABLE(leBarGraphWidget)
} leBarGraphWidgetVTable; 
 
// *****************************************************************************
/* Structure:
    leBarGraphWidget
 
  Summary:
    Implementation of a bar graph widget.
 
  Description:
    A bar graph widget draws a bar graph. All coordinates are expressed in local widget space.
 
    The color of the graph is determined by the widget scheme's 'foreground'
    color.
 
  Remarks:
    None.
*/
typedef struct leBarGraphWidget
{
    leWidget widget; // base widget header
 
    const leBarGraphWidgetVTable* fn;
 
    uint32_t tickLength;
    leBool fillGraphArea;
 
    //Value axis properties
    int32_t maxValue;
    int32_t minValue;
    uint32_t tickInterval;
    uint32_t subtickInterval;
    leBool valueAxisLabelsVisible;
    leBool valueAxisTicksVisible;
    leBool valueAxisSubticksVisible;
    leBool valueGridLinesVisible;
    leBool stacked;
    leArray dataSeriesArray;
    const leFont* ticksLabelFont;
    leBarGraphTickPosition valueAxisTicksPosition;
    leBarGraphTickPosition valueAxisSubticksPosition;
 
    //Category axis properties
    leBool categAxisLabelsVisible;
    leBool categAxisTicksVisible;
    leBarGraphTickPosition categAxisTicksPosition;
    leArray categories;
} leBarGraphWidget;
 
// *****************************************************************************
// *****************************************************************************
// Section: Routines
// *****************************************************************************
// *****************************************************************************
 
LIB_EXPORT leBarGraphWidget* leBarGraphWidget_New();
 
LIB_EXPORT void leBarGraphWidget_Constructor(leBarGraphWidget* wgt);
 
#ifdef _DOXYGEN_
#define THIS_TYPE struct leWidget
 
uint32_t getTickLength(const leBarGraphWidget* _this);
 
 
virtual leResult setTickLength(leBarGraphWidget* _this,
                               uint32_t len);
 
 
virtual uint32_t getMinValue(const leBarGraphWidget* _this,
                             leBarGraphValueAxis axis);
 
virtual leResult setMinValue(leBarGraphWidget* _this,
                             leBarGraphValueAxis axis,
                             int32_t min);
 
 
virtual uint32_t getMaxValue(const leBarGraphWidget* _this,
                             leBarGraphValueAxis axis);
 
virtual leResult setMaxValue(leBarGraphWidget* _this,
                             leBarGraphValueAxis axis,
                             int32_t max);
 
virtual leBool getValueAxisLabelsVisible(const leBarGraphWidget* _this,
                                         leBarGraphValueAxis axis);
 
 
virtual leResult setValueAxisLabelsVisible(leBarGraphWidget* _this,
                                           leBarGraphValueAxis axis,
                                           leBool vis);
 
 
virtual leBool getValueAxisTicksVisible(const leBarGraphWidget* _this,
                                leBarGraphValueAxis axis);
 
 
virtual leResult setValueAxisTicksVisible(leBarGraphWidget* _this,
                                          leBarGraphValueAxis axis,
                                          leBool vis);
 
 
virtual uint32_t getValueAxisTicksInterval(const leBarGraphWidget* _this,
                                           leBarGraphValueAxis axis);
 
 
virtual leResult setValueAxisTicksInterval(leBarGraphWidget* _this,
                                           leBarGraphValueAxis axis,
                                           uint32_t itv);
 
 
 
virtual leBarGraphTickPosition getValueAxisTicksPosition(const leBarGraphWidget* _this,
                                                         leBarGraphValueAxis axis);
 
virtual leResult setValueAxisTicksPosition(leBarGraphWidget* _this,
                                           leBarGraphValueAxis axis,
                                           leBarGraphTickPosition pos);
 
 
 
virtual leBool getValueAxisSubticksVisible(const leBarGraphWidget* _this,
                                           leBarGraphValueAxis axis);
 
 
virtual leResult setValueAxisSubticksVisible(leBarGraphWidget* _this,
                                             leBarGraphValueAxis axis,
                                             leBool vis);
 
 
 
virtual uint32_t getValueAxisSubticksInterval(const leBarGraphWidget* _this,
                                              leBarGraphValueAxis axis);
 
 
virtual leResult setValueAxisSubticksInterval(leBarGraphWidget* _this,
                                              leBarGraphValueAxis axis,
                                              uint32_t itv);
 
 
virtual leBarGraphTickPosition getValueAxisSubticksPosition(const leBarGraphWidget* _this,
                                                            leBarGraphValueAxis axis);
 
 
virtual leResult setValueAxisSubticksPosition(leBarGraphWidget* _this,
                                      leBarGraphValueAxis axis,
                                      leBarGraphTickPosition pos);
 
 
virtual leBool getCategoryAxisTicksVisible(const leBarGraphWidget* _this);
 
virtual leResult setCategoryAxisTicksVisible(leBarGraphWidget* _this,
                                     leBool vis);
 
virtual leBarGraphTickPosition getCategoryAxisTicksPosition(const leBarGraphWidget* _this);
 
virtual leResult setCategoryAxisTicksPosition(leBarGraphWidget* _this,
                                      leBarGraphTickPosition pos)
 
 
virtual leResult setCategoryAxisLabelsVisible(leBarGraphWidget* _this,
                                      leBool vis)
 
 
virtual leResult addSeries(leBarGraphWidget* _this,
                           uint32_t* seriesID);
 
virtual leScheme* getSeriesScheme(const leBarGraphWidget* _this,
                                  uint32_t seriesID);
 
leResult setSeriesScheme(leBarGraphWidget* _this,
                         uint32_t seriesID,
                         const leScheme* schm);
 
 leResult setDataInSeries(leBarGraphWidget* _this,
                         uint32_t seriesID,
                         uint32_t index,
                         int32_t value)
 
 
virtual leResult clearData(leBarGraphWidget* _this);
 
 
virtual leFont* getTicksLabelFont(leBarGraphWidget* _this);
 
 
virtual leResult setTicksLabelFont(const leBarGraphWidget* _this,
                                   const leFont* font);
 
virtual leBool getGridLinesVisible(const leBarGraphWidget* _this,
                                   leBarGraphValueAxis axis);
 
virtual leResult setGridLinesVisible(leBarGraphWidget* _this,
                                     leBarGraphValueAxis axis,
                                     leBool vis);
 
virtual leResult addCategory(leBarGraphWidget* _this,
                     uint32_t* id);
 
virtual leString* getCategoryString(const leBarGraphWidget* _this,
                                    uint32_t id);
 
virtual leResult setCategoryString(leBarGraphWidget* _this,
                                   uint32_t id,
                                   const leString* str);
 
virtual leBool getStacked(const leBarGraphWidget* _this);
 
virtual leResult setStacked(leBarGraphWidget* _this,
                            leBool stk);
 
virtual leBool getFillGraphArea(const leBarGraphWidget* _this);
 
virtual leResult setFillGraphArea(THIS_TYPE* _this,
                             leBool fill);
#undef THIS_TYPE
#endif
 
 
#endif // LE_BARGRAPH_WIDGET_ENABLED
#endif /* LEGATO_WIDGET_BAR_GRAPH_H */