Module Class Reference

The Module type reflects the latest Module specification. Do NOT subclass from Module, but use the latest Module revision (e.g. Module_v42). The Module type should only be used by the Kernel and OIL layers, never by Modules themselves. More...

#include <module.h>

Inheritance diagram for Module:

List of all members.

Static Public Member Functions
static BOOL	InitModules ()
	Called at the end of initialisation (as it may well need all other initialisations to have been done) to add Tools and Modules to the Kernel's knowledgebase.
static void	DeinitModules ()
	Deletes all allocated modules (and hence tools), then asks OIL to tidy up. Safe to call more than once.
static ModuleListItem *	Find (UINT32 ModuleID)
	Anyone can ask about a module's presence by its ID.
static ModuleListItem *	Declare (Module *, OILModule *)
	Called by OIL code to declare new modules.
Private Member Functions
	CC_DECLARE_MEMDUMP (Module)
Static Private Member Functions
static BOOL	CreateTools ()
	Scan all modules known to the kernel, and try to create an instance of each tool they contain, and add this tool to the kernel's list.
Static Private Attributes
static ModuleList *	Modules = NULL

---

Detailed Description

The Module type reflects the latest Module specification. Do NOT subclass from Module, but use the latest Module revision (e.g. Module_v42). The Module type should only be used by the Kernel and OIL layers, never by Modules themselves.

Author:

Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>

Date:

30/6/93

The modules known to the kernel are contained in the Modules object, which is pointer to an instance of the class ModuleList. This class should be used to declare/search for modules, etc.

See also:

Module_v1; ModuleList; ModuleListItem; Tool

Definition at line 258 of file module.h.

---

Member Function Documentation

Module::CC_DECLARE_MEMDUMP (  Module   )  [private]

BOOL Module::CreateTools (   )  [static, private]

Scan all modules known to the kernel, and try to create an instance of each tool they contain, and add this tool to the kernel's list. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 1/7/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE => Tools created OK. Errors: - See also: - Definition at line 332 of file module.cpp. { // Scan the list of modules ModuleListItem *Item = (ModuleListItem *) Modules->GetHead(); while (Item != NULL) { // Interrogate module ModInfo Info; Item->m_pModule->Describe(&Info); // Try to create an instance of each tool in this module for (unsigned tool = 1; tool <= Info.NumTools; tool++) { Tool *NewTool = (Tool *) Item->m_pModule->CreateTool(tool); if (NewTool != NULL) { // Tool was created - add it to the list Tool::Declare(NewTool, Info.ID); } } // Try the next module in the list. Item = (ModuleListItem *) Modules->GetNext(Item); } // Tool* NewTool ; // NewTool = (Tool*)new ZoomTool; if ( NewTool ) Tool::Declare(NewTool,1); // NewTool = (Tool*)new PushTool; if ( NewTool ) Tool::Declare(NewTool,Info.ID); // No error codes yet return TRUE; }

ModuleListItem * Module::Declare (  Module *  NewModule, OILModule *  pOILModule )  [static]

Called by OIL code to declare new modules. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 21/6/93 Parameters: NewModule  - pointer to a new Tool and its ID [INPUTS] pOILModule - pointer to the OILModule object to be associated with this module. None  [OUTPUTS] Returns: Pointer to new module list item if module. Errors: Will return NULL if invalid ID or same module ID used twice, and NewModule will have been deleted. Definition at line 227 of file module.cpp. { // Try to add the module to the kernel's list. ModuleListItem *NewItem = Modules->Add(NewModule, pOILModule); if (NewItem == NULL) { // Either out of memory or Module has invalid ID - print error message and // destroy module. #ifdef _DEBUG ModInfo Info; NewModule->Describe(&Info); TRACE( _T("Module %u is invalid or has no memory to initialise with.\n"), Info.ID ); #endif delete NewModule; } return NewItem; }

void Module::DeinitModules (   )  [static]

Deletes all allocated modules (and hence tools), then asks OIL to tidy up. Safe to call more than once. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 21/6/93 Parameters: None  [INPUTS] None  [OUTPUTS] Returns: None Do NOT try to use any tools or modules after calling this. Returns: Errors: None Definition at line 300 of file module.cpp. { if (Modules != NULL) { // Delete the list itself. delete Modules; Modules = NULL; // Perform any clean-up required by the OIL layer. PORTNOTE("other","Removed OILModule usage") #ifndef EXCLUDE_FROM_XARALX OILModule::Deinit(); #endif } }

ModuleListItem * Module::Find (  UINT32  ModuleID  )  [static]

Anyone can ask about a module's presence by its ID. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/6/93 Parameters: Module  ID [INPUTS] None  [OUTPUTS] Returns: Pointer to list item of the required module, or NULL if not found. Errors: None. Definition at line 263 of file module.cpp. { // Simple search of list for ID ModuleListItem *Item = (ModuleListItem *) Modules->GetHead(); while (Item != NULL) { if (Item->m_ModInfo.ID == ModuleID) // Found ID - return pointer to this list item. return Item; Item = (ModuleListItem *) Modules->GetNext(Item); } // Not found return NULL; }

BOOL Module::InitModules (   )  [static]

Called at the end of initialisation (as it may well need all other initialisations to have been done) to add Tools and Modules to the Kernel's knowledgebase. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/6/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if OK, FALSE for catastrophic failure Errors: None Scope: Public Definition at line 146 of file module.cpp. { // Initialise the list of Modules. Modules = new ModuleList; if (!Modules) return FALSE; if (!OILModule::Init()) // get OIL's list of modules. This works return FALSE; // by calling back to DescribeModule. // NB. OILModule::Init does it own error BOOL Finished; // reporting do { // All the modules have been 'new'ed now. We can now ask them to initialise themselves. // If they don't want to, they get 'delete'ed. ModuleListItem *Item = (ModuleListItem *) Modules->GetHead(); Finished = TRUE; while (Item != NULL) { Module *Module = Item->m_pModule; // If this module exists and has not been initialised yet, then try to // initialise it. If it initialises ok, set the item's flag, and force // another scan of the remaining modules in case one of them depends on // this module being present. if ((Module != NULL) && (!Item->m_Initialised) && (Module->Init())) { Item->m_Initialised = TRUE; // Tool initialised ok. Finished = FALSE; // At least one more loop to try } // Try the next module Item = (ModuleListItem *) Modules->GetNext(Item); } } while (!Finished); // Delete any un-initialised modules ModuleListItem *Item = (ModuleListItem *) Modules->GetHead(); while (Item != NULL) { if ((Item->m_pModule != NULL) && (!Item->m_Initialised)) { delete Item->m_pModule; Item->m_pModule = NULL; } // Try the next module Item = (ModuleListItem *) Modules->GetNext(Item); } // Scan all the modules and create (but do not initialise) any tools they provide. if (!Tool::InitToolList() || !CreateTools()) return FALSE; return TRUE; }

---

Member Data Documentation

ModuleList * Module::Modules = NULL [static, private]

Definition at line 270 of file module.h.

---

The documentation for this class was generated from the following files:

• Kernel/module.h (r1785/r1282)
• Kernel/module.cpp (r1785/r1464)

---