radiant/pluginmanager.cpp

   1 /*
   2    Copyright (C) 1999-2006 Id Software, Inc. and contributors.
   3    For a list of contributors, see the accompanying CONTRIBUTORS file.
   4
   5    This file is part of GtkRadiant.
   6
   7    GtkRadiant is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    GtkRadiant is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GtkRadiant; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20  */
  21
  22 // PlugInManager.cpp: implementation of the CPlugInManager class.
  23 //
  24 //////////////////////////////////////////////////////////////////////
  25
  26 #include "pluginmanager.h"
  27
  28 #include "modulesystem.h"
  29 #include "qerplugin.h"
  30 #include "iplugin.h"
  31
  32 #include "math/vector.h"
  33 #include "string/string.h"
  34
  35 #include "error.h"
  36 #include "select.h"
  37 #include "plugin.h"
  38
  39 #include "modulesystem.h"
  40
  41 #include <list>
  42
  43 /* plugin manager --------------------------------------- */
  44 class CPluginSlot : public IPlugIn
  45 {
  46 CopiedString m_menu_name;
  47 const _QERPluginTable *mpTable;
  48 std::list<CopiedString> m_CommandStrings;
  49 std::list<CopiedString> m_CommandTitleStrings;
  50 std::list<std::size_t> m_CommandIDs;
  51
  52 public:
  53 /*!
  54    build directly from a SYN_PROVIDE interface
  55  */
  56 CPluginSlot( GtkWidget* main_window, const char* name, const _QERPluginTable& table );
  57 /*!
  58    dispatching a command by name to the plugin
  59  */
  60 void Dispatch( const char *p );
  61
  62 // IPlugIn ------------------------------------------------------------
  63 const char* getMenuName();
  64 std::size_t getCommandCount();
  65 const char* getCommand( std::size_t n );
  66 const char* getCommandTitle( std::size_t n );
  67 void addMenuID( std::size_t n );
  68 bool ownsCommandID( std::size_t n );
  69
  70 };
  71
  72 CPluginSlot::CPluginSlot( GtkWidget* main_window, const char* name, const _QERPluginTable& table ){
  73         mpTable = &table;
  74         m_menu_name = name;
  75
  76         const char* commands = mpTable->m_pfnQERPlug_GetCommandList();
  77         const char* titles = mpTable->m_pfnQERPlug_GetCommandTitleList();
  78
  79         StringTokeniser commandTokeniser( commands, ",;" );
  80         StringTokeniser titleTokeniser( titles, ",;" );
  81
  82         const char* cmdToken = commandTokeniser.getToken();
  83         const char *titleToken = titleTokeniser.getToken();
  84         while ( !string_empty( cmdToken ) )
  85         {
  86                 if ( string_empty( titleToken ) ) {
  87                         m_CommandStrings.push_back( cmdToken );
  88                         m_CommandTitleStrings.push_back( cmdToken );
  89                         cmdToken = commandTokeniser.getToken();
  90                         titleToken = "";
  91                 }
  92                 else
  93                 {
  94                         m_CommandStrings.push_back( cmdToken );
  95                         m_CommandTitleStrings.push_back( titleToken );
  96                         cmdToken = commandTokeniser.getToken();
  97                         titleToken = titleTokeniser.getToken();
  98                 }
  99         }
 100         mpTable->m_pfnQERPlug_Init( 0, (void*)main_window );
 101 }
 102
 103 const char* CPluginSlot::getMenuName(){
 104         return m_menu_name.c_str();
 105 }
 106
 107 std::size_t CPluginSlot::getCommandCount(){
 108         return m_CommandStrings.size();
 109 }
 110
 111 const char* CPluginSlot::getCommand( std::size_t n ){
 112         std::list<CopiedString>::iterator i = m_CommandStrings.begin();
 113         while ( n-- != 0 )
 114                 ++i;
 115         return ( *i ).c_str();
 116 }
 117
 118 const char* CPluginSlot::getCommandTitle( std::size_t n ){
 119         std::list<CopiedString>::iterator i = m_CommandTitleStrings.begin();
 120         while ( n-- != 0 )
 121                 ++i;
 122         return ( *i ).c_str();
 123 }
 124
 125 void CPluginSlot::addMenuID( std::size_t n ){
 126         m_CommandIDs.push_back( n );
 127 }
 128
 129 bool CPluginSlot::ownsCommandID( std::size_t n ){
 130         for ( std::list<std::size_t>::iterator i = m_CommandIDs.begin(); i != m_CommandIDs.end(); ++i )
 131         {
 132                 if ( *i == n ) {
 133                         return true;
 134                 }
 135         }
 136         return false;
 137 }
 138
 139 void CPluginSlot::Dispatch( const char *p ){
 140         Vector3 vMin, vMax;
 141         Select_GetBounds( vMin, vMax );
 142         mpTable->m_pfnQERPlug_Dispatch( p, reinterpret_cast<float*>( &vMin ), reinterpret_cast<float*>( &vMax ), true ); //QE_SingleBrush(true));
 143 }
 144
 145
 146 class CPluginSlots
 147 {
 148 std::list<CPluginSlot *> mSlots;
 149 public:
 150 virtual ~CPluginSlots();
 151
 152 void AddPluginSlot( GtkWidget* main_window, const char* name, const _QERPluginTable& table ){
 153         mSlots.push_back( new CPluginSlot( main_window, name, table ) );
 154 }
 155
 156 void PopulateMenu( PluginsVisitor& menu );
 157 bool Dispatch( std::size_t n, const char* p );
 158 };
 159
 160 CPluginSlots::~CPluginSlots(){
 161         std::list<CPluginSlot *>::iterator iSlot;
 162         for ( iSlot = mSlots.begin(); iSlot != mSlots.end(); ++iSlot )
 163         {
 164                 delete *iSlot;
 165                 *iSlot = 0;
 166         }
 167 }
 168
 169 void CPluginSlots::PopulateMenu( PluginsVisitor& menu ){
 170         std::list<CPluginSlot *>::iterator iPlug;
 171         for ( iPlug = mSlots.begin(); iPlug != mSlots.end(); ++iPlug )
 172         {
 173                 menu.visit( *( *iPlug ) );
 174         }
 175 }
 176
 177 bool CPluginSlots::Dispatch( std::size_t n, const char* p ){
 178         std::list<CPluginSlot *>::iterator iPlug;
 179         for ( iPlug = mSlots.begin(); iPlug != mSlots.end(); ++iPlug )
 180         {
 181                 CPluginSlot *pPlug = *iPlug;
 182                 if ( pPlug->ownsCommandID( n ) ) {
 183                         pPlug->Dispatch( p );
 184                         return true;
 185                 }
 186         }
 187         return false;
 188 }
 189
 190 CPluginSlots g_plugin_slots;
 191
 192
 193 void FillPluginSlots( CPluginSlots& slots, GtkWidget* main_window ){
 194         class AddPluginVisitor : public PluginModules::Visitor
 195         {
 196         CPluginSlots& m_slots;
 197         GtkWidget* m_main_window;
 198 public:
 199         AddPluginVisitor( CPluginSlots& slots, GtkWidget* main_window )
 200                 : m_slots( slots ), m_main_window( main_window ){
 201         }
 202         void visit( const char* name, const _QERPluginTable& table ) const {
 203                 m_slots.AddPluginSlot( m_main_window, name, table );
 204         }
 205         } visitor( slots, main_window );
 206
 207         Radiant_getPluginModules().foreachModule( visitor );
 208 }
 209
 210
 211 #include "pluginmanager.h"
 212
 213 CPlugInManager g_PlugInMgr;
 214
 215 CPlugInManager& GetPlugInMgr(){
 216         return g_PlugInMgr;
 217 }
 218
 219 void CPlugInManager::Dispatch( std::size_t n, const char * p ){
 220         g_plugin_slots.Dispatch( n, p );
 221 }
 222
 223 void CPlugInManager::Init( GtkWidget* main_window ){
 224         FillPluginSlots( g_plugin_slots, main_window );
 225 }
 226
 227 void CPlugInManager::constructMenu( PluginsVisitor& menu ){
 228         g_plugin_slots.PopulateMenu( menu );
 229 }
 230
 231 void CPlugInManager::Shutdown(){
 232 }