Button.h

Go to the documentation of this file.

/******************************************************************************/
 
#ifndef BUTTON_INCLUDED
#define BUTTON_INCLUDED
 
#include "ButtonState.h"

template <uint8_t NUM>
struct ButtonConfig_t
{
  uint8_t borderWidth;
  uint16_t borderColor;
  unsigned short cornerRadius;
};

const ButtonConfig_t<2> DEFAULT_BUTTON_CONFIG = {
    3,            // Border width
    COLORS.WHITE, // Border Color
    25            // Corner Radius0
};

const ButtonConfig_t<2> DEFAULT_SM_BUTTON_CONFIG = {
    2,            // Border width
    COLORS.WHITE, // Border Color
    15            // Corner Radius0
};
 
/******************************************************************************/
/***                                                                        ***/
/***                 Class Definition: Button                               ***/
/***                                                                        ***/
/******************************************************************************/
class Button
{
public:
  enum callback_type
  {
    ON_PRESS,
    ON_RELEASE
  };
 
private:
  bool _enabled = false;       // Determines whether the button is enabled
  uint8_t _state = 0;          // Tracks the current state of the button
  const char *_BUTTON_NAME;    // Name of the button (used for error messages)
  callback_type _whenCallback; // Defines when the callback function is called
 
  // Destination where the button should be copied to
  Canvas &_DestCanvas;
  const uint16_t _DEST_X;
  const uint16_t _DEST_Y;
 
  // Size of the button
  const uint16_t _WIDTH;
  const uint16_t _HEIGHT;
 
  // Array of button states
  uint8_t _nStates = 0;                 // Maximum number of states supported by this button
  ButtonState **_buttonState = nullptr; // Array of pointers to ButtonState objects, provided by derived classes
 
  // Internal method that verifies that the indicated   state is valid
  bool _isValidState(uint8_t state);
 
public:
  Button(void) = delete;


  Button(const char *buttonName, Canvas &DestCanvas, uint16_t dest_x, uint16_t dest_y, uint16_t width, uint16_t height,
         callback_type whenCallback)
      : _BUTTON_NAME{buttonName},
        _whenCallback{whenCallback},
        _DestCanvas{DestCanvas},
        _DEST_X{dest_x},
        _DEST_Y{dest_y},
        _WIDTH{width},
        _HEIGHT{height} {};

  virtual ~Button(void) = default;


  virtual void begin(void);

  virtual bool press(FT5316::TouchLocation loc);

  virtual void release(void);

  void enable(void)
  {
    _enabled = true;
  };

  void disable(void)
  {
    _enabled = false;
  };

  void setState(uint8_t state)
  {
    if (state < 0 || state >= _nStates)
      return;
    _state = state;
  };

  void nextState(void)
  {
    if (++_state >= _nStates)
    {
      _state = 0;
    }
  };

  void draw(void)
  {
    _buttonState[_state]->draw();
  }

  void draw(Canvas &newCanvas)
  {
    _buttonState[_state]->draw(newCanvas);
  }



  inline bool isEnabled(void) const
  {
    return _enabled;
  };

  inline uint16_t width(void) const
  {
    return _WIDTH;
  }

  inline uint16_t height(void) const
  {
    return _HEIGHT;
  }

  inline uint8_t state(void) const
  {
    return _state;
  }

 
protected:
  void _validateObject(void);

  void _registerButtonStates(ButtonState **buttonStatePtrArr, uint8_t numStates);

  inline void _changeCallback(callback_type type)
  {
    _whenCallback = type;
  }
};
 
/******************************************************************************/
/***                                                                        ***/
/***                 Class Definition: ToggleButton                         ***/
/***                                                                        ***/
/******************************************************************************/
class ToggleButton : public Button
{
  static const uint8_t _NUM_STATES = 2;   
  ButtonState *_ButtonState[_NUM_STATES]; 
 
public:
  ToggleButton(void) = delete;


  ToggleButton(const char *buttonName, Canvas &Destination, const Block_Image &DestLoc,
               const char *buttonText0, FontList::FontID Font0, uint16_t fillColor0, ButtonState::buttonCallbackFunction callback0,
               const char *buttonText1, FontList::FontID Font1, uint16_t fillColor1, ButtonState::buttonCallbackFunction callback1,
               uint16_t fontBaseline, const ButtonConfig_t<2> config = DEFAULT_BUTTON_CONFIG)
      : Button(buttonName, Destination, DestLoc.x, DestLoc.y, DestLoc.width, DestLoc.height, Button::callback_type::ON_PRESS)
  {
    _ButtonState[0] = new TextButtonState(Destination, DestLoc, buttonText0, Font0, callback0, fontBaseline,
                                          config.cornerRadius, config.borderWidth, config.borderColor, fillColor0);
    _ButtonState[1] = new TextButtonState(Destination, DestLoc, buttonText1, Font1, callback1, fontBaseline,
                                          config.cornerRadius, config.borderWidth, config.borderColor, fillColor1);
  };

  ToggleButton(const char *buttonName, Canvas &Destination, const Block_Image &DestLoc,
               ROM_Image ButtonImg0, uint16_t ButtonImgColor0, uint16_t ButtonFillColor0, ButtonState::buttonCallbackFunction callback0,
               ROM_Image ButtonImg1, uint16_t ButtonImgColor1, uint16_t ButtonFillColor1, ButtonState::buttonCallbackFunction callback1,
               const ButtonConfig_t<2> config = DEFAULT_BUTTON_CONFIG)
      : Button{buttonName, Destination, DestLoc.x, DestLoc.y, DestLoc.width, DestLoc.height, Button::callback_type::ON_PRESS}
  {
    _ButtonState[0] = new ImageButtonState(Destination, DestLoc, callback0, ButtonImg0, ButtonImgColor0,
                                           config.cornerRadius, config.borderWidth, config.borderColor, ButtonFillColor0);
    _ButtonState[1] = new ImageButtonState(Destination, DestLoc, callback1, ButtonImg1, ButtonImgColor1,
                                           config.cornerRadius, config.borderWidth, config.borderColor, ButtonFillColor1);
  }

  ~ToggleButton(void) = default;


 
  void begin(void) override;

};
 
/******************************************************************************/
/***                                                                        ***/
/***                Class Definition: MomentaryButton                       ***/
/***                                                                        ***/
/******************************************************************************/
class MomentaryButton : public ToggleButton
{
  // ButtonStates define appearance and functionality of the Button
  static const uint8_t _NUM_STATES = 1;   
  ButtonState *_ButtonState[_NUM_STATES]; 
 
public:
  MomentaryButton(void) = delete;


  MomentaryButton(const char *buttonName, Canvas &Destination, const Block_Image &DestLoc,
                  const char *buttonText0, FontList::FontID Font0, uint16_t fillColor0,
                  const char *buttonText1, FontList::FontID Font1, uint16_t fillColor1,
                  ButtonState::buttonCallbackFunction callback, uint16_t fontBaseline, const ButtonConfig_t<2> config = DEFAULT_BUTTON_CONFIG)
      : ToggleButton(buttonName, Destination, DestLoc,
                     buttonText0, Font0, fillColor0, nullptr, buttonText1, Font1, fillColor1, callback,
                     fontBaseline, config)
  {
    _changeCallback(Button::ON_RELEASE);
  };

  MomentaryButton(const char *buttonName, Canvas &Destination, const Block_Image &DestLoc,
                  ROM_Image ButtonImg0, uint16_t ButtonImgColor0, uint16_t ButtonFillColor0,
                  ROM_Image ButtonImg1, uint16_t ButtonImgColor1, uint16_t ButtonFillColor1,
                  ButtonState::buttonCallbackFunction callback, const ButtonConfig_t<2> config = DEFAULT_BUTTON_CONFIG)
      : ToggleButton(buttonName, Destination, DestLoc,
                     ButtonImg0, ButtonImgColor0, ButtonFillColor0, nullptr, ButtonImg1, ButtonImgColor1, ButtonFillColor1, callback,
                     config)
  {
    _changeCallback(Button::ON_RELEASE);
  };

  ~MomentaryButton(void) = default;


  void release(void) override;
};
 
/******************************************************************************/
/***                                                                        ***/
/***                  Class Definition: TextBoxButton                       ***/
/***                                                                        ***/
/******************************************************************************/
class TextBoxButton : public Button
{
  // ButtonStates that define appearance and functionality of the Button
  static const uint8_t _NUM_STATES = 1;          
  TextBoxButtonState *_ButtonState[_NUM_STATES]; 
 
public:
  TextBoxButton(void) = delete;


  TextBoxButton(const char *buttonName, Canvas &Destination,
                const ConfigTextBox_t &config, ButtonState::buttonCallbackFunction callback)
      : Button(buttonName, Destination, config.x, config.y, config.textWidth + config.UnitsFont, config.shape.height,
               Button::callback_type::ON_RELEASE)
  {
    _ButtonState[0] = new TextBoxButtonState(Destination, config, callback);
  };

  ~TextBoxButton(void) = default;



  void begin(void) override;

  inline void update(const char *text)
  {
    _ButtonState[0]->update(text);
    _ButtonState[0]->draw();
  }

  inline void update(int value)
  {
    _ButtonState[0]->update(value);
    _ButtonState[0]->draw();
  }

  inline void setUnits(const char *text)
  {
    _ButtonState[0]->setUnits(text);
  }

};
 
/******************************************************************************/
/***                                                                        ***/
/***                Class Definition: ImmediateButton                       ***/
/***                                                                        ***/
/******************************************************************************/
/*class ImmediateButton : public Button
{
 
  // Canvases used to store the on/off button imagery. These images are copied
  // onto _DestCanvas as needed.
  static const uint8_t _NUM_STATES = 1;
  const DRAM_Canvas _Img[_NUM_STATES];
 
  // Two callbacks are store (on and off)
  const buttonCallbackFunction _callback;
 
public: */
//  ImmediateButton(void) = delete;


// ImmediateButton(Canvas &DestCanvas, const Block_Image &DestLoc, buttonCallbackFunction callback)
//     : Button(DestCanvas, DestLoc, _Img, _NUM_STATES), _Img{DRAM_Canvas(DestCanvas, DestLoc)}, _callback{callback} {}

//~ImmediateButton(void) = default;



// bool press(FT5316::TouchLocation loc) override;

 
#endif