Use the data scheme to load resources in the WebKitGTK+ implementation, rather than...

[wxWidgets.git] / src / common / module.cpp

diff --git a/src/common/module.cpp b/src/common/module.cpp
index f1d0bebed748271964c2af7a3f90eb2601d75392..3532ceb1497cb06e571faab4034b2e9e7080a35a 100644 (file)
--- a/src/common/module.cpp
+++ b/src/common/module.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        module.cpp
+// Name:        src/common/module.cpp

 // Purpose:     Modules initialization/destruction
 // Author:      Wolfram Gloger/adapted by Guilhem Lavaux
 // Modified by:
 // Purpose:     Modules initialization/destruction
 // Author:      Wolfram Gloger/adapted by Guilhem Lavaux
 // Modified by:


@@ -9,93 +9,217 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 

-#ifdef __GNUG__
-#pragma implementation "module.h"
-#endif
-

 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__

-#pragma hdrstop
+    #pragma hdrstop

 #endif
 
 #include "wx/module.h"
 #endif
 
 #include "wx/module.h"

-#include "wx/hash.h"
-#include "wx/listimpl.cpp"

 
 

-#ifdef __SALFORDC__
-void wxwxModuleListNode::DeleteData()
-{
-    delete (_WX_LIST_ITEM_TYPE_wxModuleList *)GetData();
-}
-#else
-WX_DEFINE_LIST(wxModuleList);
+#ifndef WX_PRECOMP
+    #include "wx/hash.h"
+    #include "wx/intl.h"
+    #include "wx/log.h"

 #endif
 
 #endif
 

-IMPLEMENT_CLASS(wxModule, wxObject)
+#include "wx/listimpl.cpp"
+
+#define TRACE_MODULE wxT("module")
+
+WX_DEFINE_LIST(wxModuleList)
+
+wxIMPLEMENT_ABSTRACT_CLASS(wxModule, wxObject)

 
 wxModuleList wxModule::m_modules;
 
 void wxModule::RegisterModule(wxModule* module)
 {
 
 wxModuleList wxModule::m_modules;
 
 void wxModule::RegisterModule(wxModule* module)
 {

+    module->m_state = State_Registered;

     m_modules.Append(module);
 }
 
     m_modules.Append(module);
 }
 

+void wxModule::UnregisterModule(wxModule* module)
+{
+    m_modules.DeleteObject(module);
+    delete module;
+}
+

 // Collect up all module-derived classes, create an instance of each,
 // and register them.
 void wxModule::RegisterModules()
 {
 // Collect up all module-derived classes, create an instance of each,
 // and register them.
 void wxModule::RegisterModules()
 {

-    wxNode *node;
-    wxClassInfo* classInfo;
-
-    wxClassInfo::sm_classTable->BeginFind();
-    node = wxClassInfo::sm_classTable->Next();
-    while (node)
+    for (wxClassInfo::const_iterator it  = wxClassInfo::begin_classinfo(),
+                                     end = wxClassInfo::end_classinfo();
+         it != end; ++it)

     {
     {

-        classInfo = (wxClassInfo *)node->Data();
+        const wxClassInfo* classInfo = *it;
+

         if ( classInfo->IsKindOf(CLASSINFO(wxModule)) &&
         if ( classInfo->IsKindOf(CLASSINFO(wxModule)) &&

-            (classInfo != (& (wxModule::sm_classwxModule))) )
+             (classInfo != (& (wxModule::ms_classInfo))) )

         {
         {

+            wxLogTrace(TRACE_MODULE, wxT("Registering module %s"),
+                       classInfo->GetClassName());

             wxModule* module = (wxModule *)classInfo->CreateObject();
             wxModule* module = (wxModule *)classInfo->CreateObject();

-            RegisterModule(module);
+            wxModule::RegisterModule(module);

         }
         }

-        node = wxClassInfo::sm_classTable->Next();

     }
 }
 
     }
 }
 

-bool wxModule::InitializeModules()
+bool wxModule::DoInitializeModule(wxModule *module,
+                                  wxModuleList &initializedModules)

 {
 {

-    // Initialize user-defined modules
-    wxModuleList::Node *node;
-    for ( node = m_modules.GetFirst(); node; node = node->GetNext() )
+    if ( module->m_state == State_Initializing )
+    {
+        wxLogError(_("Circular dependency involving module \"%s\" detected."),
+                   module->GetClassInfo()->GetClassName());
+        return false;
+    }
+
+    module->m_state = State_Initializing;
+
+    // translate named dependencies to the normal ones first
+    if ( !module->ResolveNamedDependencies() )
+      return false;
+
+    const wxArrayClassInfo& dependencies = module->m_dependencies;
+
+    // satisfy module dependencies by loading them before the current module
+    for ( unsigned int i = 0; i < dependencies.size(); ++i )

     {
     {

-        if ( !node->GetData()->Init() )
+        wxClassInfo * cinfo = dependencies[i];
+
+        // Check if the module is already initialized
+        wxModuleList::compatibility_iterator node;
+        for ( node = initializedModules.GetFirst(); node; node = node->GetNext() )
+        {
+            if ( node->GetData()->GetClassInfo() == cinfo )
+                break;
+        }
+
+        if ( node )
+        {
+            // this dependency is already initialized, nothing to do
+            continue;
+        }
+
+        // find the module in the registered modules list
+        for ( node = m_modules.GetFirst(); node; node = node->GetNext() )

         {
         {

-            // clean up already initialized modules - process in reverse order
-            wxModuleList::Node *n;
-            for ( n = node->GetPrevious(); n; n = n->GetPrevious() )
+            wxModule *moduleDep = node->GetData();
+            if ( moduleDep->GetClassInfo() == cinfo )

             {
             {

-                n->GetData()->OnExit();
+                if ( !DoInitializeModule(moduleDep, initializedModules ) )
+                {
+                    // failed to initialize a dependency, so fail this one too
+                    return false;
+                }
+
+                break;

             }
             }

+        }

 
 

-            return FALSE;
+        if ( !node )
+        {
+            wxLogError(_("Dependency \"%s\" of module \"%s\" doesn't exist."),
+                       cinfo->GetClassName(),
+                       module->GetClassInfo()->GetClassName());
+            return false;

         }
     }
 
         }
     }
 

-    return TRUE;
+    if ( !module->Init() )
+    {
+        wxLogError(_("Module \"%s\" initialization failed"),
+                   module->GetClassInfo()->GetClassName());
+        return false;
+    }
+
+    wxLogTrace(TRACE_MODULE, wxT("Module \"%s\" initialized"),
+               module->GetClassInfo()->GetClassName());
+
+    module->m_state = State_Initialized;
+    initializedModules.Append(module);
+
+    return true;

 }
 
 }
 

-void wxModule::CleanUpModules()
+// Initialize user-defined modules
+bool wxModule::InitializeModules()

 {
 {

-    // Cleanup user-defined modules
-    wxModuleList::Node *node;
-    for ( node = m_modules.GetFirst(); node; node = node->GetNext() )
+    wxModuleList initializedModules;
+
+    for ( wxModuleList::compatibility_iterator node = m_modules.GetFirst();
+          node;
+          node = node->GetNext() )

     {
     {

-        node->GetData()->Exit();
+        wxModule *module = node->GetData();
+
+        // the module could have been already initialized as dependency of
+        // another one
+        if ( module->m_state == State_Registered )
+        {
+            if ( !DoInitializeModule( module, initializedModules ) )
+            {
+                // failed to initialize all modules, so clean up the already
+                // initialized ones
+                DoCleanUpModules(initializedModules);
+
+                return false;
+            }
+        }

     }
 
     }
 

-    m_modules.DeleteContents(TRUE);
-    m_modules.Clear();
+    // remember the real initialisation order
+    m_modules = initializedModules;
+
+    return true;

 }
 
 }
 

+// Clean up all currently initialized modules
+void wxModule::DoCleanUpModules(const wxModuleList& modules)
+{
+    // cleanup user-defined modules in the reverse order compared to their
+    // initialization -- this ensures that dependencies are respected
+    for ( wxModuleList::compatibility_iterator node = modules.GetLast();
+          node;
+          node = node->GetPrevious() )
+    {
+        wxLogTrace(TRACE_MODULE, wxT("Cleanup module %s"),
+                   node->GetData()->GetClassInfo()->GetClassName());
+
+        wxModule * module = node->GetData();
+
+        wxASSERT_MSG( module->m_state == State_Initialized,
+                        wxT("not initialized module being cleaned up") );
+
+        module->Exit();
+        module->m_state = State_Registered;
+    }
+
+    // clear all modules, even the non-initialized ones
+    WX_CLEAR_LIST(wxModuleList, m_modules);
+}
+
+bool wxModule::ResolveNamedDependencies()
+{
+    // first resolve required dependencies
+    for ( size_t i = 0; i < m_namedDependencies.size(); ++i )
+    {
+        wxClassInfo *info = wxClassInfo::FindClass(m_namedDependencies[i]);
+
+        if ( !info )
+        {
+            // required dependency not found
+            return false;
+        }
+
+        // add it even if it is not derived from wxModule because
+        // DoInitializeModule() will make sure a module with the same class
+        // info exists and fail if it doesn't
+        m_dependencies.Add(info);
+    }
+
+    return true;
+}