Canvas.h

Go to the documentation of this file.

/*******************************************************************************
 * @file Canvas.h
 * @brief Defines higher level TFT graphics functionality
 * @details
 * The LT7683 chip can create multiple canvass for holding graphics. Callers
 * can place graphics onto the canvass and they can use the graphics engine
 * of the LT7683 chip to draw geometric shape. When ready, the caller can
 * then signify which canvas is to be diplayed within the TFT window. The
 * Canvas class provides a higher level interface to the LT7683 chip,
 * provides methods for creating, managing, and using canvass.
 ******************************************************************************/
 
#ifndef Canvas_DEFINED
#define Canvas_DEFINED
 
#include "Common.h"
 
/******************************************************************************/
/***                                                                        ***/
/***                     Class Definition: Canvas                           ***/
/***                                                                        ***/
/******************************************************************************
 * @brief Provides higher level TFT graphic functionality used by the menu system
 * @details
 * The LT7683 chip can create multiple canvass for holding graphics. Callers
 * can place graphics onto the canvass and they can use the graphics engine
 * of the LT7683 chip to draw geometric shapes. When ready, the caller can
 * then signify which canvas is to be diplayed within the TFT window. The
 * Canvas class provides a higher level interface to the LT7683 chip,
 * providing methods for creating, managing, and using these canvass.
 ******************************************************************************/
class Canvas
{
 
  const uint16_t _width;        // Width of the canvas
  const uint16_t _height;       // Height of the canvas
  const uint32_t _DRAM_address; // Starting address for the canvas in Display RAM
 
  static uint32_t _nextDRAM_Address; // Keeps track of the next available location in DRAM
 
protected:
  void _validate(void) const;
 
public:

  Canvas(void) : Canvas(false) {};

  Canvas(bool temporary);

  Canvas(uint16_t width, uint16_t height, bool temporary = false);

  ~Canvas(void) = default;


  virtual void loadImage(void) const
  {
    // validate that the width of the image is a multiple of 4.
    _validate();
  };

  void setActive(void) const;

  void setMainWindow(void) const;


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

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

  inline uint32_t address(void) const
  {
    return _DRAM_address;
  }


  static void drawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t color);

  inline void clear(void)
  {
    clear(Black);
  }

  inline void clear(uint16_t color)
  {
    setActive();
    solidFill(0, 0, LCD_XSIZE_TFT, LCD_YSIZE_TFT, color);
  }

  void solidFill(uint16_t x0, uint16_t y0, uint16_t width, uint16_t height, uint16_t color) const;

  void text(uint16_t x0, uint16_t y0, uint16_t fColor, uint16_t bColor, const char *text, bool small = false) const;

  void drawSquare(unsigned short x0, unsigned short y0, unsigned short x1, unsigned short y1, unsigned short color) const;


  void BTE_CopyFrom(const Canvas &source) const;

  void BTE_CopyFrom(const Canvas &source, uint16_t DT_x0, uint16_t DT_y0) const;

  void BTE_ROP(const Canvas &S0, uint16_t S0_x0, uint16_t S0_y0,
               const Canvas &S1, uint16_t S1_x0, uint16_t S1_y0,
               uint16_t DT_x0, uint16_t DT_y0, uint16_t DT_width, uint16_t DT_height,
               uint8_t ROP, bool S1_OpacityOn = false) const;

  inline void BTE_CopyFrom(const Canvas &source, uint16_t Src_x0, uint16_t Src_y0, uint16_t DT_x0, uint16_t DT_y0, uint16_t width, uint16_t height) const
  {
    const uint8_t ROP = 0x0C; // DT = S0 (source)
    BTE_ROP(source, Src_x0, Src_y0, source, Src_x0, Src_y0, DT_x0, DT_y0, width, height, ROP);
  };

  inline void BTE_AddImageFrom(const Canvas &source, uint16_t Src_x0, uint16_t Src_y0,
                               uint16_t DT_x0, uint16_t DT_y0, uint16_t width, uint16_t height) const
  {
    const uint8_t ROP = 0x0E; // DT = S0 + S1 (source)
    // Assumes that this object is both S0 and DT
    BTE_ROP(*this, DT_x0, DT_y0, source, Src_x0, Src_y0, DT_x0, DT_y0, width, height, ROP, false);
  };

  inline void BTE_AddTransparantImageFrom(const Canvas &source, uint16_t Src_x0, uint16_t Src_y0, uint16_t DT_x0, uint16_t DT_y0, uint16_t width, uint16_t height) const
  {
    const uint8_t ROP = 0x0E; // DT = S0 + S1 (source)
    // Assumes that this object is both S0 and DT
    BTE_ROP(*this, DT_x0, DT_y0, source, Src_x0, Src_y0, DT_x0, DT_y0, width, height, ROP, true);
  };


  static inline void BL_ON(void)
  {
    digitalWrite(TFT_BL, HIGH);
  };

  static inline void BL_OFF(void)
  {
    digitalWrite(TFT_BL, LOW);
  };

  static inline uint32_t nextAddress(void)
  {
    return _nextDRAM_Address;
  }
 
protected:
  void BTE_SetAsS0(uint16_t x0, uint16_t y0) const;

  void BTE_SetAsS1(uint16_t x0, uint16_t y0) const;

  void BTE_SetAsDT(uint16_t x0, uint16_t y0) const;
};
 
/******************************************************************************/
/***                                                                        ***/
/***                     Class Definition: ROM_Canvas                       ***/
/***                                                                        ***/
/******************************************************************************
 * @brief A variation of the Canvas class that can load imagery from Flash ROM
 * @details
 *   Note that this class assumes that the imagery in Flash ROM is in
 *   16 bpp color format.
 ******************************************************************************/
class ROM_Canvas : public Canvas
{
 
  uint32_t _ROM_Address; // Starting address of the image in Flash ROM
 
public:
  ROM_Canvas(void) = delete;

  ROM_Canvas(ROM_Image image);

  ~ROM_Canvas(void) = default;

  void loadImage(void) const override;
};
 
/******************************************************************************/
/***                                                                        ***/
/***                 Class Definition: DRAM_Canvas                          ***/
/***                                                                        ***/
/******************************************************************************
 * @brief Variation of the Canvas class that can copy imagery from
 * another canvas
 ******************************************************************************/
class DRAM_Canvas : public Canvas
{
 
  const Canvas &_srcCanvas;    // Canvas containing the source imagery
  const Block_Image _imgBlock; // The image block within _srcCanvas that is
                               // to be copied over
 
public:
  DRAM_Canvas(void) = delete;

  DRAM_Canvas(const Canvas &srcCanvas);

  DRAM_Canvas(const Canvas &srcCanvas, const Block_Image imgBlock);

  ~DRAM_Canvas(void) = default;

  void loadImage(void) const override;
};
 
/******************************************************************************/
/***                                                                        ***/
/***                           Support Functions                            ***/
/***                                                                        ***/
/******************************************************************************/

template <typename T>
inline T nearest4(T num)
{
  return static_cast<T>(ceil(num / 4.0) * 4);
};
 
#endif