vmap/radiant/pluginmanager.cpp

/*
   Copyright (C) 1999-2006 Id Software, Inc. and contributors.
   For a list of contributors, see the accompanying CONTRIBUTORS file.

   This file is part of GtkRadiant.

   GtkRadiant is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   GtkRadiant is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with GtkRadiant; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

// PlugInManager.cpp: implementation of the CPlugInManager class.
//
//////////////////////////////////////////////////////////////////////

#include "pluginmanager.h"

#include "modulesystem.h"
#include "qerplugin.h"
#include "iplugin.h"

#include "math/vector.h"
#include "string/string.h"

#include "error.h"
#include "select.h"
#include "plugin.h"

#include "modulesystem.h"

#include <list>

/* plugin manager --------------------------------------- */
class CPluginSlot : public IPlugIn {
    CopiedString m_menu_name;
    const _QERPluginTable *mpTable;
    std::list<CopiedString> m_CommandStrings;
    std::list<CopiedString> m_CommandTitleStrings;
    std::list<std::size_t> m_CommandIDs;

public:
/*!
   build directly from a SYN_PROVIDE interface
 */
    CPluginSlot(ui::Widget main_window, const char *name, const _QERPluginTable &table);

/*!
   dispatching a command by name to the plugin
 */
    void Dispatch(const char *p);

// IPlugIn ------------------------------------------------------------
    const char *getMenuName();

    std::size_t getCommandCount();

    const char *getCommand(std::size_t n);

    const char *getCommandTitle(std::size_t n);

    void addMenuID(std::size_t n);

    bool ownsCommandID(std::size_t n);

};

CPluginSlot::CPluginSlot(ui::Widget main_window, const char *name, const _QERPluginTable &table)
{
    mpTable = &table;
    m_menu_name = name;

    const char *commands = mpTable->m_pfnQERPlug_GetCommandList();
    const char *titles = mpTable->m_pfnQERPlug_GetCommandTitleList();

    StringTokeniser commandTokeniser(commands, ",;");
    StringTokeniser titleTokeniser(titles, ",;");

    const char *cmdToken = commandTokeniser.getToken();
    const char *titleToken = titleTokeniser.getToken();
    while (!string_empty(cmdToken)) {
        if (string_empty(titleToken)) {
            m_CommandStrings.push_back(cmdToken);
            m_CommandTitleStrings.push_back(cmdToken);
            cmdToken = commandTokeniser.getToken();
            titleToken = "";
        } else {
            m_CommandStrings.push_back(cmdToken);
            m_CommandTitleStrings.push_back(titleToken);
            cmdToken = commandTokeniser.getToken();
            titleToken = titleTokeniser.getToken();
        }
    }
    mpTable->m_pfnQERPlug_Init(0, (void *) main_window);
}

const char *CPluginSlot::getMenuName()
{
    return m_menu_name.c_str();
}

std::size_t CPluginSlot::getCommandCount()
{
    return m_CommandStrings.size();
}

const char *CPluginSlot::getCommand(std::size_t n)
{
    std::list<CopiedString>::iterator i = m_CommandStrings.begin();
    while (n-- != 0) {
        ++i;
    }
    return (*i).c_str();
}

const char *CPluginSlot::getCommandTitle(std::size_t n)
{
    std::list<CopiedString>::iterator i = m_CommandTitleStrings.begin();
    while (n-- != 0) {
        ++i;
    }
    return (*i).c_str();
}

void CPluginSlot::addMenuID(std::size_t n)
{
    m_CommandIDs.push_back(n);
}

bool CPluginSlot::ownsCommandID(std::size_t n)
{
    for (std::list<std::size_t>::iterator i = m_CommandIDs.begin(); i != m_CommandIDs.end(); ++i) {
        if (*i == n) {
            return true;
        }
    }
    return false;
}

void CPluginSlot::Dispatch(const char *p)
{
    Vector3 vMin, vMax;
    Select_GetBounds(vMin, vMax);
    mpTable->m_pfnQERPlug_Dispatch(p, reinterpret_cast<float *>( &vMin ), reinterpret_cast<float *>( &vMax ),
                                   true); //QE_SingleBrush(true));
}


class CPluginSlots {
    std::list<CPluginSlot *> mSlots;
public:
    virtual ~CPluginSlots();

    void AddPluginSlot(ui::Widget main_window, const char *name, const _QERPluginTable &table)
    {
        mSlots.push_back(new CPluginSlot(main_window, name, table));
    }

    void PopulateMenu(PluginsVisitor &menu);

    bool Dispatch(std::size_t n, const char *p);
};

CPluginSlots::~CPluginSlots()
{
    std::list<CPluginSlot *>::iterator iSlot;
    for (iSlot = mSlots.begin(); iSlot != mSlots.end(); ++iSlot) {
        delete *iSlot;
        *iSlot = 0;
    }
}

void CPluginSlots::PopulateMenu(PluginsVisitor &menu)
{
    std::list<CPluginSlot *>::iterator iPlug;
    for (iPlug = mSlots.begin(); iPlug != mSlots.end(); ++iPlug) {
        menu.visit(*(*iPlug));
    }
}

bool CPluginSlots::Dispatch(std::size_t n, const char *p)
{
    std::list<CPluginSlot *>::iterator iPlug;
    for (iPlug = mSlots.begin(); iPlug != mSlots.end(); ++iPlug) {
        CPluginSlot *pPlug = *iPlug;
        if (pPlug->ownsCommandID(n)) {
            pPlug->Dispatch(p);
            return true;
        }
    }
    return false;
}

CPluginSlots g_plugin_slots;


void FillPluginSlots(CPluginSlots &slots, ui::Widget main_window)
{
    class AddPluginVisitor : public PluginModules::Visitor {
        CPluginSlots &m_slots;
        ui::Widget m_main_window;
    public:
        AddPluginVisitor(CPluginSlots &slots, ui::Widget main_window)
                : m_slots(slots), m_main_window(main_window)
        {
        }

        void visit(const char *name, const _QERPluginTable &table) const
        {
            m_slots.AddPluginSlot(m_main_window, name, table);
        }
    } visitor(slots, main_window);

    Radiant_getPluginModules().foreachModule(visitor);
}


#include "pluginmanager.h"

CPlugInManager g_PlugInMgr;

CPlugInManager &GetPlugInMgr()
{
    return g_PlugInMgr;
}

void CPlugInManager::Dispatch(std::size_t n, const char *p)
{
    g_plugin_slots.Dispatch(n, p);
}

void CPlugInManager::Init(ui::Widget main_window)
{
    FillPluginSlots(g_plugin_slots, main_window);
}

void CPlugInManager::constructMenu(PluginsVisitor &menu)
{
    g_plugin_slots.PopulateMenu(menu);
}

void CPlugInManager::Shutdown()
{
}