MatOCAD Logo

Main Page | Class Hierarchy | Class List | Directories | File List | Class Members | File Members | Related Pages

events.h

Go to the documentation of this file.
00001 
00012 #ifndef _IFM_EVENTS_H_
00013 #define _IFM_EVENTS_H_
00014 
00015 #include <wx/event.h>
00016 
00017 #include "manager.h"
00018 
00019 #if WXWIN_COMPATIBILITY_EVENT_TYPES
00020 #error "WXWIN_COMPATIBILITY_EVENT_TYPES defined, but new event system is required"
00021 #endif
00022 
00023 BEGIN_DECLARE_EVENT_TYPES()
00024 
00025 // mouse events
00026 DECLARE_EVENT_TYPE(wxEVT_IFM_LEFTDOWN, 0)
00027 DECLARE_EVENT_TYPE(wxEVT_IFM_LEFTUP, 0)
00028 DECLARE_EVENT_TYPE(wxEVT_IFM_LEFTDCLICK, 0)
00029 DECLARE_EVENT_TYPE(wxEVT_IFM_RIGHTDOWN, 0)
00030 DECLARE_EVENT_TYPE(wxEVT_IFM_RIGHTUP, 0)
00031 DECLARE_EVENT_TYPE(wxEVT_IFM_RIGHTDCLICK, 0)
00032 DECLARE_EVENT_TYPE(wxEVT_IFM_MIDDLEDOWN, 0)
00033 DECLARE_EVENT_TYPE(wxEVT_IFM_MIDDLEUP, 0)
00034 DECLARE_EVENT_TYPE(wxEVT_IFM_MIDDLEDCLICK, 0)
00035 DECLARE_EVENT_TYPE(wxEVT_IFM_MOTION, 0)
00036 DECLARE_EVENT_TYPE(wxEVT_IFM_MOUSEWHEEL, 0)
00037 
00038 DECLARE_EVENT_TYPE(wxEVT_IFM_SETCURSOR, 0)
00039 
00040 DECLARE_EVENT_TYPE(wxEVT_IFM_SETFOCUS, 0) // parent recieves focus
00041 DECLARE_EVENT_TYPE(wxEVT_IFM_KILLFOCUS, 0) // parent loses focus
00042 DECLARE_EVENT_TYPE(wxEVT_IFM_ACTIVATE, 0) // parent window [de]activates
00043 
00044 DECLARE_EVENT_TYPE(wxEVT_IFM_KEYDOWN, 0)
00045 DECLARE_EVENT_TYPE(wxEVT_IFM_KEYUP, 0)
00046 
00047 DECLARE_EVENT_TYPE(wxEVT_IFM_NEWCOMPONENT, 0) // used to create all components
00048 DECLARE_EVENT_TYPE(wxEVT_IFM_DELETECOMPONENT, 0) // used to delete components (not used during cleanup phase)
00049 DECLARE_EVENT_TYPE(wxEVT_IFM_SHOWCOMPONENT, 0) // used to show or hide components
00050 DECLARE_EVENT_TYPE(wxEVT_IFM_VISIBILITYCHANGED, 0) // used to notify a component that is has been shown or hidden
00051 DECLARE_EVENT_TYPE(wxEVT_IFM_ADDCHILD, 0) // add a child window to the interface
00052 DECLARE_EVENT_TYPE(wxEVT_IFM_SETCHILD, 0) // used to add children to panels
00053 DECLARE_EVENT_TYPE(wxEVT_IFM_REMOVECHILD, 0) // removes a child from its panel (and the interface)
00054 
00055 DECLARE_EVENT_TYPE(wxEVT_IFM_PAINTINTERFACE, 0) // indicates to plugins that some or all of the interface needs to be repainted
00056 DECLARE_EVENT_TYPE(wxEVT_IFM_PAINTBG, 0) // paints a components background
00057 DECLARE_EVENT_TYPE(wxEVT_IFM_PAINTBORDER, 0) // paints a components border
00058 DECLARE_EVENT_TYPE(wxEVT_IFM_PAINTDECOR, 0) // paints a components decorations
00059 DECLARE_EVENT_TYPE(wxEVT_IFM_BEGINPAINT, 0)
00060 DECLARE_EVENT_TYPE(wxEVT_IFM_ENDPAINT, 0)
00061 
00062 DECLARE_EVENT_TYPE(wxEVT_IFM_SHOW, 0) // called to show or hide panels
00063 DECLARE_EVENT_TYPE(wxEVT_IFM_SHOWCHILD, 0) // used to show children managed by the interface
00064 DECLARE_EVENT_TYPE(wxEVT_IFM_HIDECHILD, 0) // used to hide children managed by the interface
00065 DECLARE_EVENT_TYPE(wxEVT_IFM_SETCHILDSIZE, 0) // sets the min / max / desired size of a child
00066 DECLARE_EVENT_TYPE(wxEVT_IFM_QUERYCHILD, 0) 
00067 
00068 DECLARE_EVENT_TYPE(wxEVT_IFM_UPDATE, 0) // recalc layout
00069 DECLARE_EVENT_TYPE(wxEVT_IFM_UPDATECOMPONENT, 0) // updates invidual components
00070 DECLARE_EVENT_TYPE(wxEVT_IFM_CALCRECTS, 0)
00071 
00072 // use wxIFMRectEvent for these size events
00073 DECLARE_EVENT_TYPE(wxEVT_IFM_SETDESIREDSIZE, 0) // sets a component desired size
00074 DECLARE_EVENT_TYPE(wxEVT_IFM_GETDESIREDSIZE, 0) // determines the size a component would like to be
00075 DECLARE_EVENT_TYPE(wxEVT_IFM_GETMINSIZE, 0)
00076 DECLARE_EVENT_TYPE(wxEVT_IFM_GETMAXSIZE, 0)
00077 DECLARE_EVENT_TYPE(wxEVT_IFM_SETMINSIZE, 0)
00078 DECLARE_EVENT_TYPE(wxEVT_IFM_SETMAXSIZE, 0)
00079 
00092 DECLARE_EVENT_TYPE(wxEVT_IFM_SETRECT, 0) // sets absolute size and pos
00093 DECLARE_EVENT_TYPE(wxEVT_IFM_SETABSOLUTERECT, 0) // same as SETRECT
00094 DECLARE_EVENT_TYPE(wxEVT_IFM_SETBACKGROUNDRECT, 0) // sets background size and pos
00095 DECLARE_EVENT_TYPE(wxEVT_IFM_SETCLIENTRECT, 0) // sets client size and pos
00096 DECLARE_EVENT_TYPE(wxEVT_IFM_GETRECT, 0) // returns absolute size and pos
00097 DECLARE_EVENT_TYPE(wxEVT_IFM_GETABSOLUTERECT, 0) // same as GETRECT
00098 DECLARE_EVENT_TYPE(wxEVT_IFM_GETBACKGROUNDRECT, 0) // returns background size and pos
00099 DECLARE_EVENT_TYPE(wxEVT_IFM_GETCLIENTRECT, 0) // returns client size and pos
00100 DECLARE_EVENT_TYPE(wxEVT_IFM_CONVERTRECT, 0) // used to convert from [client|background]size to [client|background]size
00101 DECLARE_EVENT_TYPE(wxEVT_IFM_HITTEST, 0) // used for position hit testing
00102 DECLARE_EVENT_TYPE(wxEVT_IFM_GETCONTENTRECT, 0) // used to retrieve the rect available for the applications content window
00103 
00104 DECLARE_EVENT_TYPE(wxEVT_IFM_DOCK, 0) // dock a component
00105 DECLARE_EVENT_TYPE(wxEVT_IFM_UNDOCK, 0) // undock a component
00106 
00107 /*
00108 Floating events
00109 */
00110 #if IFM_CANFLOAT
00111 DECLARE_EVENT_TYPE(wxEVT_IFM_FLOAT, 0) // float a component
00112 DECLARE_EVENT_TYPE(wxEVT_IFM_CREATEFLOATINGWINDOW, 0) // used to create a frame for a floating window
00113 DECLARE_EVENT_TYPE(wxEVT_IFM_DESTROYFLOATINGWINDOW, 0) // used to destroy a frame for a floating window
00114 DECLARE_EVENT_TYPE(wxEVT_IFM_FLOATING_MOVING, 0) // a floating window is being moved
00115 DECLARE_EVENT_TYPE(wxEVT_IFM_FLOATING_SIZING, 0) // a floating window is being sized
00116 DECLARE_EVENT_TYPE(wxEVT_IFM_FLOATING_MOVE, 0) // a floating window has been moved
00117 DECLARE_EVENT_TYPE(wxEVT_IFM_FLOATING_SIZE, 0) // a floating window has been sized
00118 DECLARE_EVENT_TYPE(wxEVT_IFM_FLOATING_SHOW, 0) // used to show a floating window
00119 DECLARE_EVENT_TYPE(wxEVT_IFM_FLOATING_HIDE, 0) // used to hide a floating window
00120 DECLARE_EVENT_TYPE(wxEVT_IFM_FLOATING_NOTIFY, 0) // notifies a component that it has been floated
00121 #endif
00122 
00123 END_DECLARE_EVENT_TYPES()
00124 
00128 class wxIFMPluginEvent : public wxEvent
00129 {
00130 protected:
00131 
00132     int m_componentType; // what type of component is this message for?
00133     wxIFMComponent *m_component; // the component associated with the event
00134 
00135 public:
00136 
00137     wxIFMPluginEvent(wxEventType id, wxIFMComponent *component = NULL);
00138 
00139     wxIFMPluginEvent(const wxIFMPluginEvent &event)
00140         : wxEvent(event),
00141         m_componentType(event.m_componentType),
00142         m_component(event.m_component)
00143     { }
00144 
00145     virtual wxEvent *Clone() const { return new wxIFMPluginEvent(*this); }
00146 
00150     int GetComponentType() const { return m_componentType; }
00151 
00155     wxIFMComponent *GetComponent() const { return m_component; }
00156 
00157 #if IFM_USE_WX_RTTI
00158     wxIFMPluginEvent() { }
00159     DECLARE_DYNAMIC_CLASS(wxIFMPluginEvent)
00160 #endif
00161 };
00162 
00163 // these classes are unused right now, keeping them incase I use them later
00164 #if 0
00165 
00170     class wxIFMInitializeEvent : public wxIFMPluginEvent
00171     {
00172     public:
00173 
00174         bool m_initialized;
00175 
00176         wxIFMInitializeEvent()
00177             : wxIFMPluginEvent(wxEVT_IFM_INITIALIZE),
00178             m_initialized(false)
00179         { }
00180 
00181         wxIFMInitializeEvent(const wxIFMInitializeEvent &event)
00182             : wxIFMPluginEvent(event),
00183             m_initialized(event.m_initialized)
00184         { }
00185 
00186         virtual wxEvent *Clone() const { return new wxIFMInitializeEvent(*this); }
00187 
00193         void SetInitialized(bool initialized = true) { m_initialized = initialized; }
00194 
00198         bool GetInitialized() const { return m_initialized; }
00199     };
00200 
00206     class wxIFMShutdownEvent : public wxIFMPluginEvent
00207     {
00208     public:
00209 
00210         wxIFMShutdownEvent()
00211             : wxIFMPluginEvent(wxEVT_IFM_SHUTDOWN)
00212         { }
00213 
00214         wxIFMShutdownEvent(const wxIFMShutdownEvent &event)
00215             : wxIFMPluginEvent(event)
00216         { }
00217 
00218         virtual wxEvent *Clone() const { return new wxIFMShutdownEvent(*this); }
00219     };
00220 #endif
00221 
00229 class wxIFMNewComponentEvent : public wxIFMPluginEvent
00230 {
00231 public:
00232 
00233     wxIFMNewComponentEvent(int componentType)
00234         : wxIFMPluginEvent(wxEVT_IFM_NEWCOMPONENT)
00235     { m_componentType = componentType; }
00236 
00237     wxIFMNewComponentEvent(const wxIFMNewComponentEvent &event)
00238         : wxIFMPluginEvent(event)
00239     { }
00240 
00241     virtual wxEvent *Clone() const { return new wxIFMNewComponentEvent(*this); }
00242 
00246     void SetComponent(wxIFMComponent *component) { m_component = component; }
00247 };
00248 
00268 class wxIFMDeleteComponentEvent : public wxIFMPluginEvent
00269 {
00270 public:
00271 
00272     wxIFMDeleteComponentEvent(wxIFMComponent *component)
00273         : wxIFMPluginEvent(wxEVT_IFM_DELETECOMPONENT, component)
00274     { }
00275 
00276     wxIFMDeleteComponentEvent(const wxIFMNewComponentEvent &event)
00277         : wxIFMPluginEvent(event)
00278     { }
00279 
00280     virtual wxEvent *Clone() const { return new wxIFMDeleteComponentEvent(*this); }
00281 };
00282 
00288 class wxIFMAddChildEvent : public wxIFMPluginEvent
00289 {
00290 protected:
00291     wxIFMChildDataBase *m_data; 
00292     bool m_success;
00293 
00294 public:
00295 
00296     wxIFMAddChildEvent(wxIFMChildDataBase *data)
00297         : wxIFMPluginEvent(wxEVT_IFM_ADDCHILD),
00298         m_data(data),
00299         m_success(false)
00300     { }
00301 
00302     wxIFMAddChildEvent(const wxIFMAddChildEvent &event)
00303         : wxIFMPluginEvent(event),
00304         m_data(event.m_data),
00305         m_success(event.m_success)
00306     { }
00307 
00308     virtual wxEvent *Clone() const { return new wxIFMAddChildEvent(*this); }
00309 
00313     wxIFMChildDataBase *GetChildData() const { return m_data; }
00314 
00318     void SetSuccess(bool s = true) { m_success = s; }
00319 
00323     bool GetSuccess() const { return m_success; }
00324 };
00325 
00340 class wxIFMDockEvent : public wxIFMPluginEvent
00341 {
00342 protected:
00343     wxIFMComponent *m_destination; 
00344     int m_destinationType; 
00345     int m_index; 
00346 
00347 public:
00348 
00349     wxIFMDockEvent(wxIFMComponent *component, wxIFMComponent *destination, int index);
00350 
00351     wxIFMDockEvent(const wxIFMDockEvent &event)
00352         : wxIFMPluginEvent(event),
00353         m_destination(event.m_destination),
00354         m_destinationType(event.m_destinationType),
00355         m_index(event.m_index)
00356     { }
00357  
00358     virtual wxEvent *Clone() const { return new wxIFMDockEvent(*this); }
00359 
00363     wxIFMComponent *GetDestination() const  { return m_destination; }
00364     void SetDestination(wxIFMComponent *destination);
00365 
00369     int GetDestinationType() const { return m_destinationType; }
00370 
00374     int GetIndex() const { return m_index; }
00375 };
00376 
00380 class wxIFMUndockEvent : public wxIFMPluginEvent
00381 {
00382 protected:
00383     int m_parentType; 
00384     wxIFMComponent *m_parent; 
00385     bool m_delete; 
00386 
00387 public:
00388 
00389     wxIFMUndockEvent(wxIFMComponent *component, bool del = true);
00390 
00391     wxIFMUndockEvent(const wxIFMUndockEvent &event)
00392         : wxIFMPluginEvent(event),
00393         m_parentType(event.m_parentType),
00394         m_parent(event.m_parent),
00395         m_delete(event.m_delete)
00396     { }
00397  
00398     virtual wxEvent *Clone() const { return new wxIFMUndockEvent(*this); }
00399 
00403     wxIFMComponent *GetParent() const { return m_parent; }
00404 
00408     int GetParentType() const { return m_parentType; }
00409 
00414     bool GetDelete() const { return m_delete; }
00415     void SetDelete(bool d) { m_delete = d; }
00416 
00417     void SetParent(wxIFMComponent *parent);
00418 };
00419 
00428 class wxIFMSetChildEvent : public wxIFMPluginEvent
00429 {
00430 protected:
00431     wxWindow *m_child; 
00432     int m_childType; 
00433 
00434 public:
00435 
00436     wxIFMSetChildEvent(wxIFMComponent *component, int childType, wxWindow *child)
00437         : wxIFMPluginEvent(wxEVT_IFM_SETCHILD, component),
00438         m_child(child),
00439         m_childType(childType)
00440     { }
00441 
00442     wxIFMSetChildEvent(const wxIFMSetChildEvent& event)
00443         : wxIFMPluginEvent(event),
00444         m_child(event.m_child),
00445         m_childType(event.m_childType)
00446     { }
00447 
00448     virtual wxEvent *Clone() const { return new wxIFMSetChildEvent(*this); }
00449 
00453     wxWindow *GetChild() const { return m_child; }
00454 
00458     int GetChildType() const { return m_childType; }
00459 };
00460 
00476 class wxIFMRectEvent : public wxIFMPluginEvent
00477 {
00478 protected:
00479     wxRect m_rect;
00480 
00481 public:
00482 
00483     // size / pos ctor
00484     wxIFMRectEvent(wxEventType id, wxIFMComponent *component, const wxPoint &pos, const wxSize &size)
00485         : wxIFMPluginEvent(id, component),
00486         m_rect(pos, size)
00487     { }
00488 
00489     // rect ctor
00490     wxIFMRectEvent(wxEventType id, wxIFMComponent *component, const wxRect &rect = wxRect(0,0,0,0))
00491         : wxIFMPluginEvent(id, component),
00492         m_rect(rect)
00493     { }
00494 
00495 
00496     wxIFMRectEvent(const wxIFMRectEvent &event)
00497         : wxIFMPluginEvent(event),
00498         m_rect(event.m_rect)
00499     { }
00500 
00501     virtual wxEvent *Clone() const { return new wxIFMRectEvent(*this); }
00502 
00503     wxSize GetSize() const { return m_rect.GetSize(); }
00504     wxPoint GetPosition() const { return m_rect.GetPosition(); }
00505     wxRect GetRect() const { return m_rect; }
00506 
00507     void SetSize(const wxSize &s) { m_rect.SetSize(s); }
00508     void SetPosition(const wxPoint &p) { m_rect.SetPosition(p); }
00509     void SetRect(const wxRect &r) { m_rect = r; }
00510 };
00511 
00517 class wxIFMConvertRectEvent : public wxIFMRectEvent
00518 {
00519 protected:
00521     int m_coordsTo, m_coordsFrom; 
00522 
00523 
00524 public:
00525 
00526     wxIFMConvertRectEvent(wxIFMComponent *component, int coordsFrom, int coordsTo,
00527         const wxRect &rect)
00528         : wxIFMRectEvent(wxEVT_IFM_CONVERTRECT, component, rect),
00529         m_coordsTo(coordsTo),
00530         m_coordsFrom(coordsFrom)
00531     { }
00532 
00533     wxIFMConvertRectEvent(wxIFMComponent *component, int coordsFrom, int coordsTo,
00534         const wxPoint &pos, const wxSize &size)
00535         : wxIFMRectEvent(wxEVT_IFM_CONVERTRECT, component, pos, size),
00536         m_coordsTo(coordsTo),
00537         m_coordsFrom(coordsFrom)
00538     { }
00539 
00540     wxIFMConvertRectEvent(const wxIFMConvertRectEvent &event)
00541         : wxIFMRectEvent(event),
00542         m_coordsTo(event.m_coordsTo),
00543         m_coordsFrom(event.m_coordsFrom)
00544     { }
00545 
00546     virtual wxEvent *Clone() const { return new wxIFMConvertRectEvent(*this); }
00547 
00551     int GetSourceCoords() const { return m_coordsFrom; }
00552 
00556     int GetDestinationCoords() const { return m_coordsTo; }
00557 };
00558 
00565 class wxIFMHitTestEvent : public wxIFMPluginEvent
00566 {
00567 protected:
00568     int m_coords; 
00569     bool m_passed; 
00570     const wxPoint &m_pos; 
00571 
00572 public:
00573     wxIFMHitTestEvent(wxIFMComponent *component, int coords, const wxPoint &pos)
00574         : wxIFMPluginEvent(wxEVT_IFM_HITTEST, component),
00575         m_coords(coords),
00576         m_passed(false),
00577         m_pos(pos)
00578     { }
00579 
00580     wxIFMHitTestEvent(const wxIFMHitTestEvent &event)
00581         : wxIFMPluginEvent(event),
00582         m_coords(event.m_coords),
00583         m_passed(event.m_passed),
00584         m_pos(event.m_pos)
00585     { }
00586 
00587     virtual wxEvent *Clone() const { return new wxIFMHitTestEvent(*this); }
00588 
00592     int GetCoords() const { return m_coords; }
00593 
00597     bool GetPassed() const { return m_passed; }
00598     void SetPassed(bool passed = true) { m_passed = passed; }
00599 
00603     const wxPoint &GetPos() const { return m_pos; }
00604 };
00605 
00615 class wxIFMUpdateEvent : public wxIFMPluginEvent
00616 {
00617 protected:
00618     wxRect m_rect; 
00619     wxWindow *m_content; 
00620     bool m_floating; 
00621     wxIFMComponent *m_component;
00622 
00623 public:
00624 
00625     wxIFMUpdateEvent(wxWindow *content, wxRect rect, bool floating)
00626         : wxIFMPluginEvent(wxEVT_IFM_UPDATE),
00627         m_rect(rect),
00628         m_content(content),
00629         m_floating(floating),
00630         m_component(NULL)
00631     { }
00632 
00633     wxIFMUpdateEvent(const wxIFMUpdateEvent &event)
00634         : wxIFMPluginEvent(event),
00635         m_rect(event.m_rect),
00636         m_content(event.m_content),
00637         m_floating(event.m_floating),
00638         m_component(event.m_component)
00639     { }
00640 
00641     virtual wxEvent *Clone() const { return new wxIFMUpdateEvent(*this); }
00642 
00643     /*
00644         \return Area available for the interface in frame coordinates
00645     */
00646     wxRect GetRect() const { return m_rect; }
00647 
00651     wxSize GetSize() const { return m_rect.GetSize(); }
00652 
00656     wxPoint GetPosition() const { return m_rect.GetPosition(); }
00657 
00661     wxWindow *GetContent() const { return m_content; }
00662 
00666     bool GetFoating() const { return m_floating; }
00667 };
00668 
00677 class wxIFMUpdateComponentEvent : public wxIFMPluginEvent
00678 {
00679 protected:
00680     wxRect m_rect; 
00681 
00682 public:
00683 
00684     wxIFMUpdateComponentEvent(wxIFMComponent *component, wxRect rect)
00685         : wxIFMPluginEvent(wxEVT_IFM_UPDATECOMPONENT, component),
00686         m_rect(rect)
00687     { }
00688 
00689     wxIFMUpdateComponentEvent(const wxIFMUpdateComponentEvent &event)
00690         : wxIFMPluginEvent(event),
00691         m_rect(event.m_rect)
00692     { }
00693 
00694     virtual wxEvent *Clone() const { return new wxIFMUpdateComponentEvent(*this); }
00695 
00699     wxSize GetSize() const { return m_rect.GetSize(); }
00700 
00704     wxPoint GetPosition() const { return m_rect.GetPosition(); }
00705 
00709     wxRect GetRect() const { return m_rect; }
00710 };
00711 
00712 #include <vector>
00713 typedef std::vector<wxRect> wxRectArray;
00714 typedef std::vector<wxSize> wxSizeArray;
00715 
00734 class wxIFMCalcRectsEvent : public wxIFMPluginEvent
00735 {
00736 private:
00737     wxRectArray m_rects;
00738     wxSizeArray m_min, m_max;
00739     wxIFMComponentArray m_components;
00740     wxRect m_rect;
00741 
00742 public:
00743     wxIFMCalcRectsEvent(wxIFMComponent *component, const wxRect &rect = IFM_DEFAULT_RECT);
00744 
00748     void SetComponentRect(int index, const wxRect &rect);
00749 
00753     const wxRectArray &GetComponentRects();
00754 
00758     const wxSizeArray &GetMinSizes();
00759 
00763     const wxSizeArray &GetMaxSizes();
00764 
00769     void AddComponent(wxIFMComponent *component);
00770 
00774     const wxIFMComponentArray &GetComponents();
00775 
00779     const wxRect &GetRect();
00780 };
00781 
00787 class wxIFMPaintEvent : public wxIFMPluginEvent
00788 {
00789 protected:
00790     wxRegion m_region; 
00791     wxDC &m_dc; 
00792 
00793 public:
00794 
00795     wxIFMPaintEvent(wxEventType id, wxIFMComponent *component, const wxRegion &region, wxDC &dc)
00796         : wxIFMPluginEvent(id, component),
00797         m_region(region),
00798         m_dc(dc)
00799     { }
00800 
00801     wxIFMPaintEvent(const wxIFMPaintEvent& event)
00802         : wxIFMPluginEvent(event),
00803         m_region(event.m_region),
00804         m_dc(event.m_dc)
00805     { }
00806 
00807     virtual wxEvent *Clone() const { return new wxIFMPaintEvent(*this); }
00808 
00812     wxRegion GetRegion() const { return m_region; }
00813 
00817     wxDC &GetDC() const { return m_dc; }
00818 };
00819 
00825 class wxIFMPaintInterfaceEvent : public wxIFMPluginEvent
00826 {
00827 protected:
00828     const wxRegion &m_region; 
00829     wxDC &m_dc; 
00830 
00831 public:
00832 
00833     wxIFMPaintInterfaceEvent(wxDC &dc, const wxRegion &region)
00834         : wxIFMPluginEvent(wxEVT_IFM_PAINTINTERFACE),
00835         m_region(region),
00836         m_dc(dc)
00837     { }
00838 
00839     wxIFMPaintInterfaceEvent(const wxIFMPaintInterfaceEvent& event)
00840         : wxIFMPluginEvent(event),
00841         m_region(event.m_region),
00842         m_dc(event.m_dc)
00843     { }
00844 
00845     virtual wxEvent *Clone() const { return new wxIFMPaintInterfaceEvent(*this); }
00846 
00850     wxDC &GetDC() const { return m_dc; }
00851 
00855     const wxRegion &GetUpdateRegion() const { return m_region; }
00856 };
00857 
00865 class wxIFMBeginPaintEvent : public wxIFMPluginEvent
00866 {
00867 protected:
00868     wxDC *m_dc; 
00869     bool m_onpaint; 
00870     wxWindow *m_window; 
00871 
00872 public:
00873 
00874     wxIFMBeginPaintEvent(wxWindow *window, bool onpaint = true)
00875         : wxIFMPluginEvent(wxEVT_IFM_BEGINPAINT),
00876         m_dc(NULL),
00877         m_onpaint(onpaint),
00878         m_window(window)
00879     { }
00880 
00881     wxIFMBeginPaintEvent(const wxIFMBeginPaintEvent& event)
00882         : wxIFMPluginEvent(event),
00883         m_dc(event.m_dc),
00884         m_onpaint(event.m_onpaint),
00885         m_window(event.m_window)
00886     { }
00887 
00888     virtual wxEvent *Clone() const { return new wxIFMBeginPaintEvent(*this); }
00889 
00893     wxDC *GetDC() const { return m_dc; }
00894 
00898     void SetDC(wxDC *dc) { m_dc = dc; }
00899 
00903     bool GetOnPaint() const { return m_onpaint; }
00904 
00908     wxWindow *GetWindow() const { return m_window; }
00909 };
00910 
00916 class wxIFMEndPaintEvent : public wxIFMPluginEvent
00917 {
00918 protected:
00919     wxDC *m_dc; 
00920 
00921 public:
00922 
00923     wxIFMEndPaintEvent(wxDC *dc)
00924         : wxIFMPluginEvent(wxEVT_IFM_ENDPAINT),
00925         m_dc(dc)
00926     { }
00927 
00928     wxIFMEndPaintEvent(const wxIFMEndPaintEvent& event)
00929         : wxIFMPluginEvent(event),
00930         m_dc(event.m_dc)
00931     { }
00932 
00933     virtual wxEvent *Clone() const { return new wxIFMEndPaintEvent(*this); }
00934 
00938     wxDC *GetDC() const { return m_dc; }
00939 };
00940 
00949 class wxIFMKeyEvent : public wxIFMPluginEvent
00950 {
00951 protected:
00952     wxKeyEvent &m_event; 
00953 
00954 public:
00955 
00956     wxIFMKeyEvent(wxEventType id, wxIFMComponent *component, wxKeyEvent &event)
00957         : wxIFMPluginEvent(id, component),
00958         m_event(event)
00959     { }
00960 
00961     wxIFMKeyEvent(const wxIFMKeyEvent &event)
00962         : wxIFMPluginEvent(event),
00963         m_event(event.m_event)
00964     { }
00965 
00966     virtual wxEvent *Clone() const { return new wxIFMKeyEvent(*this); }
00967 
00971     wxKeyEvent &GetKeyEvent() const { return m_event; }
00972 };
00973 
00983 class wxIFMMouseEvent : public wxIFMPluginEvent
00984 {
00985 protected:
00986     wxMouseEvent &m_event; 
00987 
00988 public:
00989 
00990     wxIFMMouseEvent(wxEventType id, wxIFMComponent *component, wxMouseEvent &event)
00991         : wxIFMPluginEvent(id, component),
00992         m_event(event)
00993     { }
00994 
00995     wxIFMMouseEvent(const wxIFMMouseEvent &event)
00996         : wxIFMPluginEvent(event),
00997         m_event(event.m_event)
00998     { }
00999 
01000     virtual wxEvent *Clone() const { return new wxIFMMouseEvent(*this); }
01001 
01005     wxMouseEvent &GetMouseEvent() const { return m_event; }
01006 };
01007 
01017 class wxIFMSetCursorEvent : public wxIFMPluginEvent
01018 {
01019 protected:
01020     wxSetCursorEvent &m_event; 
01021 
01022 public:
01023 
01024     wxIFMSetCursorEvent(wxSetCursorEvent &event, wxIFMComponent *component)
01025         : wxIFMPluginEvent(wxEVT_IFM_SETCURSOR, component),
01026         m_event(event)
01027     { }
01028 
01029     wxIFMSetCursorEvent(const wxIFMSetCursorEvent &event)
01030         : wxIFMPluginEvent(event),
01031         m_event(event.m_event)
01032     { }
01033 
01034     virtual wxEvent *Clone() const { return new wxIFMSetCursorEvent(*this); }
01035 
01039     wxSetCursorEvent &GetCursorEvent() const { return m_event; }
01040 };
01041 
01045 class wxIFMFocusEvent : public wxIFMPluginEvent
01046 {
01047 protected:
01048     wxFocusEvent &m_event; 
01049 
01050 public:
01051 
01052     wxIFMFocusEvent(wxEventType id, wxFocusEvent &event)
01053         : wxIFMPluginEvent(id),
01054         m_event(event)
01055     { }
01056 
01057     wxIFMFocusEvent(const wxIFMFocusEvent &event)
01058         : wxIFMPluginEvent(event),
01059         m_event(event.m_event)
01060     { }
01061 
01062     virtual wxEvent *Clone() const { return new wxIFMFocusEvent(*this); }
01063 
01067     wxFocusEvent &GetFocusEvent() const { return m_event; }
01068 };
01069 
01073 class wxIFMActivateEvent : public wxIFMPluginEvent
01074 {
01075 protected:
01076     wxActivateEvent &m_event; 
01077 
01078 public:
01079 
01080     wxIFMActivateEvent(wxActivateEvent &event)
01081         : wxIFMPluginEvent(wxEVT_IFM_ACTIVATE),
01082         m_event(event)
01083     { }
01084 
01085     wxIFMActivateEvent(const wxIFMActivateEvent &event)
01086         : wxIFMPluginEvent(event),
01087         m_event(event.m_event)
01088     { }
01089 
01090     virtual wxEvent *Clone() const { return new wxIFMActivateEvent(*this); }
01091 
01095     wxActivateEvent &GetActivateEvent() const { return m_event; }
01096 };
01097 
01105 class wxIFMChildEvent : public wxIFMPluginEvent
01106 {
01107 private:
01108     friend class wxIFMInterfacePluginBase;
01109     void SetComponent(wxIFMComponent *c) { m_component = c; }
01110 
01111 protected:
01112     wxWindow *m_child; 
01113 
01114 public:
01115 
01116     wxIFMChildEvent(wxEventType type, wxWindow *child)
01117         : wxIFMPluginEvent(type),
01118         m_child(child)
01119     { }
01120 
01121     wxIFMChildEvent(const wxIFMChildEvent &event)
01122         : wxIFMPluginEvent(event),
01123         m_child(event.m_child)
01124     { }
01125 
01126     virtual wxEvent *Clone() const { return new wxIFMChildEvent(*this); }
01127 
01131     wxWindow *GetChild() const { return m_child; }
01132 };
01133 
01149 class wxIFMShowChildEvent : public wxIFMChildEvent
01150 {
01151 protected:
01152     bool m_show; 
01153     bool m_update; 
01154 
01155 public:
01156 
01157     wxIFMShowChildEvent(wxWindow *child, bool show, bool update)
01158         : wxIFMChildEvent((show ? wxEVT_IFM_SHOWCHILD : wxEVT_IFM_HIDECHILD), child),
01159         m_show(show),
01160         m_update(update)
01161     { }
01162 
01163     wxIFMShowChildEvent(const wxIFMShowChildEvent &event)
01164         : wxIFMChildEvent(event),
01165         m_show(event.m_show),
01166         m_update(event.m_update)
01167     { }
01168 
01169     virtual wxEvent *Clone() const { return new wxIFMShowChildEvent(*this); }
01170 
01174     bool GetShow() const { return m_show; }
01175 
01179     bool GetUpdate() const { return m_update; }
01180     void SetUpdate(bool update) { m_update = update; }
01181 };
01182 
01188 class wxIFMQueryChildEvent : public wxIFMChildEvent
01189 {
01190 protected:
01191     bool m_visible; 
01192     
01193 public:
01194 
01195     wxIFMQueryChildEvent(wxWindow *child)
01196         : wxIFMChildEvent(wxEVT_IFM_QUERYCHILD, child),
01197         m_visible(false)
01198     { }
01199 
01200     wxIFMQueryChildEvent(const wxIFMQueryChildEvent &event)
01201         : wxIFMChildEvent(event),
01202         m_visible(event.m_visible)
01203     { }
01204 
01205     virtual wxEvent *Clone() const { return new wxIFMQueryChildEvent(*this); }
01206 
01210     bool IsVisible() const { return m_visible; }
01211     void SetVisible(bool vis) { m_visible = vis; }
01212 };
01213 
01217 class wxIFMSetChildSizeEvent : public wxIFMChildEvent
01218 {
01219 protected:
01220     wxSize m_min, m_max, m_desired;
01221     bool m_update;
01222 
01223 public:
01224     wxIFMSetChildSizeEvent(wxWindow *child, const wxSize &desired, const wxSize &min, const wxSize &max, bool update)
01225         : wxIFMChildEvent(wxEVT_IFM_SETCHILDSIZE, child),
01226         m_min(min),
01227         m_max(max),
01228         m_desired(desired),
01229         m_update(update)
01230     { }
01231 
01232     wxIFMSetChildSizeEvent(const wxIFMSetChildSizeEvent &event)
01233         : wxIFMChildEvent(event),
01234         m_min(event.m_min),
01235         m_max(event.m_max),
01236         m_desired(event.m_desired),
01237         m_update(event.m_update)
01238     { }
01239 
01240     virtual wxEvent *Clone() const { return new wxIFMSetChildSizeEvent(*this); }
01241 
01247     wxSize GetMinSize() const { return m_min; }
01248 
01254     wxSize GetMaxSize() const { return m_max; }
01255 
01261     wxSize GetDesiredSize() const { return m_desired; }
01262 
01266     bool GetUpdate() const { return m_update; }
01267     void SetUpdate(bool s) { m_update = s; }
01268 };
01269 
01294 class wxIFMShowComponentEvent : public wxIFMPluginEvent
01295 {
01296 protected:
01297     bool m_show, m_update;
01298 
01299 public:
01300     wxIFMShowComponentEvent(wxIFMComponent *component, bool show, bool update)
01301         : wxIFMPluginEvent(wxEVT_IFM_SHOWCOMPONENT, component),
01302         m_show(show),
01303         m_update(update)
01304     { }
01305 
01306     wxIFMShowComponentEvent(const wxIFMShowComponentEvent &event)
01307         : wxIFMPluginEvent(event),
01308         m_show(event.m_show),
01309         m_update(event.m_update)
01310     { }
01311 
01312     virtual wxEvent *Clone() const { return new wxIFMShowComponentEvent(*this); }
01313     
01317     bool GetShow() const { return m_show; }
01318 
01322     bool GetUpdate() const { return m_update; }
01323     void SetUpdate(bool s) { m_update = s; }
01324 };
01325 
01348 class wxIFMComponentVisibilityChangedEvent : public wxIFMPluginEvent
01349 {
01350 protected:
01351     bool m_show;
01352 
01353 public:
01354     wxIFMComponentVisibilityChangedEvent(wxIFMComponent *component, bool show)
01355         : wxIFMPluginEvent(wxEVT_IFM_VISIBILITYCHANGED, component),
01356         m_show(show)
01357     { }
01358 
01359     wxIFMComponentVisibilityChangedEvent(const wxIFMComponentVisibilityChangedEvent &event)
01360         : wxIFMPluginEvent(event),
01361         m_show(event.m_show)
01362     { }
01363 
01364     virtual wxEvent *Clone() const { return new wxIFMComponentVisibilityChangedEvent(*this); }
01365     
01369     bool GetShow() const { return m_show; }
01370 };
01371 
01372 #if IFM_CANFLOAT
01373 
01386 class wxIFMFloatEvent : public wxIFMPluginEvent
01387 {
01388 protected:
01389     wxRect m_rect; 
01390 
01391 public:
01392 
01393     wxIFMFloatEvent(wxIFMComponent* component, const wxRect &rect = wxRect(0,0,0,0))
01394         : wxIFMPluginEvent(wxEVT_IFM_FLOAT, component),
01395         m_rect(rect)
01396     { }
01397 
01398     wxIFMFloatEvent(wxIFMComponent* component, const wxPoint &pos, const wxSize &size)
01399         : wxIFMPluginEvent(wxEVT_IFM_FLOAT, component),
01400         m_rect(pos, size)
01401     { }
01402 
01403     wxIFMFloatEvent(const wxIFMFloatEvent &event)
01404         : wxIFMPluginEvent(event),
01405         m_rect(event.m_rect)
01406     { }
01407 
01408     virtual wxEvent *Clone() const { return new wxIFMFloatEvent(*this); }
01409 
01425     wxRect GetRect() const { return m_rect; }
01426 
01430     wxPoint GetPosition() const { return m_rect.GetPosition(); }
01431 
01435     wxSize GetSize() const { return m_rect.GetSize(); }
01436 };
01437 
01447 class wxIFMCreateFloatingWindowEvent : public wxIFMPluginEvent
01448 {
01449 protected:
01450     wxIFMFloatingWindowBase *m_window;
01451     wxWindow *m_parent;
01452 
01453 public:
01454 
01455     wxIFMCreateFloatingWindowEvent(wxWindow *parent, wxIFMComponent *component)
01456         : wxIFMPluginEvent(wxEVT_IFM_CREATEFLOATINGWINDOW, component),
01457         m_window(NULL),
01458         m_parent(parent)
01459     { }
01460 
01461     wxIFMCreateFloatingWindowEvent(const wxIFMCreateFloatingWindowEvent &event)
01462         : wxIFMPluginEvent(event),
01463         m_window(event.m_window),
01464         m_parent(event.m_parent)
01465     { }
01466 
01467     virtual wxEvent *Clone() const { return new wxIFMCreateFloatingWindowEvent(*this); }
01468 
01472     void SetWindow(wxIFMFloatingWindowBase *window) { m_window = window; }
01473 
01477     wxIFMFloatingWindowBase *GetWindow() const { return m_window; }
01478 
01482     wxWindow *GetParent() const { return m_parent; }
01483 };
01484 
01490 class wxIFMDestroyFloatingWindowEvent : public wxIFMPluginEvent
01491 {
01492 protected:
01493     wxIFMFloatingWindowBase *m_window;
01494     bool m_destroyRootComponent;
01495 
01496 public:
01497 
01498     wxIFMDestroyFloatingWindowEvent(wxIFMFloatingWindowBase *window, bool destroy = true)
01499         : wxIFMPluginEvent(wxEVT_IFM_DESTROYFLOATINGWINDOW),
01500         m_window(window),
01501         m_destroyRootComponent(destroy)
01502     { }
01503 
01504     wxIFMDestroyFloatingWindowEvent(const wxIFMDestroyFloatingWindowEvent &event)
01505         : wxIFMPluginEvent(event),
01506         m_window(event.m_window),
01507         m_destroyRootComponent(event.m_destroyRootComponent)
01508     { }
01509 
01510     virtual wxEvent *Clone() const { return new wxIFMDestroyFloatingWindowEvent(*this); }
01511 
01515     wxIFMFloatingWindowBase *GetWindow() const { return m_window; }
01516 
01520     bool ShouldDestroyRoot() const { return m_destroyRootComponent; }
01521 };
01522 
01526 class wxIFMFloatingSizeEvent : public wxIFMPluginEvent
01527 {
01528 protected:
01529     wxSizeEvent &m_event;
01530     wxIFMFloatingWindowBase *m_window;
01531 
01532 public:
01533 
01534     wxIFMFloatingSizeEvent(wxEventType type, wxIFMFloatingWindowBase *window, wxSizeEvent &event)
01535         : wxIFMPluginEvent(type),
01536         m_event(event),
01537         m_window(window)
01538     { }
01539 
01540     wxIFMFloatingSizeEvent(const wxIFMFloatingSizeEvent& event)
01541         : wxIFMPluginEvent(event),
01542         m_event(event.m_event),
01543         m_window(event.m_window)
01544     { }
01545 
01546     virtual wxEvent *Clone() const { return new wxIFMFloatingSizeEvent(*this); }
01547 
01551     wxIFMFloatingWindowBase *GetWindow() const { return m_window; }
01552 
01556     wxSizeEvent &GetSizeEvent() const { return m_event; }
01557 };
01558 
01562 class wxIFMFloatingMoveEvent : public wxIFMPluginEvent
01563 {
01564 protected:
01565     wxMoveEvent &m_event;
01566     wxIFMFloatingWindowBase *m_window;
01567 
01568 public:
01569 
01570     wxIFMFloatingMoveEvent(wxEventType type, wxIFMFloatingWindowBase *window, wxMoveEvent &event)
01571         : wxIFMPluginEvent(type),
01572         m_event(event),
01573         m_window(window)
01574     { }
01575 
01576     wxIFMFloatingMoveEvent(const wxIFMFloatingMoveEvent& event)
01577         : wxIFMPluginEvent(event),
01578         m_event(event.m_event),
01579         m_window(event.m_window)
01580     { }
01581 
01582     virtual wxEvent *Clone() const { return new wxIFMFloatingMoveEvent(*this); }
01583 
01587     wxIFMFloatingWindowBase *GetWindow() const { return m_window; }
01588 
01592     wxMoveEvent &GetMoveEvent() const { return m_event; }
01593 };
01594 
01610 class wxIFMFloatNotifyEvent : public wxIFMPluginEvent
01611 {
01612 protected:
01613     wxIFMFloatingWindowBase *m_window;
01614     bool m_floating;
01615 
01616 public:
01617 
01623     wxIFMFloatNotifyEvent(wxIFMComponent *component, bool floating, wxIFMFloatingWindowBase *window = NULL)
01624         : wxIFMPluginEvent(wxEVT_IFM_FLOATING_NOTIFY, component),
01625         m_window(window),
01626         m_floating(floating)
01627     { }
01628 
01629     wxIFMFloatNotifyEvent(const wxIFMFloatNotifyEvent &event)
01630         : wxIFMPluginEvent(event),
01631         m_window(event.m_window),
01632         m_floating(event.m_floating)
01633     { }
01634 
01635     virtual wxEvent *Clone() const { return new wxIFMFloatNotifyEvent(*this); }
01636 
01641     wxIFMFloatingWindowBase *GetWindow() const { return m_window; }
01642 
01646     bool GetFloating() const { return m_floating; }
01647 };
01648 
01649 #endif
01650 
01651 typedef void (wxEvtHandler::*wxIFMNewComponentEventFunction)(wxIFMNewComponentEvent&);
01652 typedef void (wxEvtHandler::*wxIFMDeleteComponentEventFunction)(wxIFMDeleteComponentEvent&);
01653 typedef void (wxEvtHandler::*wxIFMAddChildEventFunction)(wxIFMAddChildEvent&);
01654 typedef void (wxEvtHandler::*wxIFMSetChildEventFunction)(wxIFMSetChildEvent&);
01655 
01656 /*
01657 typedef void (wxEvtHandler::*wxIFMInitializeEventFunction)(wxIFMInitializeEvent&);
01658 typedef void (wxEvtHandler::*wxIFMShutdownEventFunction)(wxIFMShutdownEvent&);
01659 */
01660 
01661 typedef void (wxEvtHandler::*wxIFMDockEventFunction)(wxIFMDockEvent&);
01662 typedef void (wxEvtHandler::*wxIFMUndockEventFunction)(wxIFMUndockEvent&);
01663 
01664 typedef void (wxEvtHandler::*wxIFMShowComponentEventFunction)(wxIFMShowComponentEvent&);
01665 typedef void (wxEvtHandler::*wxIFMComponentVisibilityChangedEventFunction)(wxIFMComponentVisibilityChangedEvent&);
01666 
01667 typedef void (wxEvtHandler::*wxIFMShowChildEventFunction)(wxIFMShowChildEvent&);
01668 typedef void (wxEvtHandler::*wxIFMSetChildSizeEventFunction)(wxIFMSetChildSizeEvent&);
01669 typedef void (wxEvtHandler::*wxIFMQueryChildEventFunction)(wxIFMQueryChildEvent&);
01670 
01671 typedef void (wxEvtHandler::*wxIFMRectEventFunction)(wxIFMRectEvent&);
01672 typedef void (wxEvtHandler::*wxIFMConvertRectEventFunction)(wxIFMConvertRectEvent&);
01673 typedef void (wxEvtHandler::*wxIFMHitTestEventFunction)(wxIFMHitTestEvent&);
01674 
01675 typedef void (wxEvtHandler::*wxIFMUpdateEventFunction)(wxIFMUpdateEvent&);
01676 typedef void (wxEvtHandler::*wxIFMUpdateComponentEventFunction)(wxIFMUpdateComponentEvent&);
01677 typedef void (wxEvtHandler::*wxIFMCalcRectsEventFunction)(wxIFMCalcRectsEvent&);
01678 
01679 typedef void (wxEvtHandler::*wxIFMPaintInterfaceEventFunction)(wxIFMPaintInterfaceEvent&);
01680 typedef void (wxEvtHandler::*wxIFMPaintEventFunction)(wxIFMPaintEvent&);
01681 typedef void (wxEvtHandler::*wxIFMBeginPaintEventFunction)(wxIFMBeginPaintEvent&);
01682 typedef void (wxEvtHandler::*wxIFMEndPaintEventFunction)(wxIFMEndPaintEvent&);
01683 
01684 typedef void (wxEvtHandler::*wxIFMKeyEventFunction)(wxIFMKeyEvent&);
01685 typedef void (wxEvtHandler::*wxIFMMouseEventFunction)(wxIFMMouseEvent&);
01686 typedef void (wxEvtHandler::*wxIFMSetCursorEventFunction)(wxIFMSetCursorEvent&);
01687 typedef void (wxEvtHandler::*wxIFMFocusEventFunction)(wxIFMFocusEvent&);
01688 typedef void (wxEvtHandler::*wxIFMActivateEventFunction)(wxIFMActivateEvent&);
01689 
01690 #if IFM_CANFLOAT
01691 typedef void (wxEvtHandler::*wxIFMFloatingSizeEventFunction)(wxIFMFloatingSizeEvent&);
01692 typedef void (wxEvtHandler::*wxIFMFloatingMoveEventFunction)(wxIFMFloatingMoveEvent&);
01693 typedef void (wxEvtHandler::*wxIFMFloatNotifyEventFunction)(wxIFMFloatNotifyEvent&);
01694 typedef void (wxEvtHandler::*wxIFMFloatEventFunction)(wxIFMFloatEvent&);
01695 typedef void (wxEvtHandler::*wxIFMCreateFloatingWindowEventFunction)(wxIFMCreateFloatingWindowEvent&);
01696 typedef void (wxEvtHandler::*wxIFMDestroyFloatingWindowEventFunction)(wxIFMDestroyFloatingWindowEvent&);
01697 #endif
01698 
01699 #define wxIFMNewComponentEventFunctionHandler(func) \
01700     (wxObjectEventFunction)wxStaticCastEvent(wxIFMNewComponentEventFunction, &func)
01701 #define wxIFMDeleteComponentEventFunctionHandler(func) \
01702     (wxObjectEventFunction)wxStaticCastEvent(wxIFMDeleteComponentEventFunction, &func)
01703 #define wxIFMAddChildEventFunctionHandler(func) \
01704     (wxObjectEventFunction)wxStaticCastEvent(wxIFMAddChildEventFunction, &func)
01705 #define wxIFMSetChildEventFunctionHandler(func) \
01706     (wxObjectEventFunction)wxStaticCastEvent(wxIFMSetChildEventFunction, &func)
01707 /*
01708 #define wxIFMInitializeEventFunctionHandler(func) \
01709     (wxObjectEventFunction)wxStaticCastEvent(wxIFMInitializeEventFunction, &func)
01710 #define wxIFMShutdownEventFunctionHandler(func) \
01711     (wxObjectEventFunction)wxStaticCastEvent(wxIFMShutdownEventFunction, &func)
01712 */
01713 
01714 #define wxIFMDockEventFunctionHandler(func) \
01715     (wxObjectEventFunction)wxStaticCastEvent(wxIFMDockEventFunction, &func)
01716 #define wxIFMUndockEventFunctionHandler(func) \
01717     (wxObjectEventFunction)wxStaticCastEvent(wxIFMUndockEventFunction, &func)
01718 
01719 #define wxIFMShowComponentEventFunctionHandler(func) \
01720     (wxObjectEventFunction)wxStaticCastEvent(wxIFMShowComponentEventFunction, &func)
01721 #define wxIFMComponentVisibilityChangedEventFunctionHandler(func) \
01722     (wxObjectEventFunction)wxStaticCastEvent(wxIFMComponentVisibilityChangedEventFunction, &func)
01723 
01724 #define wxIFMShowChildEventFunctionHandler(func) \
01725     (wxObjectEventFunction)wxStaticCastEvent(wxIFMShowChildEventFunction, &func)
01726 #define wxIFMSetChildSizeEventFunctionHandler(func) \
01727     (wxObjectEventFunction)wxStaticCastEvent(wxIFMSetChildSizeEventFunction, &func)
01728 #define wxIFMQueryChildEventFunctionHandler(func) \
01729     (wxObjectEventFunction)wxStaticCastEvent(wxIFMQueryChildEventFunction, &func)
01730 
01731 #define wxIFMRectEventFunctionHandler(func) \
01732     (wxObjectEventFunction)wxStaticCastEvent(wxIFMRectEventFunction, &func)
01733 #define wxIFMConvertRectEventFunctionHandler(func) \
01734     (wxObjectEventFunction)wxStaticCastEvent(wxIFMConvertRectEventFunction, &func)
01735 #define wxIFMHitTestEventFunctionHandler(func) \
01736     (wxObjectEventFunction)wxStaticCastEvent(wxIFMHitTestEventFunction, &func)
01737 
01738 #define wxIFMUpdateEventFunctionHandler(func) \
01739     (wxObjectEventFunction)wxStaticCastEvent(wxIFMUpdateEventFunction, &func)
01740 #define wxIFMUpdateComponentEventFunctionHandler(func) \
01741     (wxObjectEventFunction)wxStaticCastEvent(wxIFMUpdateComponentEventFunction, &func)
01742 #define wxIFMCalcRectsEventFunctionHandler(func) \
01743     (wxObjectEventFunction)wxStaticCastEvent(wxIFMCalcRectsEventFunction, &func)
01744 
01745 #define wxIFMPaintInterfaceEventFunctionHandler(func) \
01746     (wxObjectEventFunction)wxStaticCastEvent(wxIFMPaintInterfaceEventFunction, &func)
01747 #define wxIFMPaintEventFunctionHandler(func) \
01748     (wxObjectEventFunction)wxStaticCastEvent(wxIFMPaintEventFunction, &func)
01749 #define wxIFMBeginPaintEventFunctionHandler(func) \
01750     (wxObjectEventFunction)wxStaticCastEvent(wxIFMBeginPaintEventFunction, &func)
01751 #define wxIFMEndPaintEventFunctionHandler(func) \
01752     (wxObjectEventFunction)wxStaticCastEvent(wxIFMEndPaintEventFunction, &func)
01753 
01754 #define wxIFMKeyEventFunctionHandler(func) \
01755     (wxObjectEventFunction)wxStaticCastEvent(wxIFMKeyEventFunction, &func)
01756 #define wxIFMMouseEventFunctionHandler(func) \
01757     (wxObjectEventFunction)wxStaticCastEvent(wxIFMMouseEventFunction, &func)
01758 #define wxIFMSetCursorEventFunctionHandler(func) \
01759     (wxObjectEventFunction)wxStaticCastEvent(wxIFMSetCursorEventFunction, &func)
01760 #define wxIFMFocusEventFunctionHandler(func) \
01761     (wxObjectEventFunction)wxStaticCastEvent(wxIFMFocusEventFunction, &func)
01762 #define wxIFMActivateEventFunctionHandler(func) \
01763     (wxObjectEventFunction)wxStaticCastEvent(wxIFMActivateEventFunction, &func)
01764 
01765 #if IFM_CANFLOAT
01766 #define wxIFMFloatingSizeEventFunctionHandler(func) \
01767     (wxObjectEventFunction)wxStaticCastEvent(wxIFMFloatingSizeEventFunction, &func)
01768 #define wxIFMFloatingMoveEventFunctionHandler(func) \
01769     (wxObjectEventFunction)wxStaticCastEvent(wxIFMFloatingMoveEventFunction, &func)
01770 #define wxIFMFloatNotifyEventFunctionHandler(func) \
01771     (wxObjectEventFunction)wxStaticCastEvent(wxIFMFloatNotifyEventFunction, &func)
01772 #define wxIFMFloatEventFunctionHandler(func) \
01773     (wxObjectEventFunction)wxStaticCastEvent(wxIFMFloatEventFunction, &func)
01774 #define wxIFMCreateFloatingWindowEventFunctionHandler(func) \
01775     (wxObjectEventFunction)wxStaticCastEvent(wxIFMCreateFloatingWindowEventFunction, &func)
01776 #define wxIFMDestroyFloatingWindowEventFunctionHandler(func) \
01777     (wxObjectEventFunction)wxStaticCastEvent(wxIFMDestroyFloatingWindowEventFunction, &func)
01778 #endif
01779 
01780 #define EVT_IFM_NEWCOMPONENT(func)  wx__DECLARE_EVT0( wxEVT_IFM_NEWCOMPONENT, wxIFMNewComponentEventFunctionHandler(func))
01781 #define EVT_IFM_DELETECOMPONENT(func) wx__DECLARE_EVT0( wxEVT_IFM_DELETECOMPONENT, wxIFMDeleteComponentEventFunctionHandler(func))
01782 #define EVT_IFM_ADDCHILD(func)      wx__DECLARE_EVT0( wxEVT_IFM_ADDCHILD, wxIFMAddChildEventFunctionHandler(func))
01783 #define EVT_IFM_SETCHILD(func)      wx__DECLARE_EVT0( wxEVT_IFM_SETCHILD, wxIFMSetChildEventFunctionHandler(func))
01784 
01785 #define EVT_IFM_DOCK(func)          wx__DECLARE_EVT0( wxEVT_IFM_DOCK, wxIFMDockEventFunctionHandler(func))
01786 #define EVT_IFM_UNDOCK(func)        wx__DECLARE_EVT0( wxEVT_IFM_UNDOCK, wxIFMUndockEventFunctionHandler(func))
01787 #define EVT_IFM_FLOAT(func)         wx__DECLARE_EVT0( wxEVT_IFM_FLOAT, wxIFMFloatEventFunctionHandler(func))
01788 #define EVT_IFM_UNFLOAT(func)       wx__DECLARE_EVT0( wxEVT_IFM_UNFLOAT, wxIFMFloatEventFunctionHandler(func))
01789 
01790 #define EVT_IFM_SHOWCOMPONENT(func) wx__DECLARE_EVT0( wxEVT_IFM_SHOWCOMPONENT, wxIFMShowComponentEventFunctionHandler(func))
01791 #define EVT_IFM_VISIBILITYCHANGED(func) wx__DECLARE_EVT0( wxEVT_IFM_VISIBILITYCHANGED, wxIFMComponentVisibilityChangedEventFunctionHandler(func))
01792 
01793 #define EVT_IFM_SHOWCHILD(func)     wx__DECLARE_EVT0( wxEVT_IFM_SHOWCHILD, wxIFMShowChildEventFunctionHandler(func))
01794 #define EVT_IFM_HIDECHILD(func)     wx__DECLARE_EVT0( wxEVT_IFM_HIDECHILD, wxIFMShowChildEventFunctionHandler(func))
01795 #define EVT_IFM_SETCHILDSIZE(func)  wx__DECLARE_EVT0( wxEVT_IFM_SETCHILDSIZE, wxIFMSetChildSizeEventFunctionHandler(func))
01796 #define EVT_IFM_QUERYCHILD(func)    wx__DECLARE_EVT0( wxEVT_IFM_QUERYCHILD, wxIFMQueryChildEventFunctionHandler(func))
01797 
01798 // rect events
01799 #define EVT_IFM_SETRECT(func)       wx__DECLARE_EVT0( wxEVT_IFM_SETRECT, wxIFMRectEventFunctionHandler(func))
01800 #define EVT_IFM_SETBACKGROUNDRECT(func) wx__DECLARE_EVT0( wxEVT_IFM_SETBACKGROUNDRECT, wxIFMRectEventFunctionHandler(func))
01801 #define EVT_IFM_SETCLIENTRECT(func) wx__DECLARE_EVT0( wxEVT_IFM_SETCLIENTRECT, wxIFMRectEventFunctionHandler(func))
01802 #define EVT_IFM_GETRECT(func)       wx__DECLARE_EVT0( wxEVT_IFM_GETRECT, wxIFMRectEventFunctionHandler(func))
01803 #define EVT_IFM_GETBACKGROUNDRECT(func) wx__DECLARE_EVT0( wxEVT_IFM_GETBACKGROUNDRECT, wxIFMRectEventFunctionHandler(func))
01804 #define EVT_IFM_GETCLIENTRECT(func) wx__DECLARE_EVT0( wxEVT_IFM_GETCLIENTRECT, wxIFMRectEventFunctionHandler(func))
01805 #define EVT_IFM_CONVERTRECT(func)   wx__DECLARE_EVT0( wxEVT_IFM_CONVERTRECT, wxIFMConvertRectEventFunctionHandler(func))
01806 #define EVT_IFM_HITTEST(func)       wx__DECLARE_EVT0( wxEVT_IFM_HITTEST, wxIFMHitTestEventFunctionHandler(func))
01807 #define EVT_IFM_GETCONTENTRECT(func) wx__DECLARE_EVT0( wxEVT_IFM_GETCONTENTRECT, wxIFMRectEventFunctionHandler(func))
01808 
01809 #define EVT_IFM_UPDATE(func)        wx__DECLARE_EVT0( wxEVT_IFM_UPDATE, wxIFMUpdateEventFunctionHandler(func))
01810 #define EVT_IFM_UPDATECOMPONENT(func) wx__DECLARE_EVT0( wxEVT_IFM_UPDATECOMPONENT, wxIFMUpdateComponentEventFunctionHandler(func))
01811 #define EVT_IFM_CALCRECTS(func)     wx__DECLARE_EVT0( wxEVT_IFM_CALCRECTS, wxIFMCalcRectsEventFunctionHandler(func))
01812 
01813 #define EVT_IFM_GETDESIREDSIZE(func) wx__DECLARE_EVT0( wxEVT_IFM_GETDESIREDSIZE, wxIFMRectEventFunctionHandler(func))
01814 #define EVT_IFM_SETDESIREDSIZE(func) wx__DECLARE_EVT0( wxEVT_IFM_SETDESIREDSIZE, wxIFMRectEventFunctionHandler(func))
01815 #define EVT_IFM_GETMINSIZE(func)    wx__DECLARE_EVT0( wxEVT_IFM_GETMINSIZE, wxIFMRectEventFunctionHandler(func))
01816 #define EVT_IFM_SETMINSIZE(func)    wx__DECLARE_EVT0( wxEVT_IFM_SETMINSIZE, wxIFMRectEventFunctionHandler(func))
01817 #define EVT_IFM_GETMAXSIZE(func)    wx__DECLARE_EVT0( wxEVT_IFM_GETMAXSIZE, wxIFMRectEventFunctionHandler(func))
01818 #define EVT_IFM_SETMAXSIZE(func)    wx__DECLARE_EVT0( wxEVT_IFM_SETMAXSIZE, wxIFMRectEventFunctionHandler(func))
01819 
01820 // paint events
01821 /*
01822 Paint events are sent in this order:
01823 background, border, decorations
01824 */
01825 
01826 #define EVT_IFM_BEGINPAINT(func)    wx__DECLARE_EVT0( wxEVT_IFM_BEGINPAINT, wxIFMBeginPaintEventFunctionHandler(func))
01827 #define EVT_IFM_ENDPAINT(func)      wx__DECLARE_EVT0( wxEVT_IFM_ENDPAINT, wxIFMEndPaintEventFunctionHandler(func))
01828 #define EVT_IFM_PAINTINTERFACE(func) wx__DECLARE_EVT0( wxEVT_IFM_PAINTINTERFACE, wxIFMPaintInterfaceEventFunctionHandler(func))
01829 #define EVT_IFM_PAINTBG(func)       wx__DECLARE_EVT0( wxEVT_IFM_PAINTBG, wxIFMPaintEventFunctionHandler(func))
01830 #define EVT_IFM_PAINTBORDER(func)   wx__DECLARE_EVT0( wxEVT_IFM_PAINTBORDER, wxIFMPaintEventFunctionHandler(func))
01831 #define EVT_IFM_PAINTDECOR(func)    wx__DECLARE_EVT0( wxEVT_IFM_PAINTDECOR, wxIFMPaintEventFunctionHandler(func))
01832 
01833 // input events
01834 #define EVT_IFM_KEYDOWN(func)       wx__DECLARE_EVT0( wxEVT_IFM_KEYDOWN, wxIFMKeyEventFunctionHandler(func))
01835 #define EVT_IFM_KEYUP(func)         wx__DECLARE_EVT0( wxEVT_IFM_KEYUP, wxIFMKeyEventFunctionHandler(func))
01836 
01837 #define EVT_IFM_LEFTDOWN(func)      wx__DECLARE_EVT0( wxEVT_IFM_LEFTDOWN, wxIFMMouseEventFunctionHandler(func))
01838 #define EVT_IFM_LEFTUP(func)        wx__DECLARE_EVT0( wxEVT_IFM_LEFTUP, wxIFMMouseEventFunctionHandler(func))
01839 #define EVT_IFM_LEFTDCLICK(func)    wx__DECLARE_EVT0( wxEVT_IFM_LEFTDCLICK, wxIFMMouseEventFunctionHandler(func))
01840 #define EVT_IFM_RIGHTDOWN(func)     wx__DECLARE_EVT0( wxEVT_IFM_RIGHTDOWN, wxIFMMouseEventFunctionHandler(func))
01841 #define EVT_IFM_RIGHTUP(func)       wx__DECLARE_EVT0( wxEVT_IFM_RIGHTUP, wxIFMMouseEventFunctionHandler(func))
01842 #define EVT_IFM_RIGHTDCLICK(func)   wx__DECLARE_EVT0( wxEVT_IFM_RIGHTDCLICK, wxIFMMouseEventFunctionHandler(func))
01843 #define EVT_IFM_MIDDLEDOWN(func)    wx__DECLARE_EVT0( wxEVT_IFM_MIDDLEDOWN, wxIFMMouseEventFunctionHandler(func))
01844 #define EVT_IFM_MIDDLEUP(func)      wx__DECLARE_EVT0( wxEVT_IFM_MIDDLEUP, wxIFMMouseEventFunctionHandler(func))
01845 #define EVT_IFM_MIDDLEDCLICK(func)  wx__DECLARE_EVT0( wxEVT_IFM_MIDDLEDCLICK, wxIFMMouseEventFunctionHandler(func))
01846 #define EVT_IFM_MOTION(func)        wx__DECLARE_EVT0( wxEVT_IFM_MOTION, wxIFMMouseEventFunctionHandler(func))
01847 #define EVT_IFM_MOUSEWHEEL(func)    wx__DECLARE_EVT0( wxEVT_IFM_MOUSEWHEEL, wxIFMMouseEventFunctionHandler(func))
01848 
01849 #define EVT_IFM_SETCURSOR(func)     wx__DECLARE_EVT0( wxEVT_IFM_SETCURSOR, wxIFMSetCursorEventFunctionHandler(func))
01850 #define EVT_IFM_SETFOCUS(func)      wx__DECLARE_EVT0( wxEVT_IFM_SETFOCUS, wxIFMFocusEventFunctionHandler(func))
01851 #define EVT_IFM_KILLFOCUS(func)     wx__DECLARE_EVT0( wxEVT_IFM_KILLFOCUS, wxIFMFocusEventFunctionHandler(func))
01852 #define EVT_IFM_ACTIVATE(func)      wx__DECLARE_EVT0( wxEVT_IFM_ACTIVATE, wxIFMActivateEventFunctionHandler(func))
01853 
01854 // floating events
01855 #if IFM_CANFLOAT
01856 #define EVT_IFM_CREATEFLOATINGWINDOW(func) wx__DECLARE_EVT0( wxEVT_IFM_CREATEFLOATINGWINDOW, wxIFMCreateFloatingWindowEventFunctionHandler(func ))
01857 #define EVT_IFM_DESTROYFLOATINGWINDOW(func) wx__DECLARE_EVT0( wxEVT_IFM_DESTROYFLOATINGWINDOW, wxIFMDestroyFloatingWindowEventFunctionHandler(func ))
01858 #define EVT_IFM_FLOATING_SIZE(func)     wx__DECLARE_EVT0( wxEVT_IFM_FLOATING_SIZE, wxIFMFloatingSizeEventFunctionHandler(func ))
01859 #define EVT_IFM_FLOATING_SIZING(func)   wx__DECLARE_EVT0( wxEVT_IFM_FLOATING_SIZING, wxIFMFloatingSizeEventFunctionHandler(func ))
01860 #define EVT_IFM_FLOATING_MOVE(func)     wx__DECLARE_EVT0( wxEVT_IFM_FLOATING_MOVE, wxIFMFloatingMoveEventFunctionHandler(func ))
01861 #define EVT_IFM_FLOATING_MOVING(func)   wx__DECLARE_EVT0( wxEVT_IFM_FLOATING_MOVING, wxIFMFloatingMoveEventFunctionHandler(func ))
01862 #define EVT_IFM_FLOATING_NOTIFY(func)   wx__DECLARE_EVT0( wxEVT_IFM_FLOATING_NOTIFY, wxIFMFloatNotifyEventFunctionHandler(func ))
01863 #endif
01864 
01865 #endif

 

SourceForge Logo