PlugInManager Class Reference

Provide general handling facilities for plug-ins in Camelot. More...

#include <plugmngr.h>

Inheritance diagram for PlugInManager:

List of all members.

Public Member Functions
	PlugInManager ()
	Main constructor for the plug-in manager in Camelot.
	~PlugInManager ()
	Main destructor for the plug-in manager in Camelot.
BOOL	Init ()
	Main initialisation code for the plug-in manager in Camelot.
BOOL	GetParseAtStartUp ()
void	SetParseAtStartUp (BOOL NewState)
BOOL	GetPlugInPath (PathName *NewSearchPath)
	Allows the requesting of a pathname to parse plug-ins for from the user. Its pops up a modified form of the stanadard file dialog box set up to browse explicitly for paths rather than files. Used by the plug-ins options tab.
BOOL	AddPlugIn (PlugInItem *pPlugIn)
	Add a plug-in to the list in the plug-in manager and register the op desciptor to the system.
BOOL	RemovePlugIn (PlugInItem *pPlugIn)
	Removes a plug-in from the list in the plug-in manager (if it's there).
PlugInItem *	GetFirstPlugIn ()
	Get the first plug-in item in the list stored in the plug-in manager.
PlugInItem *	GetNextPlugIn (PlugInItem *pPlugIn)
	Get the next plug-in item in the list stored in the plug-in manager.
BOOL	AddPlugInPath (const PathName &NewSearchPath)
	Adds a new pathname to the list of pathnames stored in the plug-in manager.
BOOL	DeletePlugInPath (const PathName &SearchPath)
	Deletes a pathname from the list of pathnames stored in the plug-in manager.
PlugInPath *	GetFirstPathName ()
	Get the first plug-in pathname in the list stored in the plug-in manager. This is just the list of user defined paths and does not include the hidden paths that are stored in the list as well.
PlugInPath *	GetNextPathName (PlugInPath *pPath)
	Get the next plug-in pathname in the list stored in the plug-in manager. This is just the list of user defined paths and does not include the hidden paths that are stored in the list as well.
PlugInItem *	GetPreviousPlugIn (PlugInItem *pPlugIn)
	Get the previous plug-in item in the list stored in the plug-in manager.
BOOL	GetPlugInPathname (INT32 PathNameID, String_256 *pPathName)
	Converts a pathanme id which is stored with each plug-in into the real pathname that it corresponds to by searching the pathname list in the plug-in manager.
BOOL	SearchForPlugIns ()
	Starts up the process of parsing all the paths specified to the plug-in manager for plug-ins and stroing information on them in a list. This is called during start up so needs to check the flag to see whether the user has requested this to be done at the start, before actually trying to parse.
BOOL	CheckHaveDetailsOnPlugIns ()
	Checks to see if the pathnames have been searched for plug-ins. If not then do it now. This should be called by any UI code before they try and put up any UI of plug-ins, e.g. a menu of available plug-ins. If the user requested not to parse pathnames at start up then this is where it happens.
BOOL	SearchedPathsYet ()
BOOL	ReadPathNameList ()
	Reads the plug-in pathnames list in from the ini file. This has to be a new ini file as the main ini file code cannot cope with the concept of sections filled with an arbitrary number of items which need cleaning out when resaving to remove old items no longer required. The code is based on LibSettings::BuildList.
BOOL	WritePathNameList ()
	Writes the list of plug-in pathnames to the ini file This has to be a new ini file as the main ini file code cannot cope with the concept of sections filled with an arbitrary number of items which need cleaning out when resaving to remove old items no longer required.
BOOL	DestroyPlugInsList ()
	Destroy the list of plugs that the plug-in manager in Camelot currently has.
BOOL	ParseAllPaths ()
	Starts up the process of parsing all the paths specified to the plug-in manager for plug-ins and storing information on them in a list. Assumes the list is either empty before we are called or the caller has cleared it using.
MenuItem *	FindPlugInMainMenuItem (MenuItem *pMainMenu=NULL)
	Finds the main plug-in menu item and returns a pointer to it.
Static Public Member Functions
static BOOL	WipePlugInsSettings ()
	Wipes the plug-in pathnames list from the ini file or from the registry.
Protected Member Functions
BOOL	ParsePathName (const PathName &SearchPath, const INT32 PathID, INT32 *FilesCount, const Progress &PathsProgress)
	Parse the given path for all files and pass the files of the registered types to the appropriate plug-in handler. The handler should then check to see whether it likes this type of file and if so then create a new plug-in record of the correct type and then place useful details into the record. Finally it should register the new plug-in record with the plug-in manager i.e. this class. The PathID should be stored in the plug-in record so that we do not have to store the full path with all plug-in records.
BOOL	ParsePathNameForDirectories (const PathName &SearchPath, INT32 *FilesCount)
	Parse the given path for all directories. If found then add them as hidden items to our list of paths so that the user cannot see them. We do it this way so that we only ever store a PathID with a plug-in record rather than having to store the pathname or sub-directories to the pathname with the plug-in. Note: Must be re-entrant!
Private Member Functions
	CC_DECLARE_DYNAMIC (PlugInManager)
BOOL	SortPlugInsAlphabetically ()
	Sorts the list of plugs-in alphabetically Borrowed code from SuperGallery::ApplySortNow as we need a much simpler version.
BOOL	DeleteMainMenuItems ()
	Before the pathnames are parsed, we must clear out the main menu items of all the current plug-ins.
BOOL	CreateMainMenuItems ()
	After the plug in list has been sorted alphabetically we must add each item in the list to the main plug-in menu.
Static Private Member Functions
static INT32 __cdecl	SortComparator (const void *Item1, const void *Item2)
	'qsort' comparator function, used when quicksorting the loaded colour list
Private Attributes
PlugInPathList	m_Paths
List	m_HandlersList
List	m_PlugInsList
BOOL	m_Initialised
BOOL	m_SearchedPaths
Static Private Attributes
static BOOL	m_ParseAtStartUp = TRUE
	If TRUE, then the plug-in pathnames will be searched at start up for plug-ins. If FALSE, then the searching happens the first time any plug-in UI is invoked.

---

Detailed Description

Provide general handling facilities for plug-ins in Camelot.

Author:

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

Date:

9/12/96

Definition at line 189 of file plugmngr.h.

---

Constructor & Destructor Documentation

PlugInManager::PlugInManager (   )

Main constructor for the plug-in manager in Camelot. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 9/12/96 Definition at line 302 of file plugmngr.cpp. { // Flag that we have not been initialised yet m_Initialised = FALSE; // Default to parsing paths at start up m_ParseAtStartUp = TRUE; // Flag that we have not searched the plug-ins path yet m_SearchedPaths = FALSE; }

PlugInManager::~PlugInManager (   )

Main destructor for the plug-in manager in Camelot. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 9/12/96 Definition at line 322 of file plugmngr.cpp. { // Clean out our list of pathnames /* PlugInPath* pPath = (PlugInPath *)Paths.GetHead(); while (pPath != NULL) { delete pBitmap->pBmp; // Try the next pathname in the list pPath = (PlugInPath *)Paths.GetNext(pPath); } */ //Paths.DeleteAll(); // Clean out the list of plug-in handlers that Camelot understands. m_HandlersList.DeleteAll(); // Clean out the list of plug-in items DestroyPlugInsList(); }

---

Member Function Documentation

BOOL PlugInManager::AddPlugIn (  PlugInItem *  pPlugIn  )

Add a plug-in to the list in the plug-in manager and register the op desciptor to the system. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 11/12/96 Returns: True if worked, False otherwise Definition at line 1107 of file plugmngr.cpp. { m_PlugInsList.AddTail(pPlugIn); return TRUE; }

BOOL PlugInManager::AddPlugInPath (  const PathName &  NewSearchPath  )

Adds a new pathname to the list of pathnames stored in the plug-in manager. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 12/12/96 Parameters: NewSearchPath  the pathname to add to the list [INPUTS] Returns: True if added ok, False otherwise. Definition at line 1027 of file plugmngr.cpp. { // First check to see if its blank or not. If so then ignore it String_256 SearchDir = NewSearchPath.GetPath(); if (SearchDir.IsEmpty()) { ERROR3("AddPlugInPath asked to add blank path!"); return FALSE; } m_Paths.AddPathName(NewSearchPath); return TRUE; }

PlugInManager::CC_DECLARE_DYNAMIC (  PlugInManager   )  [private]

BOOL PlugInManager::CheckHaveDetailsOnPlugIns (   )

Checks to see if the pathnames have been searched for plug-ins. If not then do it now. This should be called by any UI code before they try and put up any UI of plug-ins, e.g. a menu of available plug-ins. If the user requested not to parse pathnames at start up then this is where it happens. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 17/12/96 Returns: True if parsed ok, False otherwise. Definition at line 727 of file plugmngr.cpp. { // If we have not already parsed the paths then go and do it now as we need it. if (!m_SearchedPaths) return ParseAllPaths(); // Otherwise we do the job later return TRUE; }

BOOL PlugInManager::CreateMainMenuItems (   )  [private]

After the plug in list has been sorted alphabetically we must add each item in the list to the main plug-in menu. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 17/1/97 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: True if the operation completed successfully False if it failed in some way. Definition at line 1474 of file plugmngr.cpp. { /* //#if NEW_NATIVE_FILTER // Search the main menu items until we find the plug-ins one MenuItem * pRootMenu = FindPlugInMainMenuItem(); if (pRootMenu == NULL) return FALSE; // // Create the plug-ins manager menu item... // MenuItem * pPlugDlgMngr = CreateMenuItem(OPTOKEN_PLUGSDLG, pRootMenu->GetMenuId(), TRUE); // // If created ok then add this to the main plug-in's menu // if (pPlugDlgMngr) // pRootMenu->AddMenuItem(pPlugDlgMngr); // // Create a menu item for the apply last item MenuItem * pApplyLastItem = CreateMenuItem(OPTOKEN_PHOTOSHOP_APPLYLAST, pRootMenu->GetMenuId(), FALSE); // If created ok then add this to the main plug-in's menu if (pApplyLastItem) pRootMenu->AddMenuItem(pApplyLastItem); // // Go through all the handlers asking them to add in sections to the main menu PlugInHandler* pHandler = (PlugInHandler *)m_HandlersList.GetHead(); PlugInHandler* pNextHandler = NULL; BOOL AddedOk = TRUE; BOOL AddSeparator = TRUE; while (pHandler != NULL) { // Try the next handler in the list pNextHandler = (PlugInHandler *)m_HandlersList.GetNext(pHandler); // If there is a next handler then we must add a separator to the // end of the list. // This does assume that only one handler will not want to add items to the end. // but this is good enough for now if (pNextHandler && pNextHandler->GoingToAddMainMenuItems()) AddSeparator = TRUE; else AddSeparator = FALSE; // Ask the handler to add its required section of the menu to the list AddedOk = pHandler->CreateMainMenuItems(this, pRootMenu, AddSeparator); // Try the next handler in the list pHandler = pNextHandler; } // Make sure that the plug-ins win menu is updated to mirror the kernel // menu structure that we have just created BOOL update = UpdatePlugInsWinMenu(pRootMenu); */ //#endif return TRUE; }

BOOL PlugInManager::DeleteMainMenuItems (   )  [private]

Before the pathnames are parsed, we must clear out the main menu items of all the current plug-ins. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 20/1/97 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: True if the operation completed successfully False if it failed in some way. Definition at line 1431 of file plugmngr.cpp. { //#if NEW_NATIVE_FILTER // Search the main menu items until we find the plug-ins one MenuItem * pRootMenu = FindPlugInMainMenuItem(); if (pRootMenu == NULL) return FALSE; // Completely destroy this menu BOOL ok = DestroyCamMenu(pRootMenu); // We must add back an item so that the menu is not empty otherwise // all hell will break loose if its left in this state!!!! // Create a menu item for the apply last item // MenuItem * pApplyLastItem = CreateMenuItem(OPTOKEN_PLUGINS_PARSING, pRootMenu->GetMenuId(), FALSE); // If created ok then add this to the main plug-in's menu // if (pApplyLastItem) // pRootMenu->AddMenuItem(pApplyLastItem); // Just in case anything goes wrong between here and adding the new plug-ins back in // we must make sure that the plug-ins win menu is updated to mirror the kernel // menu structure that we have just blatted BOOL update = UpdatePlugInsWinMenu(pRootMenu); //#endif return TRUE; }

BOOL PlugInManager::DeletePlugInPath (  const PathName &  SearchPath  )

Deletes a pathname from the list of pathnames stored in the plug-in manager. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 12/12/96 Parameters: SearchPath  the pathname to delete from the list [INPUTS] Returns: True if added ok, False otherwise. Definition at line 1053 of file plugmngr.cpp. { return m_Paths.DeletePathName(SearchPath); }

BOOL PlugInManager::DestroyPlugInsList (   )

Destroy the list of plugs that the plug-in manager in Camelot currently has. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 12/12/96 Returns: True if worked ok, False otherwise. Definition at line 355 of file plugmngr.cpp. { // We need to write the code to destruct an OpDescriptor and delink it from the // list before we can do this. // We must go through the list of plug-ins and deregister things like the // allocated op-descriptors that we allocated when the plug-in was created. PlugInItem* pPlugIn = (PlugInItem *)m_PlugInsList.GetHead(); String_32 OpToken; String_32 FamilyOpToken; String_32 LastFamilyOpToken; while (pPlugIn != NULL) { OpToken = pPlugIn->GetUniqueID(); FamilyOpToken = OpToken; OpToken += pPlugIn->GetPlugInName(); FamilyOpToken += pPlugIn->GetFamilyName(); // Search for the OpDescriptor OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OpToken); if (pOpDesc != NULL) { OpDescriptor::DelinkDescriptor(pOpDesc); delete pOpDesc; } // If the family optoken changes then this is the time to delete it if (FamilyOpToken != LastFamilyOpToken) { // Search for the OpDescriptor pOpDesc = OpDescriptor::FindOpDescriptor(FamilyOpToken); if (pOpDesc != NULL) { OpDescriptor::DelinkDescriptor(pOpDesc); delete pOpDesc; } } LastFamilyOpToken = FamilyOpToken; // Try the next plug-in in the list pPlugIn = (PlugInItem *)m_PlugInsList.GetNext(pPlugIn); } // Clean out the list of plug-in items m_PlugInsList.DeleteAll(); // Lastly, flag that we have now not parsed all the paths m_SearchedPaths = FALSE; return TRUE; }

MenuItem * PlugInManager::FindPlugInMainMenuItem (  MenuItem *  pMainMenu = NULL  )

Finds the main plug-in menu item and returns a pointer to it. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> & Re-writen by sjk 2/8/00 so it doesn't have to be a top level menu! Date: 20/1/97 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: Pointer to the plug-in main menu item if the operation completed successfully NULL if it failed in some way. Definition at line 1379 of file plugmngr.cpp. { if (pMainMenu == NULL) pMainMenu = GetMainMDIMenu(); MenuItem * pMenu = pMainMenu->GetFirstMenuItem(); String_256 PlugInMenu(OPTOKEN_PLUGINS_UNDO_MENU); String_32 Desc; while (pMenu) { MenuItem * pSub = pMenu->GetFirstMenuItem(); if (pSub) { // check sub menu pSub = FindPlugInMainMenuItem(pMenu); } // Get the OpToken for the current menu item or returned menu item String_32 * pDesc = pSub ? pSub->GetOpToken() : pMenu->GetOpToken(); if (pDesc) Desc = *pDesc; else Desc.Empty(); // If the OpTokens match then it is the one that we desire if (Desc == PlugInMenu) return pSub ? pSub : pMenu; // Go to the next main menu item in the list pMenu = pMainMenu->GetNextMenuItem(pMenu); } return NULL; }

PlugInPath * PlugInManager::GetFirstPathName (   )

Get the first plug-in pathname in the list stored in the plug-in manager. This is just the list of user defined paths and does not include the hidden paths that are stored in the list as well. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 12/12/96 Returns: Pointer to a plug-in pathname in the list. Definition at line 1071 of file plugmngr.cpp. { return (PlugInPath *)m_Paths.GetFirstPath(); }

PlugInItem * PlugInManager::GetFirstPlugIn (   )

Get the first plug-in item in the list stored in the plug-in manager. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 11/12/96 Returns: Pointer to a plug-in item in the list. Definition at line 1147 of file plugmngr.cpp. { return (PlugInItem *)m_PlugInsList.GetHead(); }

PlugInPath * PlugInManager::GetNextPathName (  PlugInPath *  pPath  )

Get the next plug-in pathname in the list stored in the plug-in manager. This is just the list of user defined paths and does not include the hidden paths that are stored in the list as well. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 12/12/96 Parameters: pPlugIn  pointer to the current plug-in in the list [INPUTS] Returns: Pointer to a plug-in pathname in the list. Definition at line 1090 of file plugmngr.cpp. { return (PlugInPath *)m_Paths.GetNextPath(pPath); }

PlugInItem * PlugInManager::GetNextPlugIn (  PlugInItem *  pPlugIn  )

Get the next plug-in item in the list stored in the plug-in manager. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 11/12/96 Parameters: pPlugIn  pointer to the current plug-in in the list [INPUTS] Returns: Pointer to a plug-in item in the list. Definition at line 1164 of file plugmngr.cpp. { return (PlugInItem *)m_PlugInsList.GetNext(pPlugIn); }

BOOL PlugInManager::GetParseAtStartUp (   )  [inline]

Definition at line 201 of file plugmngr.h. { return m_ParseAtStartUp; }

BOOL PlugInManager::GetPlugInPath (  PathName *  NewSearchPath  )

Allows the requesting of a pathname to parse plug-ins for from the user. Its pops up a modified form of the stanadard file dialog box set up to browse explicitly for paths rather than files. Used by the plug-ins options tab. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 11/12/96 Parameters: -  [INPUTS] NewSearchPath  the pathname to parse for new plug-ins [OUTPUTS] Returns: True if parsed ok, False otherwise. Definition at line 1007 of file plugmngr.cpp. { // Ask out special class to pop up a common file dialog box to the user and then // to return the path that the user has requested back to us. BOOL ok = PlugInsBrowser::GetLibPath(NewSearchPath); return ok; }

BOOL PlugInManager::GetPlugInPathname (  INT32  PathNameID, String_256 *  pPathName )

Converts a pathanme id which is stored with each plug-in into the real pathname that it corresponds to by searching the pathname list in the plug-in manager. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 11/12/96 Parameters: PathNameID  id of the pathname to search for [INPUTS] pPathName pointer to a string to fill in with the pathname pPlugIn pointer to the current plug-in in the list Returns: True if worked ok, False otherwise. Definition at line 1202 of file plugmngr.cpp. { ERROR2IF(pPathName == NULL,FALSE,"PlugInManager::GetPlugInPathname null pPath"); // Make the string empty pPathName->Empty(); // Go through all our stored paths and check them for plug-ins stored in them. PlugInPath* pPath = (PlugInPath *)m_Paths.GetHead(); while (pPath != NULL) { if (pPath->GetPathNameID() == PathNameID) { *pPathName = pPath->GetPathNameAsString(); return TRUE; } // Try the next pathname in the list pPath = (PlugInPath *)m_Paths.GetNext(pPath); } // Nothing found so return this to the user return FALSE; }

PlugInItem * PlugInManager::GetPreviousPlugIn (  PlugInItem *  pPlugIn  )

Get the previous plug-in item in the list stored in the plug-in manager. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 11/12/96 Parameters: pPlugIn  pointer to the current plug-in in the list [INPUTS] Returns: Pointer to a previous plug-in item in the list. Definition at line 1181 of file plugmngr.cpp. { return (PlugInItem *)m_PlugInsList.GetPrev(pPlugIn); }

BOOL PlugInManager::Init (  void   )

Main initialisation code for the plug-in manager in Camelot. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 9/12/96 Returns: True if initialised ok, False otherwise. Reimplemented from SimpleCCObject. Definition at line 437 of file plugmngr.cpp. { #ifndef WEBSTER #ifndef EXCLUDE_BFX //#ifdef NEW_NATIVE_FILTER ADD_HANDLER(BfxHandler); //#endif #endif #endif // Only include the freehand plug-ins if required #ifdef PHOTOSHOPPLUGINS ADD_HANDLER(PhotoShopHandler); #endif // Only include the freehand plug-ins if required #ifdef FREEHANDPLUGINS ADD_HANDLER(XtraHandler); #endif if (!PlugInOp::Init()) return FALSE; // Declare any preferences that we require. if ( Camelot.DeclareSection(TEXT("Plug-ins"), 3) ) { // section declared ok so now define the preference option Camelot.DeclarePref(TEXT("Plug-ins"), TEXT("ParseAtStartUp"), &m_ParseAtStartUp, 0, 1); } // load stored items from preference system BOOL ok = ReadPathNameList(); ok = ok && PlugInOp::RegisterOpToken(OPTOKEN_PLUGINS_MENU, _R(IDS_PLUGINS)); ok = ok && PlugInOp::RegisterOpToken(OPTOKEN_PLUGINS_MANAGER, _R(IDS_PLUGINS)); ok = ok && PlugInOp::RegisterOpToken(OPTOKEN_PLUGINS_PARSING, _R(IDS_PLUGSIN_PARSING)); ok = ok && PlugInOp::RegisterOpToken(OPTOKEN_PLUGINS_PLUGINSMNGR, _R(IDS_PLUGINS_PLUGINSMNGR)); ok = ok && PlugInUndoOp::RegisterOpToken(OPTOKEN_PLUGINS_UNDO_MENU, _R(IDS_PLUGINS)); // Lastly, note that initialised has been called m_Initialised = TRUE; return TRUE; }

BOOL PlugInManager::ParseAllPaths (   )

Starts up the process of parsing all the paths specified to the plug-in manager for plug-ins and storing information on them in a list. Assumes the list is either empty before we are called or the caller has cleared it using. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 9/12/96 Returns: True if parsed ok, False otherwise. Definition at line 751 of file plugmngr.cpp. { // First, flag that we have parsed all the paths m_SearchedPaths = TRUE; BOOL ParsedOk = TRUE; //#if NEW_NATIVE_FILTER // Now, go and make sure that we have no plug-ins main menu items DeleteMainMenuItems(); //#endif // Start adding the plug-ins into the list // First any ones which are fixed or built in and not file related // Go through each of the handlers asking them to add fixed plug-ins. PlugInHandler* pHandler = (PlugInHandler *)m_HandlersList.GetHead(); while (pHandler != NULL) { pHandler->AddFixedPlugIns(); // Try the next handler in the list pHandler = (PlugInHandler *)m_HandlersList.GetNext(pHandler); } // Now look through all the directories that the user has specified // First remove all hidden items from the list // Put up an hourglass to show we are doing something Progress InitialPathsProgress(_R(IDS_PLUGSIN_PARSING)); m_Paths.RemoveHiddenItems(); // Now go through all the pathnames looking for sub-directories recursively // and add these to the list of items // The items we use MUST only ever see non-hidden paths, as otherwise // we will get very recursive!!!!! PlugInPath* pPath = (PlugInPath *)m_Paths.GetFirstPath(); INT32 FilesCount = 0; while (pPath != NULL) { ParsedOk = ParsedOk && ParsePathNameForDirectories(pPath->GetPathName(), &FilesCount); pPath = (PlugInPath *)m_Paths.GetNextPath(pPath); } // Put up a progress bar to show we are doing something Progress PathsProgress(_R(IDS_PLUGSIN_PARSING), FilesCount); // Go through all our stored paths and check them for plug-ins stored in them. pPath = (PlugInPath *)m_Paths.GetHead(); INT32 Count = 0; PathsProgress.Update(Count); while (pPath != NULL) { ParsedOk = ParsedOk && ParsePathName(pPath->GetPathName(), pPath->GetPathNameID(), &Count, PathsProgress); // Try the next pathname in the list pPath = (PlugInPath *)m_Paths.GetNext(pPath); PathsProgress.Update(Count); } // Sort those plug-ins that we have loaded SortPlugInsAlphabetically(); //#if NEW_NATIVE_FILTER // Now, go and create the plug-ins main menu items required CreateMainMenuItems(); //#endif return ParsedOk; }

BOOL PlugInManager::ParsePathName (  const PathName &  SearchPath, const INT32  PathID, INT32 *  pFilesCount, const Progress &  PathsProgress )  [protected]

Parse the given path for all files and pass the files of the registered types to the appropriate plug-in handler. The handler should then check to see whether it likes this type of file and if so then create a new plug-in record of the correct type and then place useful details into the record. Finally it should register the new plug-in record with the plug-in manager i.e. this class. The PathID should be stored in the plug-in record so that we do not have to store the full path with all plug-in records. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 9/12/96 Parameters: ParsePath  the pathname to parse for new plug-ins [INPUTS] pathID the ID assigned to this path PathsProgress the progress object to call for progress update pFilesCount  an updated count of the files discovered [OUTPUTS] Returns: True if parsed ok, False otherwise. Definition at line 916 of file plugmngr.cpp. { PathName File = SearchPath; String_256 SearchDir = SearchPath.GetPath(); // If the path is blank then ignore it otherwise we will search the entire hard drive // or currently selected directory! if (SearchDir.IsEmpty()) return TRUE; // We must set up the operating system current directory so that extra DLLs beside the // plug-ins can be picked up. BOOL ok = FileUtil::SetCurrentDirectory( SearchPath ); SearchDir += "*.*"; TRACEUSER( "Neville", _T("ParsePathName Search path is %s, found:-\n"), (TCHAR *)SearchDir); FindFiles Finder; BOOL IsDirectory = FALSE; if (Finder.StartFindingFiles(&SearchDir)) { String_256 LeafName; while (TRUE) { if (!Finder.FindNextFile(&LeafName, &IsDirectory)) break; if (pFilesCount) (*pFilesCount)++; // Do something with file "LeafName" TRACEUSER( "Neville", _T("ParsePathName parse plug-in file %s\n"), (TCHAR *)LeafName); // We have found a file or a directory. // In this case we only want to look for files if (!IsDirectory) { File.SetFileNameAndType(LeafName); String_32 FileType = File.GetType(); FileType.toLower(); PlugInHandler* pHandler = (PlugInHandler *)m_HandlersList.GetHead(); BOOL Found = FALSE; while (pHandler != NULL && !Found) { String_32 HandlerFileType = pHandler->GetFileTypes(); // If the handler returns a filetype which is null then ignore it // as this generally indicates that it will do its own thing. // Handlers can specify a list of file types by splitting them with commas if (!HandlerFileType.IsEmpty() && (HandlerFileType.Sub(FileType) != -1)) //FileType == HandlerFileType) Found = TRUE; else { // Try the next handler in the list pHandler = (PlugInHandler *)m_HandlersList.GetNext(pHandler); } } // If we have found this filetype in our list of handlers then // ask that handler to parse the file. if (Found && pHandler) { pHandler->ParsePlugIn(File, PathID); } // Update our progress bar for the file just parsed if (pFilesCount) PathsProgress.Update(*pFilesCount); } } // Stop the process Finder.StopFindingFiles(); } return TRUE; }

BOOL PlugInManager::ParsePathNameForDirectories (  const PathName &  SearchPath, INT32 *  pFilesCount )  [protected]

Parse the given path for all directories. If found then add them as hidden items to our list of paths so that the user cannot see them. We do it this way so that we only ever store a PathID with a plug-in record rather than having to store the pathname or sub-directories to the pathname with the plug-in. Note: Must be re-entrant! Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 9/12/96 Parameters: ParsePath  the pathname to parse for new plug-ins [INPUTS] pFilesCount  an updated count of the files discovered [OUTPUTS] Returns: True if parsed ok, False otherwise. Definition at line 840 of file plugmngr.cpp. { PathName File = SearchPath; String_256 SearchDir = SearchPath.GetPath(); // If the path is blank then ignore it otherwise we will search the entire hard drive // or currently selected directory! if (SearchDir.IsEmpty()) return TRUE; SearchDir += "*.*"; TRACEUSER( "Neville", _T("ParsePathNameForDirectories Search path is %s\n"), (TCHAR *)SearchDir); FindFiles Finder; BOOL IsDirectory = FALSE; if (Finder.StartFindingFiles(&SearchDir)) { String_256 LeafName; while (TRUE) { if (!Finder.FindNextFile(&LeafName, &IsDirectory)) break; if (pFilesCount) (*pFilesCount)++; // We have found a file or a directory. // In this case we only want to look for directories if (IsDirectory) { // Do something with the directory "LeafName" TRACEUSER( "Neville", _T("ParsePathNameForDirectories add directory %s\n"), (TCHAR *)LeafName); String_256 NewSearchDir = SearchPath.GetPath(); NewSearchDir += LeafName; // Add a trailing slash if it hasn't got one, which it shouldn't have SGLibOil::AppendSlashIfNotPresent(&NewSearchDir); PathName NewSearchPath(NewSearchDir); // Add the new pathname to the list, but as a hidden one so that // people not in the know do not see them. PlugInPath * pPath = m_Paths.AddPathName(NewSearchPath, TRUE); if (pPath) { // recover the id associated with the path ParsePathNameForDirectories(NewSearchPath, pFilesCount); } } } // Stop the process Finder.StopFindingFiles(); } return TRUE; }

BOOL PlugInManager::ReadPathNameList (   )

Reads the plug-in pathnames list in from the ini file. This has to be a new ini file as the main ini file code cannot cope with the concept of sections filled with an arbitrary number of items which need cleaning out when resaving to remove old items no longer required. The code is based on LibSettings::BuildList. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 17/12/96 See also: CFileList::ReadList(); LibSettings::BuildList; Definition at line 531 of file plugmngr.cpp. { #ifdef SAVE_PREFS_TO_REGISTRY // Check if the registry entry is present or not. Look for the our special plugin related // items which should be stored in a 'PlugIns\\Plug-in Pathname List' key. // This is the section and sub-section name that we are going to use String_256 KeySectionName(PRODUCT_REGISTRYKEY_PLUGINS TEXT("\\Plug-in Pathname List")); BOOL EntryPresent = CheckForRegistryEntry(KeySectionName); if (EntryPresent) { LoadRegistryEntries Loader; Loader.StartLoading(&KeySectionName); BOOL AddedItems = FALSE; String_256 FileName; while (Loader.LoadNextEntry(&FileName)) { // only interested in items which contain some data! // If blank then we may parse the entire disc or currently selected directory! if (!FileName.IsEmpty()) { // Add a trailing slash if it hasn't got one SGLibOil::AppendSlashIfNotPresent(&FileName); PathName Path(FileName); m_Paths.AddPathName(Path); // Flag that we have added something AddedItems = TRUE; } } Loader.StopLoading(); } else #endif { // Read in the data from the older ini file that may be kicking around // This is the section name that we are going to use String_256 SectionName(TEXT("Plug-in Pathname List")); // This is the ini file that we are going to be using String_256 PlugInsIni(PRODUCT_PLUGINS_INIFILE); BOOL AddedItems = FALSE; String_256 FileName; CCDiskFile GetEntryFile(1024, FALSE, TRUE); if (LibSettings::GetEntryStart(&GetEntryFile, &PlugInsIni)) { if (LibSettings::SeekToSection(&GetEntryFile, &SectionName)) { while (LibSettings::GetNextLine(&GetEntryFile, &FileName)) { // Add a trailing slash if it hasn't got one SGLibOil::AppendSlashIfNotPresent(&FileName); PathName Path(FileName); m_Paths.AddPathName(Path); // Flag that we have added something AddedItems = TRUE; } } LibSettings::GetEntryFinish(&GetEntryFile); } } // Everything is ok return TRUE; }

BOOL PlugInManager::RemovePlugIn (  PlugInItem *  pPlugIn  )

Removes a plug-in from the list in the plug-in manager (if it's there). Author: Richard_Millican (Xara Group Ltd) <camelotdev@xara.com> Date: 15/1/97 Parameters: pPlugIn  - Pointer to plugin item [INPUTS] Returns: True if worked, False otherwise Definition at line 1126 of file plugmngr.cpp. { if(m_PlugInsList.RemoveItem(pPlugIn) == NULL) return FALSE; return TRUE; }

BOOL PlugInManager::SearchedPathsYet (   )  [inline]

Definition at line 235 of file plugmngr.h. { return m_SearchedPaths; }

BOOL PlugInManager::SearchForPlugIns (   )

Starts up the process of parsing all the paths specified to the plug-in manager for plug-ins and stroing information on them in a list. This is called during start up so needs to check the flag to see whether the user has requested this to be done at the start, before actually trying to parse. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 17/12/96 Returns: True if parsed ok, False otherwise. Definition at line 701 of file plugmngr.cpp. { // If the user has requested plug-in parsing at start up then now is the time to do it // Otherwise, delay until the first call if (m_ParseAtStartUp) return ParseAllPaths(); // Otherwise we do the job later return TRUE; }

void PlugInManager::SetParseAtStartUp (  BOOL  NewState  )  [inline]

Definition at line 202 of file plugmngr.h. { m_ParseAtStartUp = NewState; }

INT32 __cdecl PlugInManager::SortComparator (  const void *  Item1, const void *  Item2 )  [static, private]

'qsort' comparator function, used when quicksorting the loaded colour list Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/96 Parameters: Item1,Item2  - the items to be compared [INPUTS] Returns: negative (I am lesser), 0 (we are equal), or positive (I am greater) result of comparing the items with the EntryNumber stored in each item in the loaded colour list. See also: PlugInManager::SortPlugInsAlphabetically(); ImportedColours::SortColoursByEntryNumber(); SuperGallery::SortComparator; SuperGallery::ApplySortNow; Definition at line 1332 of file plugmngr.cpp. { // if (Item1 == NULL || Item2 == NULL) // return 0; PlugInItem *pItem1 = *((PlugInItem **)Item1); PlugInItem *pItem2 = *((PlugInItem **)Item2); if (pItem1 == NULL || pItem2 == NULL) { ERROR3("PlugIn::SortComparator bad pointers!"); return 0; } INT32 Result = 0; // Sort on family name as the highest priority if (pItem1->GetFamilyName() < pItem2->GetFamilyName()) return(-1); if ((pItem1->GetFamilyName() == pItem2->GetFamilyName()) && (pItem1->GetPlugInName() < pItem2->GetPlugInName()) ) return(-1); if ((pItem1->GetFamilyName() == pItem2->GetFamilyName()) && (pItem1->GetPlugInName() == pItem2->GetPlugInName()) ) return 0; // Must be greater than return 1; }

BOOL PlugInManager::SortPlugInsAlphabetically (   )  [private]

Sorts the list of plugs-in alphabetically Borrowed code from SuperGallery::ApplySortNow as we need a much simpler version. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 16/12/96 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: True if the operation completed successfully False if it failed in some way. Errors: - See also: ImportedColours::SortColoursByEntryNumber(); SuperGallery::ApplySortNow Definition at line 1244 of file plugmngr.cpp. { INT32 NumItems = 0; // Count the number of items we have to sort PlugInItem * pPlugIn = GetFirstPlugIn(); while (pPlugIn != NULL) { NumItems ++; pPlugIn = GetNextPlugIn(pPlugIn); } // Start progress indicators, with a percentage based upon the number of items. // We will update twice for each group (after qsort and shuffle-items stages) Progress SortProgress(_R(IDS_PLUGSIN_SORTING), NumItems * 2, FALSE); INT32 NumItemsToSort = 0; if (NumItems > 1) { // Get memory for an array of pointers to these items PlugInItem **SortArray = (PlugInItem **)CCMalloc(NumItems * sizeof(PlugInItem *)); if (SortArray == NULL) return FALSE; // Fill in the array with pointers to display items to sort INT32 i = 0; PlugInItem * pPlugIn = GetFirstPlugIn(); while (pPlugIn != NULL) { SortArray[i++] = pPlugIn; pPlugIn = GetNextPlugIn(pPlugIn); } // Sort the array of pointers qsort(SortArray, NumItems, sizeof(PlugInItem *), PlugInManager::SortComparator); NumItemsToSort += NumItems; // Update percentage complete for the number of items processed SortProgress.Update(NumItemsToSort); // Now, take the sorted array, and rearrange the items to be in that order // Special case the first item PlugInItem *pPrevPlugIn = GetPreviousPlugIn(SortArray[0]); if (pPrevPlugIn != NULL) { m_PlugInsList.RemoveItem(SortArray[0]); m_PlugInsList.InsertBefore(SortArray[1], SortArray[0]); } // Then whip through the rest of the items for (i = 1; i < NumItems; i++) { pPrevPlugIn = GetPreviousPlugIn(SortArray[i]); if (pPrevPlugIn != SortArray[i-1]) { m_PlugInsList.RemoveItem(SortArray[i]); m_PlugInsList.InsertAfter(SortArray[i-1], SortArray[i]); } } // Free our temporary workspace CCFree(SortArray); } // End the progress bar that we started //EndSlowJob(); // We seem to have sorted the items ok return TRUE; }

BOOL PlugInManager::WipePlugInsSettings (   )  [static]

Wipes the plug-in pathnames list from the ini file or from the registry. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 28/2/97 See also: LibSettings::NukeSettings; Definition at line 494 of file plugmngr.cpp. { #ifdef SAVE_PREFS_TO_REGISTRY // Check if the registry entry is present or not. Look for the our special plugin related // items which should be stored in a 'PlugIns\\Plug-in Pathname List' key. // This is the section and sub-section name that we are going to use String_256 KeySectionName(PRODUCT_REGISTRYKEY_PLUGINS TEXT("\\Plug-in Pathname List")); DeleteRegKey(hAppStateRegKey, KeySectionName); // We must wipe the ini file as well as otherwise when the code checks to // see if the registry settings and then falls back on the ini file if they // are not there, then we wont be using the default settings. #endif // Vape the plug-ins ini file String_256 PlugInsIni(PRODUCT_PLUGINS_INIFILE); LibSettings::NukeSettings(&PlugInsIni); return TRUE; }

BOOL PlugInManager::WritePathNameList (   )

Writes the list of plug-in pathnames to the ini file This has to be a new ini file as the main ini file code cannot cope with the concept of sections filled with an arbitrary number of items which need cleaning out when resaving to remove old items no longer required. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 17/12/96 See also: CFileList::WriteList() Definition at line 613 of file plugmngr.cpp. { #ifdef SAVE_PREFS_TO_REGISTRY BOOL ok = TRUE; // This is the section and sub-section name that we are going to use String_256 SectionName(PRODUCT_REGISTRYKEY_PLUGINS TEXT("\\Plug-in Pathname List")); SaveRegistryEntries Saver; ok = Saver.StartSaving(&SectionName); ERROR3IF(!ok,"PlugInManager::WritePathNameList() couldn't start saving the settings"); // Go through all our stored paths writing them out in the preferences. // DO NOT USE GetHead/GetNext as we would see all the paths, which is more than we should // be seeing. Use the offical GetFirstPath/GetNextPath routines which give us what we // should be seeing, i.e. the user entered paths. PlugInPath* pPath = (PlugInPath *)m_Paths.GetFirstPath(); PathName FileName; String_256 Line; while (pPath != NULL && ok) { // Get the pathname for this entry FileName = pPath->GetPathName(); // Get the string that represents this Line = FileName.GetPath(); // only write out the line if non-blank // If blank then we may parse the entire disc or currently selected directory! if (!Line.IsEmpty()) ok = ok && Saver.SaveNextEntry(&Line); // if !ok then possibly write access denied on in file... or disk full... // So flag that we should stop outputting any more data // Try the next pathname in the list pPath = (PlugInPath *)m_Paths.GetNextPath(pPath); } Saver.StopSaving(); #else // This is the section name that we are going to use String_256 SectionName(TEXT("Plug-in Pathname List")); // This is the ini file that we are going to be using String_256 PlugInsIni(PRODUCT_PLUGINS_INIFILE); LibSettings::StartOutput(&SectionName, &PlugInsIni); LibSettings::AddSection(&SectionName, &PlugInsIni); // Go through all our stored paths writing them out in the preferences. // DO NOT USE GetHead/GetNext as we would see all the paths, which is more than we should // be seeing. Use the offical GetFirstPath/GetNextPath routines which give us what we // should be seeing, i.e. the user entered paths. PlugInPath* pPath = (PlugInPath *)m_Paths.GetFirstPath(); PathName FileName; String_256 Line; BOOL ok = TRUE; while (pPath != NULL && ok) { // Get the pathname for this entry FileName = pPath->GetPathName(); // Get the string that represents this Line = FileName.GetPath(); if (!LibSettings::AddLine(&Line, &PlugInsIni)) { // Possibly write access denied on in file... or disk full... // So flag that we should stop outputting any more data ok = FALSE; } // Try the next pathname in the list pPath = (PlugInPath *)m_Paths.GetNextPath(pPath); } #endif return TRUE; }

---

Member Data Documentation

List PlugInManager::m_HandlersList [private]

Definition at line 274 of file plugmngr.h.

BOOL PlugInManager::m_Initialised [private]

Definition at line 280 of file plugmngr.h.

BOOL PlugInManager::m_ParseAtStartUp = TRUE [static, private]

If TRUE, then the plug-in pathnames will be searched at start up for plug-ins. If FALSE, then the searching happens the first time any plug-in UI is invoked. Preference: ParseAtStartUp Section: Plug-ins Range: TRUE or FALSE See also: - Definition at line 284 of file plugmngr.h.

PlugInPathList PlugInManager::m_Paths [private]

Definition at line 271 of file plugmngr.h.

List PlugInManager::m_PlugInsList [private]

Definition at line 277 of file plugmngr.h.

BOOL PlugInManager::m_SearchedPaths [private]

Definition at line 282 of file plugmngr.h.

---

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

• Kernel/plugmngr.h (r1785/r1282)
• Kernel/plugmngr.cpp (r1785/r1282)

---