manager.h

Go to the documentation of this file.

#ifndef _IFM_MANAGER_H_
#define _IFM_MANAGER_H_

#include "ifmdefs.h"

#include <wx/window.h>

wxIFMComponentDataKeyType GetNewDataKey();

int GetNewComponentType();

int GetNewChildType();

DECLARE_IFM_DATA_KEY(IFM_FLOATING_DATA_KEY)

#if IFM_CANFLOAT

class wxIFMFloatingWindowBase : public wxEvtHandler
{
private:
    wxIFMInterfacePluginBase *m_ip;

protected:
    wxWindow *m_window;
    wxIFMInterfacePluginBase *GetIP();
    wxInterfaceManager *GetManager();

public:
    wxIFMComponent *m_component;
    bool m_destroyRoot;

protected:
    wxIFMFloatingWindowBase(wxIFMInterfacePluginBase *ip);

    void ConnectEvents();
    void DisconnectEvents();

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

public:
    wxIFMFloatingWindowBase(wxIFMInterfacePluginBase *ip,
        wxWindow *parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition,
        const wxSize& size = wxDefaultSize, long style = 0,
        const wxString& name = wxPanelNameStr);

    virtual ~wxIFMFloatingWindowBase();

private:
    void OnSize(wxSizeEvent &event);
    void OnMoving(wxMoveEvent &event);
    void OnPaint(wxPaintEvent &event);
    void OnKeyDown(wxKeyEvent &event);
    void OnKeyUp(wxKeyEvent &event);
    void OnSetCursor(wxSetCursorEvent &event);
    void OnMouseEvent(wxMouseEvent &event);
    void OnShow(wxShowEvent &event);
    void OnEraseBg(wxEraseEvent &event);

public:
    wxWindow *GetWindow() const;
    wxIFMComponent *GetComponent() const;

    void Update(bool force = false);

    void AddPendingUpdate();

    DECLARE_EVENT_TABLE()
};

#endif

class wxIFMVersionInfo
{
public:

    wxIFMVersionInfo()
        //:
    { }
};

class WXDLLEXPORT wxInterfaceManager : public wxEvtHandler
{
private:

    bool m_initialized;
    int m_flags;

    wxWindow *m_parent, *m_content;

    wxIFMInterfacePluginArray m_interfacePlugins;
    int m_activeInterface;

    wxIFMComponent *m_capturedComponent; 
    int m_capturedType; 
#if IFM_CANFLOAT
    wxIFMFloatingWindowBase *m_floatingCapture;
#endif

    wxRect m_updateRect;
    bool m_useUpdateRect;

    int m_statusbarPane;
    bool m_statusMessageDisplayed;
    wxString m_oldStatusMessage;

public:

    wxInterfaceManager(wxWindow *parent, wxWindow *content = NULL);
    ~wxInterfaceManager();

    wxWindow *GetParent() const;

    const wxRect &GetInterfaceRect() const;

    void SetInterfaceRect(const wxRect &rect);
    
    void ResetInterfaceRect();

    void SetContentWindow(wxWindow *content);

    wxWindow *GetContentWindow() const;

    bool Initialize(bool defaultPlugins = true, int flags = IFM_DEFAULT_FLAGS);

    void Shutdown();

    void SetFlags(int flags);

    int GetFlags() const;

    bool AddChild(wxIFMChildDataBase *data, bool update = false);

    void ShowChild(wxWindow *child, bool show, bool update = true);

    void HideChild(wxWindow *child, bool update = true);

    bool IsChildVisible(wxWindow *child);

    void SetChildSize(wxWindow *child, const wxSize &desired, const wxSize &min = IFM_USE_CURRENT_SIZE,
        const wxSize &max = IFM_USE_CURRENT_SIZE, bool update = true);

// private for now because they don't actually work and the api for these functions will change
private:
    int AddInterfacePlugin(wxIFMInterfacePluginBase *plugin, bool select = true);

    void SetActiveInterface(int plugin);

    void RemoveInterfacePlugin(int interface_index = IFM_INTERFACE_ACTIVE);

    void RemoveAllInterfacePlugins();


    wxIFMInterfacePluginBase *GetActiveIP() const;

    bool AddExtensionPlugin(wxIFMExtensionPluginBase *plugin/*, int interface_index = IFM_INTERFACE_ACTIVE*/);

    void RemoveExtensionPlugin(/*int interface_index = IFM_INTERFACE_ACTIVE*/);

    void RemoveAllExtensionPlugins(/*int interface_index = IFM_INTERFACE_ACTIVE*/);

public:
    void CaptureInput(wxIFMComponent *component);

    void ReleaseInput();

    bool IsInputCaptured() const;

    wxIFMComponent *GetCapturedComponent() const;

    wxWindow *GetCapturedWindow() const;

    void Update(wxRect rect = IFM_DEFAULT_RECT, bool floating = false);

    void AddPendingUpdate(wxRect rect = IFM_DEFAULT_RECT, bool floating = false);

    void SetStatusMessagePane(int pane);

    void DisplayStatusMessage(const wxString &message);
    
    void ResetStatusMessage();
};

#if IFM_USE_WX_RTTI
class wxIFMChildDataBase : public wxObject
#else
class wxIFMChildDataBase
#endif
{
public:

    int m_type; 
    wxSize m_desiredSize; 
    wxSize m_minSize; 
    wxSize m_maxSize; 
    wxWindow *m_child; 
    bool m_hidden; 
    bool m_hideable; 
    bool m_fixed; 
    wxString m_name; 

    wxIFMChildDataBase();

    wxIFMChildDataBase(wxWindow *child, int type, const wxString &name = IFM_DEFAULT_COMPONENT_NAME,
        wxSize size = IFM_DEFAULT_SIZE, bool hidden = false,
        wxSize minSize = IFM_NO_MINIMUM_SIZE, wxSize maxSize = IFM_NO_MAXIMUM_SIZE);

    wxIFMChildDataBase(const wxIFMChildDataBase &data);

    virtual ~wxIFMChildDataBase();

#if IFM_USE_WX_RTTI
    DECLARE_DYNAMIC_CLASS(wxIFMChildDataBase)
#endif
};

class wxIFMComponent
{
private:

    wxIFMComponentDataMap m_data;
    int m_type; 
    wxIFMInterfacePluginBase *m_ip;
    wxInterfaceManager *GetManager();

public:

    wxRect m_rect; 
    wxSize m_minSize; 
    wxSize m_maxSize; 
    wxSize m_desiredSize; 

    bool m_fixed;
    wxIFMBorders m_borders; 
    wxIFMMargins m_margins; 

    bool m_hidden; 
    bool m_visible; 
    bool m_canHide; 
    bool m_docked; 

    int m_alignment; 
    wxIFMComponentArray m_children; 
    wxIFMComponent *m_parent; 

    wxString m_name; 

    int m_childType; 
    wxWindow *m_child; 

    wxIFMComponent(wxIFMInterfacePluginBase *ip, int type);
private:
    wxIFMComponent(const wxIFMComponent &);
public:

    ~wxIFMComponent();

    void AddExtensionData(wxIFMExtensionDataBase *data);

    wxIFMExtensionDataBase *GetExtensionData(wxIFMComponentDataKeyType key);

    wxIFMExtensionDataBase *RemoveExtensionData(wxIFMComponentDataKeyType key);

    static int GetNextVisibleComponent(const wxIFMComponentArray &components, int start);

    static bool IsChildOf(wxIFMComponent *parent, wxIFMComponent *child);

    void Paint(wxDC &dc, const wxRegion &region);

    int GetType() const;

    wxWindow *GetParentWindow();

    wxRect GetRect();

    wxRect GetBackgroundRect();

    wxRect GetClientRect();

    wxRect GetConvertedRect(wxRect rect, int coords_from, int coords_to);

    wxSize GetDesiredSize();

    void SetDesiredSize(const wxSize &size);

    wxSize GetMinSize();

    wxSize GetMaxSize();

    void Show(bool s, bool update);
    void Hide() { Show(false, true); }

    bool IsShown();

    void VisibilityChanged(bool vis);

    bool IsVisible();
};

#if IFM_USE_WX_RTTI
class wxIFMExtensionDataBase : public wxObject
#else
class wxIFMExtensionDataBase
#endif
{
public:

    virtual ~wxIFMExtensionDataBase();

    virtual wxIFMComponentDataKeyType GetDataKey() const = 0;

    static wxIFMComponentDataKeyType DataKey();
};

#if IFM_CANFLOAT

class wxIFMFloatingData : public wxIFMExtensionDataBase
{
public:

    bool m_floating; 
    wxIFMFloatingWindowBase *m_window; 
    wxRect m_rect;
    wxIFMFloatingData();

    wxIFMComponentDataKeyType GetDataKey() const;
    static wxIFMComponentDataKeyType DataKey();
};
#endif

#endif // _IFM_MANAGER_H_