Button.h

Go to the documentation of this file.

/*******************************************************************************
 * @file Button.h
 * @brief Defines the Button classes used by the Menu system
 ******************************************************************************/
 
#ifndef BUTTON_INCLUDED
#define BUTTON_INCLUDED
 
#include "Canvas.h"
 
/******************************************************************************/
/***                                                                        ***/
/***                 Class Definition: Button                               ***/
/***                                                                        ***/
/******************************************************************************
 * @brief Provides buttons for the menu system
 * @details
 *    This is the base class for all buttons. Derived classes are expected to
 *    provide the images for the button states. This class manages the button
 *    state and the copying of the button imagery onto the destination canvas.
 *    The derived classes are responsible for providing callback functions.
 ******************************************************************************/
class Button
{
 
  bool _enabled = false; // Determines whether the button is enabled
  uint8_t _state = 0;    // Tracks the state of the button
  uint8_t _maxState;     // The maximum allowed value for _state
 
  // Destimation where the button should be copied
  Canvas &_DestCanvas;
  const uint16_t _DestX;
  const uint16_t _DestY;
 
  // Array of canvases that store the imagery by each button state. These images are
  // provided by derived classes. This class only uses these images.
  const DRAM_Canvas *_Img;
 
  // Internal method for copying the button image for the current _state onto the
  // destination canvas
  inline void _updateDestCanvas(void)
  {
    _Img[_state].BTE_CopyFrom(_Img[_state], 0, 0, _DestX, _DestY, width(), height());
  }
 
  // Validates that this object is well formed
  bool _validateObject(void);
 
public:
  Button(void) = delete;


  Button(Canvas &DestCanvas, const Block_Image &DestLoc, const DRAM_Canvas *Imgs, uint8_t maxNumStates)
      : _maxState{maxNumStates},
        _DestCanvas{DestCanvas},
        _DestX{DestLoc.x},
        _DestY{DestLoc.y},
        _Img{Imgs} {}

  ~Button(void) = default;


  typedef void (*callback_function)(void);


  void begin(void);

  virtual bool press(FT5316::TouchLocation loc);

  virtual void release(void) {};

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

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



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

  inline uint16_t width(void) const
  {
    return _Img[0].width();
  }

  inline uint16_t height(void) const
  {
    return _Img[0].height();
  }

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

 
protected:
  void _resetToState0(void)
  {
    _state = 0;
    _DestCanvas.BTE_CopyFrom(_Img[_state], _DestX, _DestY);
  }
};
 
/******************************************************************************/
/***                                                                        ***/
/***                 Class Definition: ToggleButton                         ***/
/***                                                                        ***/
/******************************************************************************
 * @brief Defines a button that toggles between two states.
 * @details
 *    Each state has its own image and callback function. The callback function
 *    is called when when the users releases the button.
 ******************************************************************************/
class ToggleButton : 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 = 2;
  const DRAM_Canvas _Img[_NUM_STATES];
 
  // Two callbacks functions are used: Botton on/off
  const callback_function _callback[_NUM_STATES];
 
public:
  ToggleButton(void) = delete;


  ToggleButton(Canvas &DestCanvas, const Block_Image &DestLoc,
               callback_function Img0Callback,
               callback_function Img1Callback)
      : Button(DestCanvas, DestLoc, _Img, _NUM_STATES),
        _Img{DRAM_Canvas(DestCanvas), DRAM_Canvas(DestCanvas)},
        _callback{Img0Callback, Img1Callback} {}

  ~ToggleButton(void) = default;



  bool press(FT5316::TouchLocation loc) override;

};
 
/******************************************************************************/
/***                                                                        ***/
/***                Class Definition: MomentaryButton                       ***/
/***                                                                        ***/
/******************************************************************************
 * @brief Momentary buttons have 2 states. Upon release, the button returns to state 0.
 * @details
 *    This button has two images (pressed and unpressed). The button's single
 *    callback function is called when the button is released.
 ******************************************************************************/
class MomentaryButton : 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 = 2;
  const DRAM_Canvas _Img[_NUM_STATES];
 
  // A single callback is used
  const callback_function _callback;
 
public:
  MomentaryButton(void) = delete;


  MomentaryButton(Canvas &DestCanvas, const Block_Image &DestLoc,
                  callback_function callback)
      : Button(DestCanvas, DestLoc, _Img, _NUM_STATES),
        _Img{DRAM_Canvas(DestCanvas), DRAM_Canvas(DestCanvas)},
        _callback{callback} {}

  ~MomentaryButton(void) = default;



  virtual void release(void)
  {
    if (state() == 1)
    {
      _resetToState0();
      _callback();
    }
  };

};
 
/******************************************************************************/
/***                                                                        ***/
/***                Class Definition: ImmediateButton                       ***/
/***                                                                        ***/
/******************************************************************************
 * @brief A single state button that calls the callback function as soon as it is pressed
 * @note
 *    There is no imagery associated with an immediate button. It is assumed that
 *    the desitination canvas already has appropriate imagery in place to indicate
 *    to the user where the button is located.
 ******************************************************************************/
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 callback_function _callback;
 
public:
  ImmediateButton(void) = delete;


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

  ~ImmediateButton(void) = default;



  bool press(FT5316::TouchLocation loc) override;

};
 
#endif