pebble_graphics_types.hpp

#pragma once
 
namespace Pebble {
 
struct GSize : public ::GSize
{
    GSize() {}
    
    GSize(const ::GSize &size)
    {
        w = size.w;
        h = size.h;
    }
    
    GSize(int16_t w, int16_t h)
    {
        this->w = w;
        this->h = h;
    }
 
    inline operator const ::GSize*() const { return this; }  
    inline operator ::GSize*()  { return this; }  
 
    inline bool operator== (const ::GSize& size) const { return gsize_equal(this, &size); }
    
    inline bool operator!= (const ::GSize& size) const { return !(*this == size); }
};
 
struct GPoint : public ::GPoint
{
    GPoint() {}
    
    GPoint(const ::GPoint &point)
    {
        x = point.x;
        y = point.y;
    }
    
    GPoint(int16_t x, int16_t y)
    {
        this->x = x;
        this->y = y;
    }    
 
    inline operator const ::GPoint*() const { return this; }  
    inline operator ::GPoint*()  { return this; }  
 
    inline bool operator== (const ::GPoint& point) const { return gpoint_equal(this, &point); }
    
    inline bool operator!= (const ::GPoint& point) const { return !(*this == point); }
};
 
struct GRect 
{
    GPoint origin;
    GSize size;
 
    GRect() {}
    
    GRect(const ::GRect& rect)
    {
        origin.x = rect.origin.x;
        origin.y = rect.origin.y;
        size.w = rect.size.w;
        size.h = rect.size.h;
    }
 
    GRect(int16_t x, int16_t y, int16_t w, int16_t h) {
        origin.x = x;
        origin.y = y;
        size.w = w;
        size.h = h;
    }
    
    GRect(::GPoint origin, ::GSize size) 
    {
        this->origin = origin;
        this->size = size;
    }
    
    GRect(GPoint origin, GSize size)
    {
        this->origin = origin;
        this->size = size;    
    }
    
    inline operator ::GRect&() { return *(::GRect*)this; }    
    inline operator const ::GRect&() const { return *(::GRect*)this; }    
    inline operator ::GRect*() { return (::GRect*)this; }
    inline operator const ::GRect*() const { return (::GRect*)this; }
 
    inline bool operator== (const ::GRect& rect) const { return grect_equal(*this, &rect); }
    
    inline bool operator!= (const ::GRect& rect) const { return !(*this == rect); }   
    
    inline void Align(const ::GRect& inside_rect, const GAlign alignment, const bool clip) { grect_align(*this, &inside_rect, alignment, clip); }
    
    inline GPoint CenterPoint() const { return grect_center_point(*this); }    
 
    inline GRect Inset(GEdgeInsets insets) const { return grect_inset(*this, insets); }
 
    inline bool IsEmpty() { return grect_is_empty(*this); }
 
    inline void Standardize() { grect_standardize(*this); }
 
    inline void Clip(const GRect& rect_clipper) { grect_clip(*this, rect_clipper); }
 
    inline bool ContainsPoint(const GPoint& point) { return grect_contains_point(*this, point); }
 
    inline GRect Crop(int32_t crop_size_px) { return grect_crop(*this, crop_size_px); }
 
    inline GPoint FromPolar(GOvalScaleMode scale_mode, int32_t angle) 
    {
        return gpoint_from_polar(*this, scale_mode, angle);    
    }
 
    inline GRect CenterFromPolar(GOvalScaleMode scale_mode, int32_t angle, GSize size) 
    {
        return grect_centered_from_polar(*this, scale_mode, angle, size);
    }     
};
 
 
class GBitmapBase 
{
public:
    operator ::GBitmap*() const { return gbitmap_; }
 
    virtual ~GBitmapBase() 
    {
    }
 
    inline uint16_t GetBytesPerRow() const { return gbitmap_get_bytes_per_row(gbitmap_); }
 
    inline GBitmapFormat GetFormat() const { return gbitmap_get_format(gbitmap_); }
 
    inline uint8_t* GetData() const { return gbitmap_get_data(gbitmap_); }
 
    inline GRect GetBounds() const { return gbitmap_get_bounds(gbitmap_); }
 
    inline GColor* GetPalette() const { return gbitmap_get_palette(gbitmap_); }
 
protected:
    GBitmapBase() : gbitmap_(nullptr)
    {
    }
 
    GBitmapBase(::GBitmap* gbitmap) : gbitmap_(gbitmap)
    {
    }
 
    // Private instance of window pebble Window pointer
    ::GBitmap *gbitmap_; 
 
    // Allow GBitmap to access the protected members of this class to provide
    // the reference features.
    friend class GBitmap;
}; // End Class
 
 
class GBitmap : public GBitmapBase
{
public:
    GBitmap(::GBitmap* gbitmap) : GBitmapBase(gbitmap)
    {
    }
 
    GBitmap(const GBitmapBase& that) : GBitmapBase(that.gbitmap_)
    {
    }
 
    GBitmap& operator=(const GBitmapBase& that) 
    {
        gbitmap_ = that.gbitmap_;
        return *this;
    }
 
    GBitmap& operator=(::GBitmap* gbitmap)
    {
        gbitmap_ = gbitmap;
        return *this;
    }
 
    inline bool IsValid() { return gbitmap_ != nullptr; }
}; // End Class
 
 
class GOwnedBitmap : public GBitmapBase
{
public:
    GOwnedBitmap() : GBitmapBase() {}
 
    GOwnedBitmap(const GBitmap&) = delete;
    
    GOwnedBitmap(GOwnedBitmap&& that) : GBitmapBase(that.gbitmap_) 
    {
        that.gbitmap_ = nullptr;
    }
 
    GOwnedBitmap& operator=(GOwnedBitmap that) 
    {
        std::swap(gbitmap_, that.gbitmap_);
        return *this;
    }
 
    GOwnedBitmap& operator=(GOwnedBitmap& that) 
    {
        std::swap(gbitmap_, that.gbitmap_);
        return *this;
    }
 
    virtual ~GOwnedBitmap() 
    {
        if (gbitmap_) gbitmap_destroy(gbitmap_);
    }
 
    inline void SetData(uint8_t * data, GBitmapFormat format, uint16_t row_size_bytes, bool free_on_destroy) 
    {
        gbitmap_set_data(gbitmap_, data, format, row_size_bytes, free_on_destroy);
    }
 
    inline void SetBounds(const GRect& bounds) { gbitmap_set_bounds(gbitmap_, bounds); } 
 
    inline void SetPalette(GColor* palette, bool free_on_destroy) { gbitmap_set_palette(gbitmap_, palette, free_on_destroy); }
 
    static inline GOwnedBitmap CreateFromPngData(const uint8_t * png_data, size_t png_data_size) 
    {
        return gbitmap_create_from_png_data(png_data, png_data_size);
    }
 
    static inline GOwnedBitmap CreateSubBitmap(const ::GBitmap* base_bitmap, ::GRect sub_rect)
    {
         return gbitmap_create_as_sub_bitmap(base_bitmap, sub_rect);
    }
    
    static inline GOwnedBitmap CreateWithData(const uint8_t* data) 
    {
        return gbitmap_create_with_data(data);
    }
    
    static inline GOwnedBitmap CreateWithResource(uint32_t resource_id)
    {
        return gbitmap_create_with_resource(resource_id);        
    }
 
    static inline GOwnedBitmap CreateBlank(GSize size, GBitmapFormat format)
    {
        return gbitmap_create_blank(size, format);
    }
 
    static inline GOwnedBitmap CreateBlank(GSize size, GBitmapFormat format, GColor* palette, bool free_on_destroy)
    {
        return gbitmap_create_blank_with_palette(size, format, palette, free_on_destroy);
    }
 
    static inline GOwnedBitmap CreatePalettizedFrom1bit(const ::GBitmap* src_bitmap)
    {
        return gbitmap_create_palettized_from_1bit(src_bitmap);
    }
 
protected:
    GOwnedBitmap(::GBitmap* bitmap) : GBitmapBase(bitmap)
    {
    }
 
}; // End Class
 
 
}