definterface.h

Go to the documentation of this file.

#ifndef _DEFINTERFACE_H_
#define _DEFINTERFACE_H_

#include "plugin.h"
#include "events.h"

#include <wx/frame.h>
#include <wx/bitmap.h>
#include <wx/pen.h>
#include <wx/brush.h>

//#include <list>
//#include <vector>

#define IFM_FLOATING_FRAME_STYLE wxFRAME_NO_TASKBAR | wxFRAME_FLOAT_ON_PARENT | wxRESIZE_BORDER | wxSYSTEM_MENU | wxCLOSE_BOX

#define IFM_CAPTION_PAD 1 

#define IFM_COMPONENT_BUTTON_X    10
#define IFM_COMPONENT_BUTTON_Y    11
#define IFM_COMPONENT_BUTTON_PAD  2

#define IFM_COMPONENT_ID_CLOSE      0
#define IFM_COMPONENT_ID_MAXIMIZE   1
#define IFM_COMPONENT_ID_MINIMIZE   2

#define IFM_CONTAINER_GRIPPER_WIDTH 0

class wxIFMDefaultInterfacePlugin;
class wxIFMFloatingFrame;
class wxIFMDefaultContainerPlugin;
class wxIFMDefaultPanelPlugin;
class wxIFMContainerData;
class wxIFMPanelTabData;
class wxIFMAddTopContainerEvent;
class wxIFMRemoveTopContainerEvent;
class wxIFMSelectTabEvent;
class wxIFMComponentButton;
class wxIFMComponentButtonManager;
class wxIFMComponentButtonEvent;
class wxIFMTab;

//typedef std::list<wxIFMComponent *> wxIFMComponentList;
WX_DECLARE_LIST(wxIFMComponent, wxIFMComponentList);

// typedef std::vector<wxIFMComponentButton *> wxIFMComponentButtonArray;
WX_DEFINE_ARRAY(wxIFMComponentButton *, wxIFMComponentButtonArray);
WX_DEFINE_ARRAY(wxIFMTab *, wxIFMTabArray);

// component data keys
DECLARE_IFM_DATA_KEY(IFM_CONTAINER_DATA_KEY)
DECLARE_IFM_DATA_KEY(IFM_PANEL_DATA_KEY)
DECLARE_IFM_DATA_KEY(IFM_TABBED_PANEL_DATA_KEY)

#define IFM_ORIENTATION_DEFAULT -1 
#define IFM_ORIENTATION_NONE    0 
#define IFM_ORIENTATION_TOP     1 
#define IFM_ORIENTATION_BOTTOM  2 
#define IFM_ORIENTATION_LEFT    3 
#define IFM_ORIENTATION_RIGHT   4 
#define IFM_ORIENTATION_FLOAT   5 
#define IFM_ORIENTATION_DOCKED  6 

DECLARE_IFM_COMPONENT_TYPE(IFM_COMPONENT_CONTAINER)
DECLARE_IFM_COMPONENT_TYPE(IFM_COMPONENT_PANEL_TAB)
DECLARE_IFM_COMPONENT_TYPE(IFM_COMPONENT_PANEL) // a component that manages a group of panel tabs

DECLARE_EVENT_TYPE(wxEVT_IFM_ADDTOPCONTAINER, 0);
DECLARE_EVENT_TYPE(wxEVT_IFM_REMOVETOPCONTAINER, 0);
DECLARE_EVENT_TYPE(wxEVT_IFM_SELECTTAB, 0);
DECLARE_EVENT_TYPE(wxEVT_IFM_COMPONENTBUTTONCLICK, 0);

#if IFM_CANFLOAT

class wxIFMFloatingFrame : public wxIFMFloatingWindowBase
{
public:

    wxIFMFloatingFrame(wxIFMInterfacePluginBase *ip,
        wxWindow *parent, wxWindowID id, const wxString& title, const wxPoint& pos = wxDefaultPosition,
        const wxSize& size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE,
        const wxString& name = wxFrameNameStr);

    ~wxIFMFloatingFrame() {}

    void OnClose(wxCloseEvent &event);

    DECLARE_EVENT_TABLE()
};

#endif

class wxIFMDefaultInterfacePlugin : public wxIFMInterfacePluginBase
{
public:

    wxIFMDefaultInterfacePlugin();
    ~wxIFMDefaultInterfacePlugin();

    bool Initialize(wxInterfaceManager *manager);

    const wxIFMComponentList &GetTopContainerList() const;

    bool ProcessPluginEvent(wxIFMPluginEvent &event);

    wxIFMComponent *GetContainer(int orientation);

    wxIFMComponent *GetComponentByPos(const wxPoint &pos, wxIFMComponent *component = NULL, bool floating = false);

private:

    wxIFMComponentList m_containers;

    void OnDeleteComponent(wxIFMDeleteComponentEvent &event);
    void OnAddChild(wxIFMAddChildEvent &event);
    void OnUpdate(wxIFMUpdateEvent &event);
    void OnPaint(wxIFMPaintInterfaceEvent &event);
    void OnGetContentRect(wxIFMRectEvent &event);

    void OnAddTopContainer(wxIFMAddTopContainerEvent &event);
    void OnRemoveTopContainer(wxIFMRemoveTopContainerEvent &event);

#if IFM_CANFLOAT
    void OnCreateFloatingWindow(wxIFMCreateFloatingWindowEvent &event);
    void OnDestroyFloatingWindow(wxIFMDestroyFloatingWindowEvent &event);
    void OnFloat(wxIFMFloatEvent &event);
#endif

    DECLARE_EVENT_TABLE()

#if IFM_USE_WX_RTTI
    DECLARE_DYNAMIC_CLASS_NO_COPY(wxIFMDefaultInterfacePlugin)
#endif
};

class wxIFMDefaultContainerPlugin : public wxIFMExtensionPluginBase
{
public:

    wxIFMDefaultContainerPlugin();

private:

    /*
    Event handlers
    */
    void OnCreateComponent(wxIFMNewComponentEvent &event);
    void OnDock(wxIFMDockEvent &event);
    void OnUndock(wxIFMUndockEvent &event);
    void OnUpdate(wxIFMUpdateComponentEvent &event);
    void OnVisibilityChange(wxIFMComponentVisibilityChangedEvent &event);
    void OnShowComponent(wxIFMShowComponentEvent &event);
    void OnLeftDown(wxIFMMouseEvent &event);

#if IFM_CANFLOAT
    void OnFloatNotify(wxIFMFloatNotifyEvent &event);
    void UpdateFloatingCaption(wxIFMComponent *container);
#endif

    void OnGetDesiredSize(wxIFMRectEvent &event);
    void OnSetDesiredSize(wxIFMRectEvent &event);
    void OnGetRect(wxIFMRectEvent &event);

    void OnPaintDecor(wxIFMPaintEvent &event);

    void OnComponentButtonClick(wxIFMComponentButtonEvent &event);

    bool HasVisibleChildren(wxIFMComponent *component);

    bool HasNonCloseableChildren(wxIFMComponent *component);

    int GetVisibleChildrenCount(wxIFMComponent *component);

    DECLARE_EVENT_TABLE()

#if IFM_USE_WX_RTTI
    DECLARE_DYNAMIC_CLASS_NO_COPY(wxIFMDefaultContainerPlugin)
#endif
};

struct wxIFMTabConfig
{
    wxFont font;
    wxColour font_color;
    int font_height;
    int row_height;
    int row_indent;
    int tab_height;
    int tab_padding;
    int tab_spacing;
    int rounding_factor;

    wxPen tab_border_p;// = wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNSHADOW)); 
    
    wxBrush tab_active_bg_b;// = wxBrush(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNHIGHLIGHT)); 
    wxPen tab_active_bg_p;// = wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNHIGHLIGHT));
    
    wxBrush tab_inactive_bg_b;// = wxBrush(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE)); 
    wxPen tab_inactive_bg_p;// = wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE));
    
    wxBrush bg_brush;// = wxBrush(wxSystemSettings::GetColour(wxSYS_COLOUR_3DLIGHT)); 
    wxPen bg_pen;// = wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DLIGHT)); 
    wxPen line_pen;// = wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNSHADOW)); 
};

struct wxIFMCaptionConfig
{
    wxFont font;
    wxColour color;
    int font_height;
    int height;
    int padding;
};

class wxIFMDefaultPanelPlugin : public wxIFMExtensionPluginBase
{
public:
    
    wxIFMDefaultPanelPlugin() : wxIFMExtensionPluginBase() {}
    bool Initialize(wxIFMInterfacePluginBase *plugin);

private:

    wxIFMCaptionConfig m_caption_config;
    wxIFMTabConfig m_tab_config;

    void OnCreateComponent(wxIFMNewComponentEvent &event);
    void OnDestroyComponent(wxIFMDeleteComponentEvent &event);
    void OnSetChild(wxIFMSetChildEvent &event);
    void OnQueryChild(wxIFMQueryChildEvent &event);
    void OnUpdate(wxIFMUpdateComponentEvent &event);
    void OnVisibilityChanged(wxIFMComponentVisibilityChangedEvent &event);
    void OnShowComponent(wxIFMShowComponentEvent &event);
    void OnPaintDecor(wxIFMPaintEvent &event);
    void OnPaintBg(wxIFMPaintEvent &event);
    void OnLeftDown(wxIFMMouseEvent &event);
    void OnLeftUp(wxIFMMouseEvent &event);
    void OnMouseMove(wxIFMMouseEvent &event);
    void OnDock(wxIFMDockEvent &event);
    void OnUndock(wxIFMUndockEvent &event);
    void OnComponentButtonClick(wxIFMComponentButtonEvent &event);
    
    void OnSelectTab(wxIFMSelectTabEvent &event);
    void OnGetDesiredSize(wxIFMRectEvent &event);
    void OnSetDesiredSize(wxIFMRectEvent &event);
    void OnGetMinSize(wxIFMRectEvent &event);
    void OnGetMaxSize(wxIFMRectEvent &event);

    void DrawTabs(wxDC &dc, wxIFMComponent *component, const wxRegion &region, const wxIFMTabArray &tabs);

#if IFM_CANFLOAT
    void OnFloatNotify(wxIFMFloatNotifyEvent &event);
#endif

    DECLARE_EVENT_TABLE()

#if IFM_USE_WX_RTTI
    DECLARE_DYNAMIC_CLASS_NO_COPY(wxIFMDefaultPanelPlugin)
#endif
};

class wxIFMComponentButtonManager
{
private:
    wxPoint m_pos;
    int m_height;
    wxIFMInterfacePluginBase *m_ip;
    wxIFMComponent *m_component;
    bool m_hidden;

public:

    wxIFMComponentButtonArray m_buttons;

    wxIFMComponentButtonManager(wxIFMInterfacePluginBase *ip, wxIFMComponent *component);
    ~wxIFMComponentButtonManager();

    wxIFMInterfacePluginBase *GetIP();
    wxIFMComponent *GetComponent();

    wxIFMComponentButton *AddButton(int id);

    void RemoveButton(int id);

    wxIFMComponentButton *GetButton(int id);

    const wxRect GetRect() const;

    const wxPoint &GetPosition() const;

    void SetPosition(const wxPoint& pos);

    void SetHeight(int height);

    void Show(bool show = true);
    void Hide();

    void Show(bool show, int id);

    void SetParent(wxWindow *parent);

    void Layout();
};

class wxIFMComponentButton : public wxWindow
{
private:

    int m_id;

    wxIFMComponentButtonManager *m_manager;

    bool m_hover, m_pressed, m_leftDown;

    wxIFMInterfacePluginBase *GetIP();

public:
    wxBitmap *m_bmp, *m_bmpH, *m_bmpP;

    wxIFMComponentButton(wxIFMComponentButtonManager *manager, int id, wxWindow *parent);
    int GetID() const;

    void SetHover(bool h);
    bool GetHover() const;

    void SetPressed(bool p);
    bool GetPressed() const;

    void OnPaint(wxPaintEvent &event);
    void OnEraseBg(wxEraseEvent &event);
    void OnEnterWindow(wxMouseEvent &event);
    void OnLeaveWindow(wxMouseEvent &event);
    void OnLeftDown(wxMouseEvent &event);
    void OnLeftUp(wxMouseEvent &event);
    void OnMouseMove(wxMouseEvent &event);

    DECLARE_EVENT_TABLE()
};

class wxIFMDefaultChildData : public wxIFMChildDataBase
{
public:

    int m_orientation;
    int m_index;
    bool m_newRow;
    bool m_tabify;
    wxBitmap m_bitmap;
    wxPoint m_pos;
    wxIFMDefaultChildData();

    // docked ctor
    wxIFMDefaultChildData(wxWindow *child, int type, const wxString &name = IFM_DEFAULT_COMPONENT_NAME,
        wxSize size = IFM_DEFAULT_SIZE, bool hidden = false,
        int orientation = IFM_ORIENTATION_DEFAULT, int index = IFM_DEFAULT_INDEX,
        bool newRow = false, bool tabify = false, const wxBitmap &bmp = wxNullBitmap);

    // floating ctor
    wxIFMDefaultChildData(wxWindow *child, int type, wxPoint pos, wxSize size, bool hidden = false,
        const wxString &name = IFM_DEFAULT_COMPONENT_NAME);

    // copy ctors
    wxIFMDefaultChildData(const wxIFMDefaultChildData &data);
    wxIFMDefaultChildData(const wxIFMChildDataBase &data);

#if IFM_USE_WX_RTTI
    DECLARE_DYNAMIC_CLASS(wxIFMDefaultChildData)
#endif
};

class wxIFMContainerData : public wxIFMExtensionDataBase
{
public:

#if IFM_USE_WX_RTTI
    wxIFMContainerData();
#endif

    wxIFMContainerData(wxIFMInterfacePluginBase *ip, wxIFMComponent *c);

    //wxIFMComponentButtonManager m_buttonManager;

    int m_orientation; 
    wxRect m_tray_rect; 

    wxIFMComponentDataKeyType GetDataKey() const;
    static wxIFMComponentDataKeyType DataKey();

#if IFM_USE_WX_RTTI
    DECLARE_DYNAMIC_CLASS(wxIFMContainerData)
#endif
};

class wxIFMPanelTabData : public wxIFMExtensionDataBase
{
public:

    wxBitmap m_bitmap;

#if IFM_USE_WX_RTTI
    wxIFMPanelTabData();
#endif

    wxIFMComponentDataKeyType GetDataKey() const;
    static wxIFMComponentDataKeyType DataKey();

#if IFM_USE_WX_RTTI
    DECLARE_DYNAMIC_CLASS(wxIFMPanelTabData)
#endif
};

class wxIFMTab
{
public:
    wxIFMTab()
        : m_active(false),
        m_visible(true),
        m_tab(NULL),
        m_name_width(0)
    { }

    bool m_active, m_visible;
    wxRect m_rect; 
    wxIFMComponent *m_tab; 
    int m_name_width; 
};

class wxIFMPanelData : public wxIFMExtensionDataBase
{
public:

#ifdef IFM_USE_WX_RTTI
    wxIFMPanelData()
        : m_button_manager(0,0)
    { }
#endif

    wxIFMPanelData(wxIFMInterfacePluginBase *ip, wxIFMComponent *c);
    ~wxIFMPanelData();

    wxIFMComponentButtonManager m_button_manager;

    int m_active_tab_index; 
    wxIFMTab *m_active_tab; 
    wxRect m_caption;
    wxPoint m_titlePos;

    bool m_dont_hide_tab;

    wxIFMTabArray m_tabs;

    wxIFMComponentDataKeyType GetDataKey() const;
    static wxIFMComponentDataKeyType DataKey();

#if IFM_USE_WX_RTTI
    DECLARE_DYNAMIC_CLASS(wxIFMPanelData)
#endif
};

class wxIFMAddTopContainerEvent : public wxIFMPluginEvent
{
private:
    int m_index;
    wxIFMComponent *m_indexContainer; // container to dock relatively to

public:
    // index mode ctor
    wxIFMAddTopContainerEvent(wxIFMComponent *container, int index)
        : wxIFMPluginEvent(wxEVT_IFM_ADDTOPCONTAINER, container),
        m_index(index),
        m_indexContainer(NULL)
    { }

    // relative mode ctor
    // if before == false, after is implied
    wxIFMAddTopContainerEvent(wxIFMComponent *container, wxIFMComponent *index_container, bool before)
        : wxIFMPluginEvent(wxEVT_IFM_ADDTOPCONTAINER, container),
        m_index(before ? 1 : 0),
        m_indexContainer(index_container)
    { }

    virtual wxEvent *Clone() const { return new wxIFMAddTopContainerEvent(*this); }

    bool GetIndexMode() const { return m_indexContainer == NULL; }

    int GetIndex() const { return m_index; }

    wxIFMComponent *GetIndexContainer() const { return m_indexContainer; }
};

class wxIFMRemoveTopContainerEvent : public wxIFMPluginEvent
{
public:
    wxIFMRemoveTopContainerEvent(wxIFMComponent *container)
        : wxIFMPluginEvent(wxEVT_IFM_REMOVETOPCONTAINER, container)
    { }

    wxIFMRemoveTopContainerEvent(const wxIFMRemoveTopContainerEvent &event)
        : wxIFMPluginEvent(event)
    { }

    virtual wxEvent *Clone() const { return new wxIFMRemoveTopContainerEvent(*this); }
};

class wxIFMSelectTabEvent : public wxIFMPluginEvent
{
private:
    wxIFMTab *m_tab; 
    bool m_update; 

public:
    wxIFMSelectTabEvent(wxIFMComponent *panel, wxIFMTab *tab, bool update)
        : wxIFMPluginEvent(wxEVT_IFM_SELECTTAB, panel),
        m_tab(tab),
        m_update(update)
    { }

    wxIFMSelectTabEvent(const wxIFMSelectTabEvent &event)
        : wxIFMPluginEvent(event),
        m_tab(event.m_tab),
        m_update(event.m_update)
    { }

    virtual wxEvent *Clone() const { return new wxIFMSelectTabEvent(*this); }

    wxIFMTab *GetTab() { return m_tab; }

    bool GetUpdate() { return m_update; }
};

class wxIFMComponentButtonEvent : public wxIFMPluginEvent
{
private:
    wxIFMComponentButton *m_button;

public:
    wxIFMComponentButtonEvent(wxEventType type, wxIFMComponent *component, wxIFMComponentButton *button)
        : wxIFMPluginEvent(type, component),
        m_button(button)
    { }

    wxIFMComponentButton *GetButton() const { return m_button; }
};

typedef void (wxEvtHandler::*wxIFMAddTopContainerEventFunction)(wxIFMAddTopContainerEvent&);
typedef void (wxEvtHandler::*wxIFMRemoveTopContainerEventFunction)(wxIFMRemoveTopContainerEvent&);
typedef void (wxEvtHandler::*wxIFMSelectTabEventFunction)(wxIFMSelectTabEvent&);
typedef void (wxEvtHandler::*wxIFMComponentButtonEventFunction)(wxIFMComponentButtonEvent&);

#define wxIFMAddTopContainerEventFunctionHandler(func) \
    (wxObjectEventFunction)wxStaticCastEvent(wxIFMAddTopContainerEventFunction, &func)
#define wxIFMRemoveTopContainerEventFunctionHandler(func) \
    (wxObjectEventFunction)wxStaticCastEvent(wxIFMRemoveTopContainerEventFunction, &func)
#define wxIFMSelectTabEventFunctionHandler(func) \
    (wxObjectEventFunction)wxStaticCastEvent(wxIFMSelectTabEventFunction, &func)
#define wxIFMComponentButtonEventFunctionHandler(func) \
    (wxObjectEventFunction)wxStaticCastEvent(wxIFMComponentButtonEventFunction, &func)

#define EVT_IFM_ADDTOPCONTAINER(func)       wx__DECLARE_EVT0(wxEVT_IFM_ADDTOPCONTAINER, wxIFMAddTopContainerEventFunctionHandler(func))
#define EVT_IFM_REMOVETOPCONTAINER(func)    wx__DECLARE_EVT0(wxEVT_IFM_REMOVETOPCONTAINER, wxIFMRemoveTopContainerEventFunctionHandler(func))
#define EVT_IFM_SELECTTAB(func)             wx__DECLARE_EVT0(wxEVT_IFM_SELECTTAB, wxIFMSelectTabEventFunctionHandler(func))
#define EVT_IFM_COMPONENTBUTTONCLICK(func)  wx__DECLARE_EVT0(wxEVT_IFM_COMPONENTBUTTONCLICK, wxIFMComponentButtonEventFunctionHandler(func))

#endif // _DEFINTERFACE_H_