Canvas.hh

Go to the documentation of this file.

#ifndef COSA_CANVAS_HH
#define COSA_CANVAS_HH

#include "Cosa/Types.h"

// Forward declaration of default system font
class Font;
class System5x7;
extern System5x7 system5x7;

class Canvas {
public:
  union color16_t {
    uint16_t rgb;
    struct {
      unsigned int blue:5;
      unsigned int green:6;
      unsigned int red:5;
    };

    color16_t()
    {
      rgb = 0;
    }

    color16_t(uint16_t color)
    {
      rgb = color;
    }

    color16_t(uint8_t r, uint8_t g, uint8_t b)
    {
      red = r >> 3;
      green = g >> 2;
      blue = b >> 3;
    }

    operator uint16_t()
    {
      return (rgb);
    }
  };

  enum {
    BLACK = 0x0000U,
    WHITE = 0xFFFFU,
    RED = 0xF800U,
    GREEN = 0x07E0U,
    BLUE = 0x001FU,
    YELLOW = RED + GREEN,
    CYAN = GREEN + BLUE,
    MAGENTA = RED + BLUE
  };

  struct pos16_t {
    uint16_t x;
    uint16_t y;
  };

  struct rect16_t {
    uint16_t x;
    uint16_t y;
    uint16_t width;
    uint16_t height;
  };

  struct circle16_t {
    uint16_t x;
    uint16_t y;
    uint16_t radius;
  };

  class Context {
  public:
    Context(Font* font = (Font*) &system5x7) :
      m_pen_color(BLACK),
      m_canvas_color(WHITE),
      m_text_color(BLACK),
      m_text_scale(1),
      m_font(font)
    {
      set_cursor(0, 0);
    }

    color16_t get_canvas_color() const
    {
      return (m_canvas_color);
    }

    color16_t set_canvas_color(color16_t color)
    {
      color16_t previous = m_canvas_color;
      m_canvas_color = color;
      return (previous);
    }

    color16_t get_pen_color() const
    {
      return (m_pen_color);
    }

    color16_t set_pen_color(color16_t color)
    {
      color16_t previous = m_pen_color;
      m_pen_color = color;
      return (previous);
    }

    color16_t get_text_color() const
    {
      return (m_text_color);
    }

    color16_t set_text_color(color16_t color)
    {
      color16_t previous = m_text_color;
      m_text_color = color;
      return (previous);
    }

    Font* get_text_font() const
    {
      return (m_font);
    }

    Font* set_text_font(Font* font)
    {
      Font* previous = m_font;
      m_font = font;
     return (previous);
    }

    uint8_t get_text_scale() const
    {
      return (m_text_scale);
    }

    uint8_t set_text_scale(uint8_t scale)
    {
      uint8_t previous = m_text_scale;
      m_text_scale = (scale > 0 ? scale : 1);
      return (previous);
    }

    void get_cursor(uint16_t& x, uint16_t& y) const
    {
      x = m_cursor.x;
      y = m_cursor.y;
    }

    void set_cursor(uint16_t x, uint16_t y)
    {
      m_cursor.x = x;
      m_cursor.y = y;
    }

    void move_cursor(int16_t dx, int16_t dy)
    {
      m_cursor.x += dx;
      m_cursor.y += dy;
    }

  protected:
    color16_t m_pen_color;      
    color16_t m_canvas_color;   
    color16_t m_text_color;     
    uint8_t m_text_scale;       
    Font* m_font;               
    pos16_t m_cursor;           
  };

  class Element : public Context {
  public:
    Element(Canvas* canvas, Font* font = (Font*) &system5x7) :
      Context(font),
      m_canvas(canvas)
    {
    }
  protected:
    Canvas* m_canvas;
  };

  class Image {
  public:
    uint16_t WIDTH;

    uint16_t HEIGHT;

    Image(uint16_t width = 0, uint16_t height = 0) :
      WIDTH(width),
      HEIGHT(height)
    {}

    virtual bool read(color16_t* buf, size_t count) = 0;

    static const size_t BUFFER_MAX = 32;
  };

  uint16_t WIDTH;
  uint16_t HEIGHT;
  enum {
    PORTRAIT = 0,
    LANDSCAPE = 1,
  } __attribute__((packed));

  Canvas(uint16_t width, uint16_t height, Context* context = &Canvas::context) :
    WIDTH(width),
    HEIGHT(height),
    m_context(context),
    m_direction(PORTRAIT)
  {
  }

  virtual bool begin() = 0;

  Context* get_context() const
  {
    return (m_context);
  }

  Context* set_context(Context* context)
  {
    Context* previous = m_context;
    m_context = context;
    return (previous);
  }

  color16_t get_canvas_color() const
  {
    return (m_context->get_canvas_color());
  }

  color16_t set_canvas_color(color16_t color)
  {
    return (m_context->set_canvas_color(color));
  }

  color16_t get_pen_color() const
  {
    return (m_context->get_pen_color());
  }

  color16_t set_pen_color(color16_t color)
  {
    return (m_context->set_pen_color(color));
  }

  color16_t get_text_color() const
  {
    return (m_context->get_text_color());
  }

  color16_t set_text_color(color16_t color)
  {
    return (m_context->set_text_color(color));
  }

  Font* get_text_font() const
  {
    return (m_context->get_text_font());;
  }

  Font* set_text_font(Font* font)
  {
    return (m_context->set_text_font(font));
  }

  uint8_t get_text_scale() const
  {
    return (m_context->get_text_scale());
  }

  uint8_t set_text_scale(uint8_t scale)
  {
    return (m_context->set_text_scale(scale));
  }

  void get_cursor(uint16_t& x, uint16_t& y) const
  {
    m_context->get_cursor(x, y);
  }

  void set_cursor(uint16_t x, uint16_t y)
  {
    m_context->set_cursor(x, y);
  }

  void move_cursor(int16_t dx, int16_t dy)
  {
    m_context->move_cursor(dx, dy);
  }

  color16_t color(uint8_t red, uint8_t green, uint8_t blue)
  {
    return (color16_t(red, green, blue));
  }

  static color16_t shade(color16_t color, uint8_t scale);

  static color16_t blend(color16_t c1, color16_t c2);

  virtual uint8_t get_orientation();

  virtual uint8_t set_orientation(uint8_t direction);

  virtual void draw_pixel(uint16_t x, uint16_t y);

  void draw_pixel()
  {
    uint16_t x, y;
    get_cursor(x, y);
    draw_pixel(x, y);
  }

  virtual void draw_bitmap(uint16_t x, uint16_t y, const uint8_t* bp,
                           uint16_t width, uint16_t height,
                           uint8_t scale = 1);

  void draw_bitmap(const uint8_t* bp,
                   uint16_t width, uint16_t height,
                   uint8_t scale = 1)
  {
    uint16_t x, y;
    get_cursor(x, y);
    draw_bitmap(x, y, bp, width, height, scale);
  }

  virtual void draw_icon(uint16_t x, uint16_t y, const uint8_t* bp,
                         uint16_t width, uint16_t height,
                         uint8_t scale = 1);

  virtual void draw_icon(uint16_t x, uint16_t y, const uint8_t* bp,
                         uint8_t scale = 1);

  void draw_icon(const uint8_t* bp, uint8_t scale = 1)
  {
    uint16_t width = pgm_read_byte(bp++);
    uint16_t height = pgm_read_byte(bp++);
    uint16_t x, y;
    get_cursor(x, y);
    draw_icon(x, y, bp, width, height, scale);
  }

  virtual void draw_image(uint16_t x, uint16_t y, Image* image);

  void draw_image(Image* image)
  {
    uint16_t x, y;
    get_cursor(x, y);
    draw_image(x, y, image);
  }

  virtual void draw_line(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1);

  void draw_line(uint16_t x1, uint16_t y1)
  {
    uint16_t x0, y0;
    get_cursor(x0, y0);
    draw_line(x0, y0, x1, y1);
    set_cursor(x1, y1);
  }

  virtual void draw_vertical_line(uint16_t x, uint16_t y, uint16_t length);

  void draw_vertical_line(uint16_t length)
  {
    uint16_t x, y;
    get_cursor(x, y);
    draw_line(x, y + length);
  }

  virtual void draw_horizontal_line(uint16_t x, uint16_t y, uint16_t length);

  void draw_horizontal_line(uint16_t length)
  {
    uint16_t x, y;
    get_cursor(x, y);
    draw_line(x + length, y);
  }

  virtual void draw_poly_P(const int8_t* poly, uint8_t scale = 1);

  virtual void draw_stroke_P(const int8_t* stroke, uint8_t scale = 1);

  virtual void draw_rect(uint16_t x, uint16_t y, uint16_t width, uint16_t height);

  void draw_rect(uint16_t width, uint16_t height)
  {
    uint16_t x, y;
    get_cursor(x, y);
    draw_rect(x, y, width, height);
  }

  virtual void fill_rect(uint16_t x, uint16_t y, uint16_t width, uint16_t height);

  void fill_rect(uint16_t width, uint16_t height)
  {
    uint16_t x, y;
    get_cursor(x, y);
    fill_rect(x, y, width, height);
  }

  virtual void draw_roundrect(uint16_t x, uint16_t y,
                              uint16_t width, uint16_t height,
                              uint16_t radius);

  void draw_roundrect(uint16_t width, uint16_t height, uint16_t radius)
  {
    uint16_t x, y;
    get_cursor(x, y);
    draw_roundrect(x, y, width, height, radius);
  }

  virtual void fill_roundrect(uint16_t x, uint16_t y,
                              uint16_t width, uint16_t height,
                              uint16_t radius);

  void fill_roundrect(uint16_t width, uint16_t height, uint16_t radius)
  {
    uint16_t x, y;
    get_cursor(x, y);
    fill_roundrect(x, y, width, height, radius);
  }

  virtual void draw_circle(uint16_t x, uint16_t y, uint16_t radius);

  void draw_circle(uint16_t radius)
  {
    uint16_t x, y;
    get_cursor(x, y);
    draw_circle(x, y, radius);
  }

  virtual void fill_circle(uint16_t x, uint16_t y, uint16_t radius);

  void fill_circle(uint16_t radius)
  {
    uint16_t x, y;
    get_cursor(x, y);
    fill_circle(x, y, radius);
  }

  virtual void draw_char(uint16_t x, uint16_t y, char c);

  void draw_char(char c)
  {
    uint16_t x, y;
    get_cursor(x, y);
    draw_char(x, y, c);
  }

  virtual void draw_string(char* s);

  virtual void draw_string(str_P s);

  virtual void fill_screen();

  virtual bool end() = 0;

  enum {
    END_SCRIPT = 0,
    CALL_SCRIPT,
    SET_CANVAS_COLOR,
    SET_PEN_COLOR,
    SET_TEXT_COLOR,
    SET_TEXT_SCALE,
    SET_TEXT_FONT,
    SET_CURSOR,
    MOVE_CURSOR,
    DRAW_BITMAP,
    DRAW_ICON,
    DRAW_PIXEL,
    DRAW_LINE,
    DRAW_POLY,
    DRAW_STROKE,
    DRAW_RECT,
    FILL_RECT,
    DRAW_ROUNDRECT,
    FILL_ROUNDRECT,
    DRAW_CIRCLE,
    FILL_CIRCLE,
    DRAW_CHAR,
    DRAW_STRING,
    FILL_SCREEN
  } __attribute__((packed));

  void run(uint8_t ix, const void_P* tab, uint8_t max);

protected:
  static Context context;

  Context* m_context;

  uint8_t m_direction;
};

#define CANVAS_BEGIN_SCRIPT(name) const uint8_t name[] __PROGMEM = {
#define CANVAS_CALL_SCRIPT(ix) Canvas::CALL_SCRIPT, ix,
#define CANVAS_SET_CANVAS_COLOR(r, g, b) Canvas::SET_CANVAS_COLOR, r, g, b,
#define CANVAS_SET_PEN_COLOR(r, g, b) Canvas::SET_PEN_COLOR, r, g, b,
#define CANVAS_SET_TEXT_COLOR(r, g, b) Canvas::SET_TEXT_COLOR, r, g, b,
#define CANVAS_SET_TEXT_SCALE(s) Canvas::SET_TEXT_SCALE, s,
#define CANVAS_SET_TEXT_PORT(x, y, w, h) Canvas::SET_TEXT_PORT, x, y, w, h,
#define CANVAS_SET_TEXT_FONT(ix) Canvas::SET_TEXT_FONT, ix,
#define CANVAS_SET_CURSOR(x, y) Canvas::SET_CURSOR, x, y,
#define CANVAS_MOVE_CURSOR(dx, dy) Canvas::MOVE_CURSOR, (uint8_t) dx, (uint8_t) dy,
#define CANVAS_DRAW_BITMAP(ix, w, h, s) Canvas::DRAW_BITMAP, ix, w, h, s,
#define CANVAS_DRAW_ICON(ix, s) Canvas::DRAW_ICON, ix, s,
#define CANVAS_DRAW_PIXEL() Canvas::DRAW_PIXEL,
#define CANVAS_DRAW_LINE(x, y) Canvas::DRAW_LINE, x, y,
#define CANVAS_DRAW_POLY(ix, s) Canvas::DRAW_POLY, ix, s,
#define CANVAS_DRAW_STROKE(ix, s) Canvas::DRAW_STROKE, ix, s,
#define CANVAS_DRAW_RECT(w, h) Canvas::DRAW_RECT, w, h,
#define CANVAS_FILL_RECT(w, h) Canvas::FILL_RECT, w, h,
#define CANVAS_DRAW_ROUNDRECT(w, h, r) Canvas::DRAW_ROUNDRECT, w, h, r,
#define CANVAS_FILL_ROUNDRECT(w, h, r) Canvas::FILL_ROUNDRECT, w, h, r,
#define CANVAS_DRAW_CIRCLE(r) Canvas::DRAW_CIRCLE, r,
#define CANVAS_FILL_CIRCLE(r) Canvas::FILL_CIRCLE, r,
#define CANVAS_DRAW_CHAR(c) Canvas::DRAW_CHAR, c,
#define CANVAS_DRAW_STRING(ix) Canvas::DRAW_STRING, ix,
#define CANVAS_FILL_SCREEN() Canvas::FILL_SCREEN,
#define CANVAS_END_SCRIPT Canvas::END_SCRIPT };

#endif