]> git.xonotic.org Git - xonotic/netradiant.git/blob - radiant/pluginmanager.cpp
Hack around segfault at launch, patch from danfe: https://github.com/TTimo/GtkRadiant...
[xonotic/netradiant.git] / 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 }