lvppBase.h

Go to the documentation of this file.

// Copyright 2023 Robert M. Wolff (bob dot wolff 68 at gmail dot com)
//
// Redistribution and use in source and binary forms, with or without modification, 
// are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this 
// list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice, 
// this list of conditions and the following disclaimer in the documentation and/or 
// other materials provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of its contributors 
// may be used to endorse or promote products derived from this software without 
// specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
#ifndef _LVPPBASE_H
#define _LVPPBASE_H
 
#include <vector>
#include <utility> // For std::pair
#include <string>
#include <functional>
 
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
 
static std::string eventNames[_LV_EVENT_LAST];  
 
class lvppBase {
public:
    lvppBase(const char* fName, const char* oType);
    ~lvppBase();
    void createObj(lv_obj_t* o);        
    static const char* getEventName(lv_event_code_t code);
    static bool isUnknownCode(lv_event_code_t code);
    lv_obj_t* getObj(void) { return obj; };
    lv_obj_t* getLabelObj(void) { return label; };
    virtual void setSize(lv_coord_t width, lv_coord_t height);
    void align(lv_align_t align, lv_coord_t x_ofs, lv_coord_t y_ofs);
    void setFontSize(uint8_t points);
    void setFont(const lv_font_t* pF);
    void setBGColor(lv_color_t color);
    void setColorGradient(lv_color_t col1, lv_color_t col2, lv_grad_dir_t direction);
    virtual void setText(const char* pText);
    std::string getText();
    void setTextAlign(lv_align_t align, lv_coord_t xoff, lv_coord_t yoff);
    void setTextColor(lv_color_t newColor);
    void setLabelJustificationAlignment(lv_text_align_t _align);
    void setLabelColorizationEnabled(bool bEnable=true);
 
    virtual void setAdjText(const char* pText, lv_coord_t x_ofs=-10000, lv_coord_t y_ofs=-10000);
   void setAdjTextColor(lv_color_t newColor);
   void setAdjBGColor(lv_color_t color);
    void setAdjColorGradient(lv_color_t col1, lv_color_t col2, lv_grad_dir_t direction);
    void setAdjFont(const lv_font_t* pF);
    void setAdjJustificationAlignment(lv_text_align_t _align);
    virtual void onClicked() { };
    virtual void internalOnClicked() { };
    virtual void onValueChanged() { };
    virtual void internalOnValueChanged() { };
    void setFriendlyName(const char* pName);
    std::string getFriendlyName() { return friendlyName; };
    std::string getObjType() { return objType; };
    const char* whoAmI(void);
    void setCallbackOnClicked(std::function<void()> cbF) {
        assert(!cbOnClicked);
        assert(cbF);
        cbOnClicked = cbF;
    };
    void setCallbackOnValueChanged(std::function<void()> cbF) {
        assert(!cbOnValueChanged);
        assert(cbF);
        cbOnValueChanged = cbF;
    };
 
    virtual void setNewParent(lv_obj_t* pNewParent);
protected:
    lv_obj_t* label;    
    lv_obj_t* adjLabel; 
    std::function<void()> cbOnClicked=nullptr;      
    std::function<void()> cbOnValueChanged=nullptr; 
    lv_obj_t* obj;      
    lv_obj_t* objParent;    
    std::string objType;
    std::string friendlyName;
    lv_style_t style_obj;   
    void setObjType(const char* pType) { objType = pType; };
 
    void baseEventHandler(lv_event_t* event);
    virtual void eventHandler(lv_event_t* event) { };
    static void lvCallback(lv_event_t* event);
    static void initEventNames(void);
 
    static bool bEventNamesInitComplete;    
private:
    void createLabel();
    void createAdjLabel();
};
 
//
//
// l v p p B a s e W i t h V a l u e
//
//
 
class lvppBaseWithValue : public lvppBase {
public:
    lvppBaseWithValue(const char* fName, const char* oType);
    virtual void setValue(int16_t value, bool animate=true);
    int16_t getValue(void) { return curValue; };
    uint16_t getValuePercentage(void) { return 100 * (curValue-min) / (max-min); };
    void enableValueLabel(lv_coord_t xoff, lv_coord_t yoff, lv_align_t alignment=LV_ALIGN_CENTER);
    void setValueLabelFormat(const char* fmt);
    void setValueLabelColor(lv_color_t newColor);
    void setValueLabelBGColor(lv_color_t newColor);
    void setValueLabelColorGradient(lv_color_t col1, lv_color_t col2, lv_grad_dir_t direction);
    void setValueLabelJustificationAlignment(lv_text_align_t _align);
    void setValueLabelFont(const lv_font_t* pF);
    void setValueRange(int16_t _min, int16_t _max) { min = _min; max = _max; };
    virtual void setNewParent(lv_obj_t* pNewParent);
protected:
    virtual int16_t baseGetter() = 0;
    virtual void baseSetter(int16_t nVal, bool animate=true) = 0;
    void internalOnValueChanged();  
    int16_t curValue;               
    lv_obj_t* valueLabel;           
    std::string valueLabelFormat;   
    int16_t min, max;               
private:
    void createValueLabel();
};
 
class lvppOptions {
public:
    virtual void setOptions(const char* pOpts);
    virtual void setOptions(std::vector<std::string>& _opts);
    virtual void setOptionsWithIDs(std::vector<std::pair<std::string, uint64_t>>& valIDs);
    virtual void addOption(const char* pOpt);
    virtual void addOptionWithID(const char* pOpt, uint64_t id);
    virtual void addOption(std::string& _opt);
    virtual void addOptionWithID(std::string& _opt, uint64_t id);
    virtual void clearOptions();
    virtual uint64_t getSelectedID();
protected:
    virtual void lvOptionSetter(const char* pOpts) = 0;
    virtual uint16_t lvOptionGetIndex() = 0;
    std::string oneString;              
    std::vector<std::string> options;   
    std::vector<uint64_t> idList;       
    const char* getNewlineSepOptions(); 
};
 
 
#endif