pebble_window.hpp

#pragma once
 
namespace Pebble {
 
// Window callback handler
template<class T, void (T::*Method)(void)>
static void pebble_callback_handler(::Window* window);
 
// Click conflig callback handler
template<class T, void (T::*Method)(const ClickConfig&)>
static void pebble_callback_handler(void* context);
 
// Click callback handler
template<class T, void (T::*Method)(const ClickRecognizer&)>
static void pebble_callback_handler(::ClickRecognizerRef recognizer, void* context);
 
// Numberwindow callback handler
template<class T, void (T::*Method)(void)>
static void pebble_callback_handler(::NumberWindow* window, void* context);
 
 
 
class Window : public Layer
{
public:
    Window(::Window* window) : Layer(window_get_root_layer(window)), window_(window)
    {
    }
 
    virtual ~Window() 
    {
        // Does not destroy the Pebble window has this base class does not take ownership.
    }
    
    operator ::Window*() { return window_; }
 
    inline void StackPush(bool animated) { window_stack_push(window_, animated); }
    
    inline bool StackContainsWindow() const { return window_stack_contains_window(window_); }
    
    inline bool WindowIsTop() { return window_ == window_stack_get_top_window(); }
    
    inline bool StackRemove(bool animated) { return window_stack_remove(window_, animated); } 
 
    inline bool IsLoaded() const { return window_is_loaded(window_); }
 
    inline ::ClickConfigProvider GetClickConfigProvider() const { return window_get_click_config_provider(window_); }
 
    inline void SetBackgroundColor(GColor background_color) { window_set_background_color(window_, background_color); }
 
protected:
    // Private instance of window pebble Window pointer
    ::Window *window_;
 
}; // End Class
 
 
class AppWindow : public Window
{
public:
    AppWindow() : Window(window_create())
    { 
        window_set_user_data(window_, this); 
        window_set_window_handlers(window_, {
            .load = CALLBACK(OnLoad),
            .appear = CALLBACK(OnAppear),
            .disappear = CALLBACK(OnDisappear),
            .unload = CALLBACK(OnUnload)
        });
    }
    
    virtual ~AppWindow() 
    {
        // The assignment to a static variable makes the virtual methods work for subclasses
        // I have no idea why!
        dummy() = 0; 
        window_destroy(window_);    
    }
      
    template<class T>
    static inline T& Get(::Window* window) { return *(T*)(window_get_user_data(window)); } 
      
protected:
    virtual void OnLoad() { }; 
 
    virtual void OnUnload() { }; 
 
    virtual void OnAppear() { }; 
 
    virtual void OnDisappear() { }; 
 
    inline void SetClickConfigProvider(::ClickConfigProvider click_config_provider)
    {
        window_set_click_config_provider_with_context(window_, click_config_provider, this);
    }
 
private:
    // Dummy static variable needed for virutal method pointers to work (see destructor)
    inline static int& dummy() { static int dummy = 0; return dummy; }  
 
}; // End Class
 
 
class NumberWindow : public Window
{
public:
    NumberWindow(const char* label) : Window((::Window*)number_window_create(
            label, 
            {
                .incremented = CALLBACK(OnIncremented),
                .decremented = CALLBACK(OnDecremented),
                .selected = CALLBACK(OnSelected),
            },
            this
        ))
    { 
    }
 
    virtual ~NumberWindow() {
        number_window_destroy((::NumberWindow*)window_);    
    }
    
    operator ::NumberWindow*() { return (::NumberWindow*)window_; }    
    
    inline int32_t GetValue() const { return number_window_get_value((::NumberWindow*)window_); }
    
    inline void SetValue(int32_t value) { number_window_set_value((::NumberWindow*)window_, value); }
    
    inline void SetLabel(const char* label) { number_window_set_label((::NumberWindow*)window_, label); }
    
    inline void SetMin(int32_t min) { number_window_set_min((::NumberWindow*)window_, min); }
 
    inline void SetMax(int32_t max) { number_window_set_max((::NumberWindow*)window_, max); }
    
    inline void SetStepSize(int32_t step) { number_window_set_step_size((::NumberWindow*)window_, step); }
 
protected:
    virtual void OnIncremented() { }; 
 
    virtual void OnDecremented() { }; 
 
    virtual void OnSelected() { }; 
  
}; // End Class
 
// Window callback handler implementation
template<class T, void (T::*Method)(void)>
static void pebble_callback_handler(::Window* window)
{
    (AppWindow::Get<T>(window).*Method)();
}     
 
// Click configuration handler implementation
template<class T, void (T::*Method)(const ClickConfig&)>
static void pebble_callback_handler(void* context)
{
    (((T*)context)->*Method)(ClickConfig());
}       
 
// Click handler implementation
template<class T, void (T::*Method)(const ClickRecognizer&)>
static void pebble_callback_handler(::ClickRecognizerRef recognizer, void* context)
{
    (((T*)context)->*Method)(ClickRecognizer(recognizer));
}   
 
// Number window handler implementation
template<class T, void (T::*Method)(void)>
static void pebble_callback_handler(::NumberWindow* window, void* context)
{
    (((T*)context)->*Method)();
}   
 
 
 
}