Canvas.h

Go to the documentation of this file.

/******************************************************************************/
 
#ifndef Canvas_DEFINED
#define Canvas_DEFINED
 
#include "ROM_Images.h"
 
/******************************************************************************/
/***                                                                        ***/
/***                     Class Definition: Canvas                           ***/
/***                                                                        ***/
/******************************************************************************/
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, width(), height(), 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 drawRect(unsigned short x0, unsigned short y0, unsigned short x1, unsigned short y1, unsigned short color) const;

  void drawRoundedRect(unsigned short x0, unsigned short y0, unsigned short x1, unsigned short y1,
                       unsigned short color, unsigned short radius, bool fill = false) 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, false);
  };

  inline void BTE_AddImageFrom(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 width, uint16_t height, bool S1OpacityOn=false) const
  {
    const uint8_t ROP = 0x0E; // DT = S0 + S1 (source)
    // Assumes that this object is both S0 and DT
    BTE_ROP(S0, S0_x0, S0_y0, S1, S1_x0, S1_y0, DT_x0, DT_y0, width, height, ROP, S1OpacityOn);
  };

  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_AddTransparentImageFrom(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 void BL_ON(void);
  
  static void BL_OFF(void);

  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                       ***/
/***                                                                        ***/
/******************************************************************************/
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, bool temporary = false);

  ~ROM_Canvas(void) = default;

  void loadImage(void) const override;
};
 
/******************************************************************************/
/***                                                                        ***/
/***                 Class Definition: DRAM_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, bool temporary = false);

  DRAM_Canvas(const Canvas &srcCanvas, const Block_Image imgBlock, bool temporary = false);

  ~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