]> git.saurik.com Git - wxWidgets.git/blob - src/common/dynload.cpp
Fix ribbon documentation warnings.
[wxWidgets.git] / src / common / dynload.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/dynload.cpp
3 // Purpose: Dynamic loading framework
4 // Author: Ron Lee, David Falkinder, Vadim Zeitlin and a cast of 1000's
5 // (derived in part from dynlib.cpp (c) 1998 Guilhem Lavaux)
6 // Modified by:
7 // Created: 03/12/01
8 // Copyright: (c) 2001 Ron Lee <ron@debian.org>
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ----------------------------------------------------------------------------
13 // headers
14 // ----------------------------------------------------------------------------
15
16 #include "wx/wxprec.h"
17
18 #ifdef __BORLANDC__
19 #pragma hdrstop
20 #endif
21
22 #if wxUSE_DYNAMIC_LOADER
23
24 #ifdef __WINDOWS__
25 #include "wx/msw/private.h"
26 #endif
27
28 #ifndef WX_PRECOMP
29 #include "wx/log.h"
30 #include "wx/intl.h"
31 #include "wx/hash.h"
32 #include "wx/utils.h"
33 #include "wx/module.h"
34 #endif
35
36 #include "wx/strconv.h"
37
38 #include "wx/dynload.h"
39
40
41 // ---------------------------------------------------------------------------
42 // wxPluginLibrary
43 // ---------------------------------------------------------------------------
44
45
46 wxDLImports* wxPluginLibrary::ms_classes = NULL;
47
48 class wxPluginLibraryModule : public wxModule
49 {
50 public:
51 wxPluginLibraryModule() { }
52
53 // TODO: create ms_classes on demand, why always preallocate it?
54 virtual bool OnInit()
55 {
56 wxPluginLibrary::ms_classes = new wxDLImports;
57 wxPluginManager::CreateManifest();
58 return true;
59 }
60
61 virtual void OnExit()
62 {
63 wxDELETE(wxPluginLibrary::ms_classes);
64 wxPluginManager::ClearManifest();
65 }
66
67 private:
68 DECLARE_DYNAMIC_CLASS(wxPluginLibraryModule )
69 };
70
71 IMPLEMENT_DYNAMIC_CLASS(wxPluginLibraryModule, wxModule)
72
73
74 wxPluginLibrary::wxPluginLibrary(const wxString &libname, int flags)
75 : m_linkcount(1)
76 , m_objcount(0)
77 {
78 const wxClassInfo* const oldFirst = wxClassInfo::GetFirst();
79 Load( libname, flags );
80
81 // It is simple to know what is the first object in the linked list of
82 // wxClassInfo that we registered (it's also the last one chronologically),
83 // it's just the new head of the wxClassInfo list:
84 m_ourFirst = wxClassInfo::GetFirst();
85
86 // But to find the first wxClassInfo created by this library we need to
87 // iterate until we get to the previous head as we don't have the links in
88 // the backwards direction:
89 if ( m_ourFirst != oldFirst )
90 {
91 for ( const wxClassInfo* info = m_ourFirst; ; info = info->GetNext() )
92 {
93 if ( info->GetNext() == oldFirst )
94 {
95 m_ourLast = info;
96 break;
97 }
98 }
99 }
100 else // We didn't register any classes at all.
101 {
102 m_ourFirst =
103 m_ourLast = NULL;
104 }
105
106 if( m_handle != 0 )
107 {
108 UpdateClasses();
109 RegisterModules();
110 }
111 else
112 {
113 // Flag us for deletion
114 --m_linkcount;
115 }
116 }
117
118 wxPluginLibrary::~wxPluginLibrary()
119 {
120 if( m_handle != 0 )
121 {
122 UnregisterModules();
123 RestoreClasses();
124 }
125 }
126
127 wxPluginLibrary *wxPluginLibrary::RefLib()
128 {
129 wxCHECK_MSG( m_linkcount > 0, NULL,
130 wxT("Library had been already deleted!") );
131
132 ++m_linkcount;
133 return this;
134 }
135
136 bool wxPluginLibrary::UnrefLib()
137 {
138 wxASSERT_MSG( m_objcount == 0,
139 wxT("Library unloaded before all objects were destroyed") );
140
141 if ( m_linkcount == 0 || --m_linkcount == 0 )
142 {
143 delete this;
144 return true;
145 }
146
147 return false;
148 }
149
150 // ------------------------
151 // Private methods
152 // ------------------------
153
154 void wxPluginLibrary::UpdateClasses()
155 {
156 if ( !m_ourFirst )
157 return;
158
159 for ( const wxClassInfo *info = m_ourFirst; ; info = info->GetNext() )
160 {
161 if( info->GetClassName() )
162 {
163 // Hash all the class names into a local table too so
164 // we can quickly find the entry they correspond to.
165 (*ms_classes)[info->GetClassName()] = this;
166 }
167
168 if ( info == m_ourLast )
169 break;
170 }
171 }
172
173 void wxPluginLibrary::RestoreClasses()
174 {
175 // Check if there is a need to restore classes.
176 if (!ms_classes)
177 return;
178
179 if ( !m_ourFirst )
180 return;
181
182 for ( const wxClassInfo *info = m_ourFirst; ; info = info->GetNext() )
183 {
184 ms_classes->erase(ms_classes->find(info->GetClassName()));
185
186 if ( info == m_ourLast )
187 break;
188 }
189 }
190
191 void wxPluginLibrary::RegisterModules()
192 {
193 // Plugin libraries might have wxModules, Register and initialise them if
194 // they do.
195 //
196 // Note that these classes are NOT included in the reference counting since
197 // it's implicit that they will be unloaded if and when the last handle to
198 // the library is. We do have to keep a copy of the module's pointer
199 // though, as there is currently no way to Unregister it without it.
200
201 wxASSERT_MSG( m_linkcount == 1,
202 wxT("RegisterModules should only be called for the first load") );
203
204 if ( m_ourFirst )
205 {
206 for ( const wxClassInfo *info = m_ourFirst; ; info = info->GetNext() )
207 {
208 if( info->IsKindOf(wxCLASSINFO(wxModule)) )
209 {
210 wxModule *m = wxDynamicCast(info->CreateObject(), wxModule);
211
212 wxASSERT_MSG( m, wxT("wxDynamicCast of wxModule failed") );
213
214 m_wxmodules.push_back(m);
215 wxModule::RegisterModule(m);
216 }
217
218 if ( info == m_ourLast )
219 break;
220 }
221 }
222
223 // FIXME: Likewise this is (well was) very similar to InitializeModules()
224
225 for ( wxModuleList::iterator it = m_wxmodules.begin();
226 it != m_wxmodules.end();
227 ++it)
228 {
229 if( !(*it)->Init() )
230 {
231 wxLogDebug(wxT("wxModule::Init() failed for wxPluginLibrary"));
232
233 // XXX: Watch this, a different hash implementation might break it,
234 // a good hash implementation would let us fix it though.
235
236 // The name of the game is to remove any uninitialised modules and
237 // let the dtor Exit the rest on shutdown, (which we'll initiate
238 // shortly).
239
240 wxModuleList::iterator oldNode = m_wxmodules.end();
241 do {
242 ++it;
243 if( oldNode != m_wxmodules.end() )
244 m_wxmodules.erase(oldNode);
245 wxModule::UnregisterModule( *it );
246 oldNode = it;
247 } while( it != m_wxmodules.end() );
248
249 --m_linkcount; // Flag us for deletion
250 break;
251 }
252 }
253 }
254
255 void wxPluginLibrary::UnregisterModules()
256 {
257 wxModuleList::iterator it;
258
259 for ( it = m_wxmodules.begin(); it != m_wxmodules.end(); ++it )
260 (*it)->Exit();
261
262 for ( it = m_wxmodules.begin(); it != m_wxmodules.end(); ++it )
263 wxModule::UnregisterModule( *it );
264
265 // NB: content of the list was deleted by UnregisterModule calls above:
266 m_wxmodules.clear();
267 }
268
269
270 // ---------------------------------------------------------------------------
271 // wxPluginManager
272 // ---------------------------------------------------------------------------
273
274 wxDLManifest* wxPluginManager::ms_manifest = NULL;
275
276 // ------------------------
277 // Static accessors
278 // ------------------------
279
280 wxPluginLibrary *
281 wxPluginManager::LoadLibrary(const wxString &libname, int flags)
282 {
283 wxString realname(libname);
284
285 if( !(flags & wxDL_VERBATIM) )
286 realname += wxDynamicLibrary::GetDllExt(wxDL_MODULE);
287
288 wxPluginLibrary *entry;
289
290 if ( flags & wxDL_NOSHARE )
291 {
292 entry = NULL;
293 }
294 else
295 {
296 entry = FindByName(realname);
297 }
298
299 if ( entry )
300 {
301 wxLogTrace(wxT("dll"),
302 wxT("LoadLibrary(%s): already loaded."), realname.c_str());
303
304 entry->RefLib();
305 }
306 else
307 {
308 entry = new wxPluginLibrary( libname, flags );
309
310 if ( entry->IsLoaded() )
311 {
312 (*ms_manifest)[realname] = entry;
313
314 wxLogTrace(wxT("dll"),
315 wxT("LoadLibrary(%s): loaded ok."), realname.c_str());
316
317 }
318 else
319 {
320 wxLogTrace(wxT("dll"),
321 wxT("LoadLibrary(%s): failed to load."), realname.c_str());
322
323 // we have created entry just above
324 if ( !entry->UnrefLib() )
325 {
326 // ... so UnrefLib() is supposed to delete it
327 wxFAIL_MSG( wxT("Currently linked library is not loaded?") );
328 }
329
330 entry = NULL;
331 }
332 }
333
334 return entry;
335 }
336
337 bool wxPluginManager::UnloadLibrary(const wxString& libname)
338 {
339 wxString realname = libname;
340
341 wxPluginLibrary *entry = FindByName(realname);
342
343 if ( !entry )
344 {
345 realname += wxDynamicLibrary::GetDllExt(wxDL_MODULE);
346
347 entry = FindByName(realname);
348 }
349
350 if ( !entry )
351 {
352 wxLogDebug(wxT("Attempt to unload library '%s' which is not loaded."),
353 libname.c_str());
354
355 return false;
356 }
357
358 wxLogTrace(wxT("dll"), wxT("UnloadLibrary(%s)"), realname.c_str());
359
360 if ( !entry->UnrefLib() )
361 {
362 // not really unloaded yet
363 return false;
364 }
365
366 ms_manifest->erase(ms_manifest->find(realname));
367
368 return true;
369 }
370
371 // ------------------------
372 // Class implementation
373 // ------------------------
374
375 bool wxPluginManager::Load(const wxString &libname, int flags)
376 {
377 m_entry = wxPluginManager::LoadLibrary(libname, flags);
378
379 return IsLoaded();
380 }
381
382 void wxPluginManager::Unload()
383 {
384 wxCHECK_RET( m_entry, wxT("unloading an invalid wxPluginManager?") );
385
386 for ( wxDLManifest::iterator i = ms_manifest->begin();
387 i != ms_manifest->end();
388 ++i )
389 {
390 if ( i->second == m_entry )
391 {
392 ms_manifest->erase(i);
393 break;
394 }
395 }
396
397 m_entry->UnrefLib();
398
399 m_entry = NULL;
400 }
401
402 #endif // wxUSE_DYNAMIC_LOADER