pebble_graphics_context.hpp

#pragma once
 
#include "pebble.hpp"
 
namespace Pebble {
 
 
class GTextAttributes
{
public:
    GTextAttributes() : text_attributes_(graphics_text_attributes_create()) {};    
 
    operator ::GTextAttributes*() { return text_attributes_; }    
    operator ::GTextAttributes*() const { return text_attributes_; }    
 
    virtual ~GTextAttributes() 
    { 
        graphics_text_attributes_destroy(text_attributes_);
    }
 
    inline void RestoreDefaultTextFlow() { graphics_text_attributes_restore_default_text_flow(text_attributes_); }
 
    inline void EnableScreenTextFlow(uint8_t inset) { graphics_text_attributes_enable_screen_text_flow(text_attributes_, inset); } 
 
    inline void RestoreDefaultPaging() { graphics_text_attributes_restore_default_paging(text_attributes_); }
 
    inline void EnablePaging(GPoint content_origin_on_screen, GRect paging_on_screen) { graphics_text_attributes_enable_paging(text_attributes_, content_origin_on_screen, paging_on_screen); }
 
protected:
    ::GTextAttributes* text_attributes_;
};
 
 
 
class GContext 
{
public:
    GContext(::GContext *ctx) : gcontext_(ctx) {};    
 
    virtual ~GContext() { }
    
    operator ::GContext*() const { return gcontext_; }
 
    inline void SetStrokeColor(GColor color) const { graphics_context_set_stroke_color(gcontext_, color); }
 
    inline void SetFillColor(GColor color) const { graphics_context_set_fill_color(gcontext_, color); }
 
    inline void SetTextColor(GColor color) const { graphics_context_set_text_color(gcontext_, color); }
 
    inline void SetCompositingMode(GCompOp mode) const { graphics_context_set_compositing_mode(gcontext_, mode); }
 
    inline void SetAntialiased(bool enable) const { graphics_context_set_antialiased(gcontext_, enable); }
 
    inline void SetStrokeWidth(uint8_t stroke_width) const { graphics_context_set_stroke_width(gcontext_, stroke_width); }
 
    inline void DrawText(const char* text, GFont const font, const GRect box, const GTextOverflowMode overflow_mode = GTextOverflowModeWordWrap, const GTextAlignment alignment = GTextAlignmentLeft) const
    {
        graphics_draw_text(gcontext_, text, font, box, overflow_mode, alignment, nullptr);
    }
 
    inline void DrawText(const char* text, GFont const font, const GRect box, const GTextOverflowMode overflow_mode, const GTextAlignment alignment, const GTextAttributes& text_attributes ) const
    {
        graphics_draw_text(gcontext_, text, font, box, overflow_mode, alignment, text_attributes);
    }
 
    inline void DrawText(const std::string& text, GFont const font, const GRect box, const GTextOverflowMode overflow_mode = GTextOverflowModeWordWrap, const GTextAlignment alignment = GTextAlignmentLeft) const
    {
        graphics_draw_text(gcontext_, text.c_str(), font, box, overflow_mode, alignment, nullptr);
    }
 
    inline void DrawText(const std::string& text, GFont const font, const GRect box, const GTextOverflowMode overflow_mode, const GTextAlignment alignment, const GTextAttributes& text_attributes) const
    {
        graphics_draw_text(gcontext_, text.c_str(), font, box, overflow_mode, alignment, text_attributes);
    }
 
    static inline GSize GetContentSize(const char* text, GFont const font, const GRect box, const GTextOverflowMode overflow_mode = GTextOverflowModeWordWrap, const GTextAlignment alignment = GTextAlignmentLeft) 
    {
        return graphics_text_layout_get_content_size(text, font, box, overflow_mode, alignment);
    }
 
    static inline GSize GetContentSize(const char* text, GFont const font, const GRect box, const GTextOverflowMode overflow_mode, const GTextAlignment alignment, const GTextAttributes& text_attributes)
    {
        return graphics_text_layout_get_content_size_with_attributes(text, font, box, overflow_mode, alignment, text_attributes);
    }
 
    static inline GSize GetContentSize(const std::string& text, GFont const font, const GRect box, const GTextOverflowMode overflow_mode = GTextOverflowModeWordWrap, const GTextAlignment alignment = GTextAlignmentLeft) 
    {
        return graphics_text_layout_get_content_size(text.c_str(), font, box, overflow_mode, alignment);
    }
 
    static inline GSize GetContentSize(const std::string& text, GFont const font, const GRect box, const GTextOverflowMode overflow_mode, const GTextAlignment alignment, const GTextAttributes& text_attributes) 
    {
        return graphics_text_layout_get_content_size_with_attributes(text.c_str(), font, box, overflow_mode, alignment, text_attributes);
    }
 
    inline void DrawPixel(GPoint point) const { graphics_draw_pixel(gcontext_, point); }
 
    inline void DrawLine(GPoint p0, GPoint p1) const { graphics_draw_line(gcontext_, p0, p1); }
 
    inline void DrawRect(GRect rect) const { graphics_draw_rect(gcontext_, rect); }
 
    inline void FillRect(GRect rect, uint16_t corner_radius, GCornerMask corner_mask) const { graphics_fill_rect(gcontext_, rect, corner_radius, corner_mask); }
 
    inline void DrawCircle(GPoint p, uint16_t radius) const { graphics_draw_circle(gcontext_, p, radius); }
 
    inline void FillCircle(GPoint p, uint16_t radius) const { graphics_fill_circle(gcontext_, p, radius); }
 
    inline void DrawRoundRect(GRect rect, uint16_t radius) const { graphics_draw_round_rect(gcontext_, rect, radius); }
 
    inline void DrawBitmapInRect(const GBitmap& bitmap, GRect rect) const { graphics_draw_bitmap_in_rect(gcontext_, bitmap, rect); }
 
    inline GBitmap CaptureFrameBuffer() { return graphics_capture_frame_buffer(gcontext_); }
    
    inline GBitmap CaptureFrameBuffer(GBitmapFormat format) { return graphics_capture_frame_buffer_format(gcontext_, format); }
 
    inline bool ReleaseFrameBuffer(const GBitmap& buffer) { return graphics_release_frame_buffer(gcontext_, buffer); }
 
    inline bool FrameBufferIsCaptured() { return graphics_frame_buffer_is_captured(gcontext_); }
 
    inline void DrawRotatedBitmap(const GBitmap& src, GPoint src_ic, int rotation, GPoint dest_ic) const 
    { 
        graphics_draw_rotated_bitmap(gcontext_, src, src_ic, rotation, dest_ic); 
    }    
 
    inline void DrawArc(GRect rect, GOvalScaleMode scale_mode, int32_t angle_start, int32_t angle_end) const 
    {
        graphics_draw_arc(gcontext_, rect, scale_mode, angle_start, angle_end);
    }
 
    inline void FillRadial(GRect rect, GOvalScaleMode scale_mode, uint16_t inset_thickness, int32_t angle_start, int32_t angle_end) const 
    { 
        graphics_fill_radial(gcontext_, rect, scale_mode, inset_thickness, angle_start, angle_end);    
    }
 
protected:
    ::GContext* gcontext_;
};
 
 
}