plugin.cpp

Go to the documentation of this file.

#include "../../include/wxIFM/plugin.h"

#if IFM_USE_WX_RTTI
IMPLEMENT_DYNAMIC_CLASS(wxIFMInterfacePluginBase, wxEvtHandler);
IMPLEMENT_DYNAMIC_CLASS(wxIFMExtensionPluginBase, wxEvtHandler);
#endif

/*
wxIFMInterfacePluginBase implementation
*/
wxIFMInterfacePluginBase::wxIFMInterfacePluginBase()
    : wxEvtHandler(),
    m_manager(NULL),
    m_topExtensionPlugin(NULL)
{ }

wxInterfaceManager *wxIFMInterfacePluginBase::GetManager()
{
    return m_manager;
}

const wxIFMComponentArray &wxIFMInterfacePluginBase::GetComponents() const
{
    return m_components;
}

#if IFM_CANFLOAT
const wxIFMFloatingWindowArray &wxIFMInterfacePluginBase::GetFloatingWindows() const
{
    return m_floatingWindows;
}
#endif

bool wxIFMInterfacePluginBase::Initialize(wxInterfaceManager *manager)
{
    m_manager = manager;

    // connect events
#if IFM_USE_NEW_EVENTS
    GetManager()->Connect(wxID_ANY, wxEVT_PAINT, wxPaintEventHandler(wxIFMInterfacePluginBase::OnPaint), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_SET_CURSOR, wxSetCursorEventHandler(wxIFMInterfacePluginBase::OnSetCursor), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_MOTION, wxMouseEventHandler(wxIFMInterfacePluginBase::OnMouseEvent), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_LEFT_DOWN, wxMouseEventHandler(wxIFMInterfacePluginBase::OnMouseEvent), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_LEFT_UP, wxMouseEventHandler(wxIFMInterfacePluginBase::OnMouseEvent), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_MIDDLE_DOWN, wxMouseEventHandler(wxIFMInterfacePluginBase::OnMouseEvent), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_MIDDLE_UP, wxMouseEventHandler(wxIFMInterfacePluginBase::OnMouseEvent), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_RIGHT_DOWN, wxMouseEventHandler(wxIFMInterfacePluginBase::OnMouseEvent), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_RIGHT_UP, wxMouseEventHandler(wxIFMInterfacePluginBase::OnMouseEvent), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_LEFT_DCLICK, wxMouseEventHandler(wxIFMInterfacePluginBase::OnMouseEvent), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_MIDDLE_DCLICK, wxMouseEventHandler(wxIFMInterfacePluginBase::OnMouseEvent), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_RIGHT_DCLICK, wxMouseEventHandler(wxIFMInterfacePluginBase::OnMouseEvent), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_MOUSEWHEEL, wxMouseEventHandler(wxIFMInterfacePluginBase::OnMouseEvent), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_KEY_DOWN, wxKeyEventHandler(wxIFMInterfacePluginBase::OnKeyDown), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_KEY_UP, wxKeyEventHandler(wxIFMInterfacePluginBase::OnKeyUp), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_SIZE, wxSizeEventHandler(wxIFMInterfacePluginBase::OnSize), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_SET_FOCUS, wxFocusEventHandler(wxIFMInterfacePluginBase::OnFocus), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_KILL_FOCUS, wxFocusEventHandler(wxIFMInterfacePluginBase::OnFocus), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_ACTIVATE, wxActivateEventHandler(wxIFMInterfacePluginBase::OnActivate), NULL, this);
#else
    GetManager()->Connect(wxID_ANY, wxEVT_PAINT, (wxObjectEventFunction)(&wxIFMInterfacePluginBase::OnPaint), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_SET_CURSOR, (wxObjectEventFunction)(&wxIFMInterfacePluginBase::OnSetCursor), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_MOTION, (wxObjectEventFunction)(&wxIFMInterfacePluginBase::OnMouseEvent), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_LEFT_DOWN, (wxObjectEventFunction)(&wxIFMInterfacePluginBase::OnMouseEvent), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_LEFT_UP, (wxObjectEventFunction)(&wxIFMInterfacePluginBase::OnMouseEvent), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_MIDDLE_DOWN, (wxObjectEventFunction)(&wxIFMInterfacePluginBase::OnMouseEvent), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_MIDDLE_UP, (wxObjectEventFunction)(&wxIFMInterfacePluginBase::OnMouseEvent), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_RIGHT_DOWN, (wxObjectEventFunction)(&wxIFMInterfacePluginBase::OnMouseEvent), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_RIGHT_UP, (wxObjectEventFunction)(&wxIFMInterfacePluginBase::OnMouseEvent), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_LEFT_DCLICK, (wxObjectEventFunction)(&wxIFMInterfacePluginBase::OnMouseEvent), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_MIDDLE_DCLICK, (wxObjectEventFunction)(&wxIFMInterfacePluginBase::OnMouseEvent), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_RIGHT_DCLICK, (wxObjectEventFunction)(&wxIFMInterfacePluginBase::OnMouseEvent), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_MOUSEWHEEL, (wxObjectEventFunction)(&wxIFMInterfacePluginBase::OnMouseEvent), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_KEY_DOWN, (wxObjectEventFunction)(&wxIFMInterfacePluginBase::OnKeyDown), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_KEY_UP, (wxObjectEventFunction)(&wxIFMInterfacePluginBase::OnKeyUp), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_SIZE, (wxObjectEventFunction)(&wxIFMInterfacePluginBase::OnSize), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_SET_FOCUS, (wxObjectEventFunction)(&wxIFMInterfacePluginBase::OnFocus), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_KILL_FOCUS, (wxObjectEventFunction)(&wxIFMInterfacePluginBase::OnFocus), NULL, this);
    GetManager()->Connect(wxID_ANY, wxEVT_ACTIVATE, (wxObjectEventFunction)(&wxIFMInterfacePluginBase::OnActivate), NULL, this);
#endif
    return true;
}

void wxIFMInterfacePluginBase::Shutdown()
{
    // remove extensions
    PopAllExtensionPlugins();
}

bool wxIFMInterfacePluginBase::ProcessPluginEvent(wxIFMPluginEvent &event)
{
    // initialize the component member for child events
    if( event.GetEventType() == wxEVT_IFM_SHOWCHILD || event.GetEventType() == wxEVT_IFM_HIDECHILD ||
        event.GetEventType() == wxEVT_IFM_SETCHILDSIZE || event.GetEventType() == wxEVT_IFM_QUERYCHILD)
    {
#if IFM_USE_WX_RTTI
        wxIFMChildEvent *evt = wxDynamicCast(&event, wxIFMChildEvent);
#else
        wxIFMChildEvent *evt = dynamic_cast<wxIFMChildEvent*>(&event);
#endif
        if( evt )
        {
            evt->SetComponent(FindChildWindow(evt->GetChild()));
            return GetTopPlugin()->ProcessEvent(*evt);
        }
    }

    // process the event
    bool ret = GetTopPlugin()->ProcessEvent(event);

    if( event.GetEventType() == wxEVT_IFM_NEWCOMPONENT )
    {
#if IFM_USE_WX_RTTI
        wxIFMNewComponentEvent *evt = wxDynamicCast(&event, wxIFMNewComponentEvent);
#else
        wxIFMNewComponentEvent *evt = dynamic_cast<wxIFMNewComponentEvent*>(&event);
#endif
        if( evt )
            m_components.push_back(evt->GetComponent());
    }
    else if( event.GetEventType() == wxEVT_IFM_DELETECOMPONENT )
    {
#if IFM_USE_WX_RTTI
        wxIFMDeleteComponentEvent *evt = wxDynamicCast(&event, wxIFMDeleteComponentEvent);
#else
        wxIFMDeleteComponentEvent *evt = dynamic_cast<wxIFMDeleteComponentEvent*>(&event);
#endif
        if( evt )
        {
            wxIFMComponent *component = evt->GetComponent();
            // find and remove this component from the array
            //for( int i = 0, count = m_components.GetCount(); i < count; ++i )
            for( wxIFMComponentArray::iterator i = m_components.begin(), end = m_components.end(); i != end; ++i )
            {
                if( *i /*m_components[i]*/ == component )
                {
                    //m_components.RemoveAt(i);
                    m_components.erase(i);
                    break;
                }
            }
            delete component;
        }
    }

    return ret;
}

void wxIFMInterfacePluginBase::AddPendingPluginEvent(wxIFMPluginEvent &event)
{
    GetTopPlugin()->AddPendingEvent(event);
}

wxIFMInterfacePluginBase::~wxIFMInterfacePluginBase()
{
    // memory cleanup
    PopAllExtensionPlugins();

    // delete components
    for( int i = 0, count = m_components.GetCount(); i < count; ++i )
    //for( wxIFMComponentArray::const_iterator i = m_components.begin(), end = m_components.end(); i != end; ++i )
        delete m_components[i];
        //delete *i;
}

bool wxIFMInterfacePluginBase::PushExtensionPlugin(wxIFMExtensionPluginBase *plugin)
{
    // initialize the plugin
    if( !plugin->Initialize(this) )
        return false;

    // link event handlers
    if( m_topExtensionPlugin )
    {
        plugin->SetNextHandler(m_topExtensionPlugin);
        m_topExtensionPlugin->SetPreviousHandler(plugin);
    }
    else
    {
        // link the first plugin to ourself
        plugin->SetNextHandler(this);
        SetPreviousHandler(plugin);
    }

    m_topExtensionPlugin = plugin;
    return true;
}

void wxIFMInterfacePluginBase::PopExtensionPlugin()
{
    wxASSERT_MSG(m_topExtensionPlugin, wxT("Popping from an empty plugin list"));

    m_topExtensionPlugin->Shutdown();

    // re-link event handlers
    wxEvtHandler *plugin = m_topExtensionPlugin->GetNextHandler();

    if( plugin )
        plugin->SetPreviousHandler(NULL);
    else
        SetPreviousHandler(NULL); // unlink the last plugin from ourself

    delete m_topExtensionPlugin;
#if IFM_USE_WX_RTTI
    m_topExtensionPlugin = wxDynamicCast(plugin, wxIFMExtensionPluginBase);
#else
    m_topExtensionPlugin = dynamic_cast<wxIFMExtensionPluginBase*>(plugin);
#endif
}

void wxIFMInterfacePluginBase::PopAllExtensionPlugins()
{
    while(m_topExtensionPlugin)
        PopExtensionPlugin();
}

wxEvtHandler *wxIFMInterfacePluginBase::GetTopPlugin()
{
    if( m_topExtensionPlugin )
        return m_topExtensionPlugin;
    else
        return this;
}

void wxIFMInterfacePluginBase::Enable(bool val)
{
    wxEvtHandler::SetEvtHandlerEnabled(val);

    // enable or disable all extension plugins
    wxIFMExtensionPluginBase *plugin = m_topExtensionPlugin;
    while(plugin)
    {
        plugin->Enable(val);
#if IFM_USE_WX_RTTI
        plugin = wxDynamicCast(plugin->GetNextHandler(), wxIFMExtensionPluginBase);
#else
        plugin = dynamic_cast<wxIFMExtensionPluginBase*>(plugin->GetNextHandler());
#endif
    }

    // enable or disable the default plugin too
    GetNextHandler()->SetEvtHandlerEnabled(val);
}

wxIFMComponent *wxIFMInterfacePluginBase::GetComponentByPos(const wxPoint &pos, wxIFMComponent *component, bool floating)
{
#if IFM_CANFLOAT
    if( floating )
    {
        wxIFMComponent *component = GetFloatingComponentByPos(m_manager->GetParent()->ClientToScreen(pos));
        if( component )
            return component;
    }
#endif

    if( component == NULL )
    {
        wxIFMComponent *ret;
        for( int i = 0, count = m_components.GetCount(); i < count; ++i )
        //for( wxIFMComponentArray::const_iterator i = m_components.begin(), end = m_components.end(); i != end; ++i )
        {
            ret = GetComponentByPos(pos, m_components[i]);
            if( ret )
                return ret;
        }
        return NULL;
    }

    //wxIFMHitTestEvent evt(component, IFM_COORDS_ABSOLUTE, pos);
    //ProcessPluginEvent(evt);

    //if( evt.GetPassed() )
    if( !component->m_hidden && component->m_rect.Inside(pos) )
    {
        // check children
        wxIFMComponent *ret;
        const wxIFMComponentArray &components = component->m_children;
        for( int i = 0, count = components.GetCount(); i < count; ++i )
        //for( wxIFMComponentArray::const_iterator i = components.begin(), end = components.end(); i != end; ++i )
        {
            ret = GetComponentByPos(pos, components[i]);
            if( ret )
                return ret;
        }
        return component;
    }

    return NULL;
}

#if IFM_CANFLOAT
wxIFMComponent *wxIFMInterfacePluginBase::GetFloatingComponentByPos(const wxPoint &pos)
{
    wxIFMFloatingWindowBase *base;
    wxIFMComponent *ret;

    for( int i = 0, size = m_floatingWindows.GetCount(); i < size; ++i )
    //for( wxIFMFloatingWindowArray::const_iterator i = m_floatingWindows.begin(), end = m_floatingWindows.end(); i != end; ++i )
    {
        base = m_floatingWindows[i];
        //base = *i;

        ret = GetComponentByPos(base->GetWindow()->ScreenToClient(pos), base->GetComponent());
        if( ret )
            return ret;
    }

    return NULL;
}
#endif

void wxIFMInterfacePluginBase::AddChildWindow(wxWindow *window, wxIFMComponent *component)
{
    // store the child window / component pair
    m_windows[(int)window] = component;
}

wxIFMComponent *wxIFMInterfacePluginBase::FindChildWindow(wxWindow *window)
{
    return m_windows[(int)window];
}

void wxIFMInterfacePluginBase::OnMouseEvent(wxMouseEvent &event)
{
    wxEventType type = 0, _type = event.GetEventType();

    if( _type == wxEVT_LEFT_DOWN )
        type = wxEVT_IFM_LEFTDOWN;
    else if( _type == wxEVT_LEFT_UP )
        type = wxEVT_IFM_LEFTUP;
    else if( _type == wxEVT_LEFT_DCLICK )
        type = wxEVT_IFM_LEFTDCLICK;
    else if( _type == wxEVT_RIGHT_DOWN )
        type = wxEVT_IFM_RIGHTDOWN;
    else if( _type == wxEVT_RIGHT_UP )
        type = wxEVT_IFM_RIGHTUP;
    else if( _type == wxEVT_RIGHT_DCLICK )
        type = wxEVT_IFM_RIGHTDCLICK;
    else if( _type == wxEVT_MIDDLE_DOWN )
        type = wxEVT_IFM_MIDDLEDOWN;
    else if( _type == wxEVT_MIDDLE_UP )
        type = wxEVT_IFM_MIDDLEUP;
    else if( _type == wxEVT_MIDDLE_DCLICK )
        type = wxEVT_IFM_MIDDLEDCLICK;
    else if( _type == wxEVT_MOTION )
        type = wxEVT_IFM_MOTION;
    else if( _type == wxEVT_MOUSEWHEEL )
        type = wxEVT_IFM_MOUSEWHEEL;

    // figure out which component the mouse is over
    wxIFMComponent *component = NULL;

    if( m_manager->IsInputCaptured() )
        component = m_manager->GetCapturedComponent();
    else
        component = GetComponentByPos(event.GetPosition());

    // generate mouse event
    wxIFMMouseEvent evt(type, component, event);
    if( !ProcessPluginEvent(evt) )
        event.Skip();
}

void wxIFMInterfacePluginBase::OnSetCursor(wxSetCursorEvent &event)
{
    wxIFMSetCursorEvent evt(event, GetComponentByPos(wxPoint(event.GetX(), event.GetY())));
    if( !ProcessPluginEvent(evt) )
        event.Skip();
}

void wxIFMInterfacePluginBase::OnKeyDown(wxKeyEvent &event)
{
    wxIFMKeyEvent evt(wxEVT_IFM_KEYDOWN, m_manager->GetCapturedComponent(), event);
    if( !ProcessPluginEvent(evt) )
        event.Skip();
}

void wxIFMInterfacePluginBase::OnKeyUp(wxKeyEvent &event)
{
    wxIFMKeyEvent evt(wxEVT_IFM_KEYUP, m_manager->GetCapturedComponent(), event);
    if( !ProcessPluginEvent(evt) )
        event.Skip();
}

void wxIFMInterfacePluginBase::OnPaint(wxPaintEvent &event)
{
    // send BEGINPAINT message to get a DC with which to paint
    wxIFMBeginPaintEvent beginpaint(m_manager->GetParent());
    ProcessPluginEvent(beginpaint);

    // make sure we have a valid dc
    wxDC *dc = beginpaint.GetDC();
    wxASSERT_MSG(dc, wxT("Invalid DC returned by EVT_IFM_BEGINPAINT"));

    // send paint interface event
    wxIFMPaintInterfaceEvent paintevt(*dc, GetManager()->GetParent()->GetUpdateRegion());
    ProcessPluginEvent(paintevt);

    // send ENDPAINT message to clean up the DC used to paint
    wxIFMEndPaintEvent endpaint(dc);
    ProcessPluginEvent(endpaint);

    // let the frame paint itself too
#if !defined(__WXMAC__) && !defined(__WXCOCOA)
    event.Skip();
#endif
}

void wxIFMInterfacePluginBase::OnSize(wxSizeEvent &event)
{
    // update the interface
    if( m_manager->GetFlags() & IFM_NO_RESIZE_UPDATE )
        event.Skip();
    else
        m_manager->Update();
}

void wxIFMInterfacePluginBase::OnFocus(wxFocusEvent &event)
{
    // send focus event
    wxIFMFocusEvent evt((event.GetEventType() == wxEVT_SET_FOCUS) ? wxEVT_IFM_SETFOCUS : wxEVT_IFM_KILLFOCUS, event);
    if( !ProcessPluginEvent(evt) )
        event.Skip();
}

void wxIFMInterfacePluginBase::OnActivate(wxActivateEvent &event)
{
    wxIFMActivateEvent evt(event);
    if( !ProcessPluginEvent(evt) )
        event.Skip();
}

/*
wxIFMExtensionPluginBase implementation
*/
wxIFMExtensionPluginBase::wxIFMExtensionPluginBase()
    : wxEvtHandler(),
    m_ip(NULL)
{ }

wxIFMExtensionPluginBase::~wxIFMExtensionPluginBase()
{ }

wxInterfaceManager *wxIFMExtensionPluginBase::GetManager()
{
    return m_ip->GetManager();
}

wxIFMInterfacePluginBase *wxIFMExtensionPluginBase::GetIP()
{
    return m_ip;
}

bool wxIFMExtensionPluginBase::Initialize(wxIFMInterfacePluginBase *plugin)
{
    wxASSERT_MSG(!m_ip, wxT("Interface plugin has already been set!"));
    m_ip = plugin;
    return true;
}

void wxIFMExtensionPluginBase::Shutdown()
{ }

void wxIFMExtensionPluginBase::Enable(bool val)
{
    wxEvtHandler::SetEvtHandlerEnabled(val);
}

void wxIFMExtensionPluginBase::Disable()
{
    Enable(false);
}