dragndrop.h

Go to the documentation of this file.

#ifndef _IFM_DND_H_
#define _IFM_DND_H_

#include "definterface.h"

#include <wx/frame.h>
#include <wx/dcscreen.h>
//#include <vector>

class wxIFMDefaultDockingPlugin;
class wxIFMInitDragEvent;
class wxIFMDragEvent;
class wxIFMDockTargetButton;
class wxIFMShowDropTargetsEvent;

DECLARE_EVENT_TYPE(wxEVT_IFM_INITDRAG, 0);
DECLARE_EVENT_TYPE(wxEVT_IFM_BEGINDRAG, 0);
DECLARE_EVENT_TYPE(wxEVT_IFM_ENDDRAG, 0);
DECLARE_EVENT_TYPE(wxEVT_IFM_DRAGGING, 0);

DECLARE_EVENT_TYPE(wxEVT_IFM_SHOWDROPTARGETS, 0);

#define IFM_DOCK_TARGET_BUTTON_WIDTH    20
#define IFM_DOCK_TARGET_BUTTON_SIZE     wxSize(IFM_DOCK_TARGET_BUTTON_WIDTH, IFM_DOCK_TARGET_BUTTON_WIDTH)

#define IFM_DRAG_DISTANCE 4 // how many pixels the mouse must move before dragging starts (only if SystemMetrics doesn't know)

//typedef std::vector<wxIFMDockTargetButton *> DockButtonArray;
WX_DEFINE_ARRAY(wxIFMDockTargetButton*, DockButtonArray);

enum dock_button_icons
{
    IFM_DOCK_ICON_LEFT,
    IFM_DOCK_ICON_RIGHT,
    IFM_DOCK_ICON_TOP,
    IFM_DOCK_ICON_BOTTOM,
    IFM_DOCK_ICON_TAB
};

enum dock_button_ids
{
    IFM_DOCK_ID_LEFT,
    IFM_DOCK_ID_RIGHT,
    IFM_DOCK_ID_BOTTOM,
    IFM_DOCK_ID_TOP,
    IFM_DOCK_ID_TAB,

    IFM_DOCK_ID_FRAME_LEFT,
    IFM_DOCK_ID_FRAME_RIGHT,
    IFM_DOCK_ID_FRAME_BOTTOM,
    IFM_DOCK_ID_FRAME_TOP
};

class wxIFMDefaultDockingPlugin : public wxIFMExtensionPluginBase
{
private:

    wxIFMDefaultInterfacePlugin *m_ip;

    bool m_realtime, m_dragging, m_captured;
    wxPoint m_offset, m_oldPos, m_clickPos;
    int m_dragx, m_dragy;

    wxRect m_hintRect;

    DockButtonArray m_dockButtonArray;
    wxIFMDockTargetButton *m_oldBtn;

#if IFM_CANFLOAT
    wxIFMFloatingWindowBase *m_window;
#endif

public:

    wxIFMDefaultDockingPlugin();

    bool Initialize(wxIFMInterfacePluginBase *plugin);

private:

    void OnLeftDown(wxIFMMouseEvent &event);
#if IFM_CANFLOAT
    void OnLeftDClick(wxIFMMouseEvent &event);
#endif
    void OnLeftUp(wxIFMMouseEvent &event);
    void OnMouseMove(wxIFMMouseEvent &event);
    void OnKeyDown(wxIFMKeyEvent &event);

    void OnDragInit(wxIFMInitDragEvent &event);
    void OnDragBegin(wxIFMDragEvent &event);
    void OnDragEnd(wxIFMDragEvent &event);
    void OnDrag(wxIFMDragEvent &event);
    void OnDock(wxIFMDockEvent &event);
    void OnShowDropTargets(wxIFMShowDropTargetsEvent &event);

    void DrawHintRect(wxDC &dc, const wxRect &rect);
    
    void CreateTargetButtons();
    void DestroyTargetButtons();

    void ShowFrameDropButtons(bool show = true);
    void ShowComponentDropButtons(bool show  = true);

    wxIFMDockTargetButton *GetDockTargetButtonByPos(const wxPoint &pos);

#if IFM_CANFLOAT
    wxIFMComponent *GetFloatingComponentByPosExclusion(const wxPoint &pos, wxIFMFloatingWindowBase *exclude);
#endif

    DECLARE_EVENT_TABLE()

#if IFM_USE_WX_RTTI
    DECLARE_DYNAMIC_CLASS_NO_COPY(wxIFMDefaultDockingPlugin)
#endif
};

class wxIFMInitDragEvent : public wxIFMPluginEvent
{
private:
    wxIFMComponent *m_drag; 
    wxPoint m_pos; 

public:
    wxIFMInitDragEvent(wxIFMComponent *component, wxIFMComponent *drag, const wxPoint &pos)
        : wxIFMPluginEvent(wxEVT_IFM_INITDRAG, component),
        m_drag(drag),
        m_pos(pos)
    { }

    wxIFMInitDragEvent(const wxIFMInitDragEvent &event)
        : wxIFMPluginEvent(event),
        m_drag(event.m_drag),
        m_pos(event.m_pos)
    { }

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

    wxIFMComponent *GetDraggedComponent() const { return m_drag; }

    const wxPoint &GetPos() const { return m_pos; }
};

class wxIFMDragEvent : public wxIFMPluginEvent
{
private:

    wxPoint m_pos;
    bool m_canceled, m_realtime;
    bool m_altDown, m_ctrlDown, m_shiftDown;

public:

    wxIFMDragEvent(wxEventType type, wxIFMComponent *component,
        wxPoint pos, bool alt, bool shift, bool control,
        bool realtime = false, bool canceled = false)
        : wxIFMPluginEvent(type, component),
        m_pos(pos),
        m_canceled(canceled),
        m_realtime(realtime),
        m_altDown(alt),
        m_ctrlDown(control),
        m_shiftDown(shift)
    { }

    wxIFMDragEvent(const wxIFMDragEvent &event)
        : wxIFMPluginEvent(event),
        m_pos(event.m_pos),
        m_canceled(event.m_canceled),
        m_realtime(event.m_realtime),
        m_altDown(event.m_altDown),
        m_ctrlDown(event.m_ctrlDown),
        m_shiftDown(event.m_shiftDown)
    { }

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

    const wxPoint &GetPosition() const { return m_pos; }

    bool WasCanceled() const { return m_canceled; }

    bool RealtimeUpdates() const { return m_realtime; }

    bool ControlDown() const { return m_ctrlDown; }

    bool ShiftDown() const { return m_shiftDown; }

    bool AltDown() const { return m_altDown; }
};

class wxIFMDockEventEx : public wxIFMDockEvent
{
private:
    int m_where; // above, below, right, left, into

public:
#if IFM_USE_WX_RTTI
    // default ctor for wx rtti to work
    wxIFMDockEventEx() : wxIFMDockEvent(0, 0, 0) { }
#endif

    wxIFMDockEventEx(wxIFMComponent *component, wxIFMComponent *destination,
        int index, int where)
        : wxIFMDockEvent(component, destination, index),
        m_where(where)
    { }

    wxIFMDockEventEx(const wxIFMDockEventEx &event)
        : wxIFMDockEvent(event),
        m_where(event.m_where)
    { }

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

    int GetWhere() const { return m_where; }
    void SetIndex(int i) { m_index = i; }

#if IFM_USE_WX_RTTI
    DECLARE_DYNAMIC_CLASS(wxIFMDockEventEx)
#endif
};

/*
class wxIFMDropTargetEventBase : public wxIFMPluginEvent
{
public:
    wxIFMDropTargetEventBase(wxInterfaceManager *manager, wxEventType id, wxIFMComponent *component = NULL,
        )
        : wxIFMPluginEvent(manager, id, component)
};
*/

class wxIFMShowDropTargetsEvent : public wxIFMPluginEvent
{
private:
    wxPoint m_pos; // position of mouse in client coordinates
    wxIFMComponent *m_draggedComponent; // component being dragged

public:
    wxIFMShowDropTargetsEvent( wxIFMComponent *component,
        const wxPoint &pos, wxIFMComponent *dragged_component)
        : wxIFMPluginEvent(wxEVT_IFM_SHOWDROPTARGETS, component),
        m_pos(pos),
        m_draggedComponent(dragged_component)
    { }

    wxIFMShowDropTargetsEvent(const wxIFMShowDropTargetsEvent &event)
        : wxIFMPluginEvent(event),
        m_pos(event.m_pos),
        m_draggedComponent(event.m_draggedComponent)
    { }

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

    const wxPoint &GetPosition() const { return m_pos; }

    wxIFMComponent *GetDraggedComponent() const { return m_draggedComponent; }
};

// commenting out the mac "fix" because it messed up coordinates and makes the buttons
// appear in the wrong spot
#if 0 //defined(__WXMAC__) || defined (__WXCOCOA)
class wxIFMDockTargetButton : public wxWindow // dont use a frame on macs to avoid messiness
#else
class wxIFMDockTargetButton : public wxFrame
#endif
{
private:

    bool m_hover;
    int m_id, m_icon;

    wxIFMComponent *m_component;

public:

    wxIFMDockTargetButton(wxWindow *parent, const wxPoint &pos, int id, int icon, wxIFMComponent *component = NULL);

    void SetHover(bool hover = true);

    int GetId() const { return m_id; }

    void SetComponent(wxIFMComponent *component) { m_component = component; }
    wxIFMComponent *GetComponent() const { return m_component; }

private:

    void OnEraseBackground(wxEraseEvent &event);
    void OnPaint(wxPaintEvent &event);

    DECLARE_EVENT_TABLE()
};

typedef void (wxEvtHandler::*wxIFMInitDragEventFunction)(wxIFMInitDragEvent&);
typedef void (wxEvtHandler::*wxIFMDragEventFunction)(wxIFMDragEvent&);
typedef void (wxEvtHandler::*wxIFMShowDropTargetsEventFunction)(wxIFMShowDropTargetsEvent&);

#define wxIFMInitDragEventFunctionHandler(func) \
    (wxObjectEventFunction)wxStaticCastEvent(wxIFMInitDragEventFunction, &func)
#define wxIFMDragEventFunctionHandler(func) \
    (wxObjectEventFunction)wxStaticCastEvent(wxIFMDragEventFunction, &func)
#define wxIFMShowDropTargetsEventFunctionHandler(func) \
    (wxObjectEventFunction)wxStaticCastEvent(wxIFMShowDropTargetsEventFunction, &func)

#define EVT_IFM_DRAG_INIT(func)     wx__DECLARE_EVT0(wxEVT_IFM_INITDRAG, wxIFMInitDragEventFunctionHandler(func))
#define EVT_IFM_DRAG_BEGIN(func)    wx__DECLARE_EVT0(wxEVT_IFM_BEGINDRAG, wxIFMDragEventFunctionHandler(func))
#define EVT_IFM_DRAG_END(func)      wx__DECLARE_EVT0(wxEVT_IFM_ENDDRAG, wxIFMDragEventFunctionHandler(func))
#define EVT_IFM_DRAG_DRAGGING(func) wx__DECLARE_EVT0(wxEVT_IFM_DRAGGING, wxIFMDragEventFunctionHandler(func))
#define EVT_IFM_SHOWDROPTARGETS(func) wx__DECLARE_EVT0(wxEVT_IFM_SHOWDROPTARGETS, wxIFMShowDropTargetsEventFunctionHandler(func))

#endif