app.h

Go to the documentation of this file.
00001 // $Id: app.h 1461 2006-07-18 09:50:40Z luke $
00002 /* @@tag:xara-cn@@ DO NOT MODIFY THIS LINE
00003 ================================XARAHEADERSTART===========================
00004  
00005                Xara LX, a vector drawing and manipulation program.
00006                     Copyright (C) 1993-2006 Xara Group Ltd.
00007        Copyright on certain contributions may be held in joint with their
00008               respective authors. See AUTHORS file for details.
00009 
00010 LICENSE TO USE AND MODIFY SOFTWARE
00011 ----------------------------------
00012 
00013 This file is part of Xara LX.
00014 
00015 Xara LX is free software; you can redistribute it and/or modify it
00016 under the terms of the GNU General Public License version 2 as published
00017 by the Free Software Foundation.
00018 
00019 Xara LX and its component source files are distributed in the hope
00020 that it will be useful, but WITHOUT ANY WARRANTY; without even the
00021 implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
00022 See the GNU General Public License for more details.
00023 
00024 You should have received a copy of the GNU General Public License along
00025 with Xara LX (see the file GPL in the root directory of the
00026 distribution); if not, write to the Free Software Foundation, Inc., 51
00027 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
00028 
00029 
00030 ADDITIONAL RIGHTS
00031 -----------------
00032 
00033 Conditional upon your continuing compliance with the GNU General Public
00034 License described above, Xara Group Ltd grants to you certain additional
00035 rights. 
00036 
00037 The additional rights are to use, modify, and distribute the software
00038 together with the wxWidgets library, the wxXtra library, and the "CDraw"
00039 library and any other such library that any version of Xara LX relased
00040 by Xara Group Ltd requires in order to compile and execute, including
00041 the static linking of that library to XaraLX. In the case of the
00042 "CDraw" library, you may satisfy obligation under the GNU General Public
00043 License to provide source code by providing a binary copy of the library
00044 concerned and a copy of the license accompanying it.
00045 
00046 Nothing in this section restricts any of the rights you have under
00047 the GNU General Public License.
00048 
00049 
00050 SCOPE OF LICENSE
00051 ----------------
00052 
00053 This license applies to this program (XaraLX) and its constituent source
00054 files only, and does not necessarily apply to other Xara products which may
00055 in part share the same code base, and are subject to their own licensing
00056 terms.
00057 
00058 This license does not apply to files in the wxXtra directory, which
00059 are built into a separate library, and are subject to the wxWindows
00060 license contained within that directory in the file "WXXTRA-LICENSE".
00061 
00062 This license does not apply to the binary libraries (if any) within
00063 the "libs" directory, which are subject to a separate license contained
00064 within that directory in the file "LIBS-LICENSE".
00065 
00066 
00067 ARRANGEMENTS FOR CONTRIBUTION OF MODIFICATIONS
00068 ----------------------------------------------
00069 
00070 Subject to the terms of the GNU Public License (see above), you are
00071 free to do whatever you like with your modifications. However, you may
00072 (at your option) wish contribute them to Xara's source tree. You can
00073 find details of how to do this at:
00074   http://www.xaraxtreme.org/developers/
00075 
00076 Prior to contributing your modifications, you will need to complete our
00077 contributor agreement. This can be found at:
00078   http://www.xaraxtreme.org/developers/contribute/
00079 
00080 Please note that Xara will not accept modifications which modify any of
00081 the text between the start and end of this header (marked
00082 XARAHEADERSTART and XARAHEADEREND).
00083 
00084 
00085 MARKS
00086 -----
00087 
00088 Xara, Xara LX, Xara X, Xara X/Xtreme, Xara Xtreme, the Xtreme and Xara
00089 designs are registered or unregistered trademarks, design-marks, and/or
00090 service marks of Xara Group Ltd. All rights in these marks are reserved.
00091 
00092 
00093       Xara Group Ltd, Gaddesden Place, Hemel Hempstead, HP2 6EX, UK.
00094                         http://www.xara.com/
00095 
00096 =================================XARAHEADEREND============================
00097  */
00098 
00099 #ifndef INC_APP
00100 #define INC_APP
00101 
00102 #include <limits.h>
00103 #include <float.h>
00104 
00105 #include "list.h"
00106 #include "rgnlist.h"
00107 #include "ccobject.h"
00108 #include "prefs.h"
00109 //#include "range.h"
00110 //#include "sentryop.h"
00111 #include "bmplist.h"
00112 #include "fraclist.h"
00113 //#include "bitmapcachekey.h"
00114 
00115 class CCPen;
00116 class RenderRegion;     // #include "rndrgn.h"
00117 class RenderRegionList;
00118 class BlobManager;      // #include "blobs.h"
00119 class DocComponentClass; // #include "doccomp.h"
00120 class KeyPress;
00121 class CCStatusBar;
00122 class StatusLine;
00123 class DragInformation;
00124 class ATMIniCache;
00125 class FontManager;
00126 class ColourManager;
00127 class XaraCMS;
00128 class PrintMarksMan;
00129 class PlugInManager;
00130 class FilterManager;
00131 class APIObject;
00132 class HandleManager;
00133 class NoiseMan;
00134 class ObjectCache;
00135 class SelRange;
00136 class ConcurrencyController;
00137 class WizOps;
00138 class CBitmapCache;
00139 class CTemplateManager;
00140 
00141 #define FONTMANAGER (GetApplication()->GetFontManager())
00142 #define NOISEMANAGER (GetApplication()->GetNoiseManager())
00143 
00144 /*********************************************************************************************
00145 
00146 >   class Application : public SimpleCCObject
00147 
00148     Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
00149     Created:    20/5/1993
00150     Base Class: None
00151     Purpose:    Represents an instance of the Camelot application.
00152     
00153                 \b General \b0
00154                 
00155                 There is only one Application object; it is a global, and it is called
00156                 Camelot.
00157                 
00158                 The data member 'Documents' is a list of 'Document' objects associated
00159                 with this instance of the application.  Any documents left in this list
00160                 are deleted by the Application's destructor.
00161                 
00162                 The data member 'RenderRegions' is a RenderRegionList object, and is the
00163                 list of RenderRegions outstanding for this instance of the application.
00164 
00165                 The data member 'Selection' is a SelRange object which caches information
00166                 about the current selection for quick access. NOTE: There is only one 
00167                 Selection object and it is used by all documents because the selection 
00168                 follows the input focus - when the user selects something in a document 
00169                 any existing selection in any other document is cleared.
00170                 So that the inline functions get fast access to the SelRange object the 
00171                 Application class is a friend of the SelRange class.
00172                 
00173                 \b User Preferences \b0
00174 
00175                 The Camelot object is responsible for controlling the application 
00176                 preferences.
00177                 
00178                 When a client wishes to use a preference, they should allocate some space to
00179                 hold its value, and then use DeclarePref to inform the preferences system
00180                 of its existence.
00181                 
00182                 e.g.
00183                 MonoOn
00184                     INT32 AutoSaveDelay;
00185                     Camelot.DeclarePref("Global", "AutoSaveDelay", &AutoSaveDelay);
00186                 MonoOff
00187                 
00188                 This will inform the preferences system that there is a preference called
00189                 \b AutoSaveDelay \b0 in the section called \b Global \b0 (the names of the 
00190                 sections and preferences are always case-insensitive).  The \b DeclarePref \b0
00191                 call will also attempt to read this preference from the application's 
00192                 preference file - if it exists, it will read the value and store it in the 
00193                 \i AutoSaveDelay \i0 variable. The \b DeclarePref \b0 function is currently
00194                 overloaded for INTs, UINTs, doubles, and Camelot String objects.
00195                 
00196                 \b NB! You should NOT pass the address of an \i auto \i0 variable to 
00197                 DeclarePref, because this will obviously be invalid as soon as your function
00198                 exits, and will cause interesting values to be written to the .ini file - hence
00199                 all preference variables should be declared as \i static \i0 . \b0
00200                 (This should be fairly obvious though, because actually using a preference
00201                 variable that isn't static wouldn't really work all that well.)
00202                 
00203                 Another effect of declaring a preference is that when the application saves
00204                 the preferences out (e.g. on normal application close-down), the preference
00205                 is automatically saved out under its correct name and section, using the
00206                 value contained in (assuming the above example) \i AutoSaveDelay \i0 when the 
00207                 save occurs.
00208                 
00209                 Note that before a preference can be declared, its parent section \i must \i0
00210                 have been declared via a call to \b DeclareSection \b0:
00211                 
00212                 MonoOn
00213                     Application::DeclareSection("Global", 100);
00214                 MonoOff
00215                 
00216                 The value of 100 indicates that the caller expects there to about 100
00217                 preferences stored in this section - this is used as a guideline by the
00218                 preferences system when allocating memory for preferences.  This is not an
00219                 absolute limit - the section is automatically extended when necessary, but
00220                 the more accurate the initial estimate, the more efficient the memory
00221                 usage will be.  Obviously for some sections, the accuracy is limited - for
00222                 example, it may depend on how many tools the user loads/uses.
00223                 
00224                 
00225     Errors:     None.
00226                 
00227 *********************************************************************************************/
00228 
00229 class CCAPI Application : public CC_CLASS_MEMDUMP
00230 {
00231     CC_DECLARE_MEMDUMP(Application);
00232     
00233 public:       
00234 
00235     Application();
00236     ~Application();
00237 
00238     BOOL Init();
00239     BOOL LateInit();
00240     void Deinit();
00241     
00242     List Documents;
00243 
00244     BOOL CreateDragTargets(DragInformation * DragInfo);
00245 
00246     void AddRenderRegion(RenderRegion *);
00247     BOOL DeleteRenderRegion(RenderRegion *);
00248     void DeleteRenderRegions(Document *pDoc) 
00249         { RenderList.Remove(pDoc); };
00250     void DeleteRenderRegions(View *pView) 
00251         { RenderList.Remove(pView); };
00252     RenderRegionList* GetRegionList();
00253     // CGS:  used by the brush system.
00254     // allows an extra check prior to doing the screen capture inside freehand.cpp (OnIdle ())
00255     BOOL IsRenderingComplete () { return (RenderList.IsEmpty ()); }
00256     BOOL ServiceRendering(BOOL bImmediate = FALSE);
00257 
00258     BOOL IsBgRendering();
00259     BOOL BgRendering;
00260 
00261     inline ColourManager *FindTheColourManager(void)
00262         { return(TheColourManager); };
00263 
00264     SelRange *Selection;                // Cached information about the current selection
00265 
00266 // These global functions provide VERY fast access to the global Selection object...
00267     inline void UpdateSelection()       // Inform the global Selection object that
00268         { Selection->Update(); };       // the selection may have changed.
00269 
00270     inline SelRange* FindSelection()    // Retreive a ptr to the global Selection
00271         { return(Selection); };         // SelRange object.
00272 
00273 // WEBSTER - markn 25/4/97
00274 // No pen stuff required in Webster
00275 // Taken out by vector stroking code Neville 2/10/97
00276 #ifdef VECTOR_STROKING
00277     // This functions allows access to the global pressure pen.
00278     CCPen* GetPressurePen();
00279 #endif // VECTOR_STROKING
00280 
00281     // Functions to gain access to the Blob Manager
00282     BlobManager* GetBlobManager() { return BlobMgr; }
00283 
00284     // Function to gain access to the ATM ini cache manager
00285     ATMIniCache* GetATMIniCache() { return pATMIniCache; }
00286 
00287     // Function to gain access to Camelots Font Manager
00288     FontManager* GetFontManager() { return FontMgr; }
00289 
00290     // Function to gain access to Camelots CMS Manager
00291     XaraCMS* GetCMSManager() const { return CMSManager; }
00292 
00293     // Function to gain access to the PrintMarks Manager
00294     PrintMarksMan* GetMarksManager() const { return TheMarksManager; }
00295 
00296     // Function to gain access to the Camelot Plug-in Manager
00297     PlugInManager* GetPlugInManager() const { return ThePlugInManager; }
00298 
00299     // And one for the one & only Camelot Filter Manager
00300     FilterManager* GetFilterManager() const { return TheFilterManager; }
00301     
00302     // Function to gain access to the plugin API host object
00303     APIObject* GetAPIObject() const { return TheAPIObject; }
00304 
00305     // Function to gain access to the noise generator
00306     NoiseMan* GetNoiseManager() const { return TheNoiseManager; }
00307 
00308     // Function to gain access to the IMoaHandleManager
00309     HandleManager* GetHandleManager() const {return TheHandleManager;}
00310 
00311     // Here's one for the WizOp's hanging around in your registry (don't forget the 's')
00312     WizOps* GetWizOps() const   {   return TheWizardOfOps;  }
00313 
00314     // Function to gain access to the Bitmap Cache
00315     CBitmapCache* GetBitmapCache() const { return TheBitmapCache; }
00316 
00317 #ifdef AUTOMATION
00318     // Use this for the one true ConcurrencyController
00319     ConcurrencyController* GetConcurrencyController() const {   return TheConcurrencyController;    }
00320 #endif
00321 
00322     // Functions to gain access to the Global Bitmap List
00323     GlobalBitmapList* GetGlobalBitmapList() { return &GlobalBitmaps; }
00324     GlobalFractalList* GetGlobalFractalList() { return &GlobalFractals; }
00325 
00326     // Function to register document components with the application.
00327     void RegisterDocComponent(DocComponentClass *);
00328 
00329     // Find out which document components have been registered.
00330     DocComponentClass *EnumerateDocComponents(DocComponentClass*);
00331 
00332     // Ask each registered document component to add an instance of the component to
00333     // a specified document.
00334     BOOL ApplyDocComponents(BaseDocument *);
00335 
00336 
00337     // Keith may not be needed now we have the Message handler class
00338     // Keith is Camelot's main sentry operation. His job is to hang out on the live
00339     // operation's list waiting for messages. When he receives a message he informs 
00340     // all interested subsystems. 
00341     /*
00342     SentryOperation Keith; 
00343     */                       
00344 
00345     BOOL OnKeyPress(KeyPress* pKeyPress);
00346     BOOL OnIdle(BOOL IdleRedraw);
00347     void RemoveIdleProcessor(INT32 Priority, Operation* pOp);
00348     void RegisterIdleProcessor(INT32 Priority, Operation* pOp);
00349     void NeedMoreIdles();
00350 
00351     // Dubugging dump ops
00352     void DumpAllOps(Document* pDoc);            // Dumps entire op history
00353     void DumpLastOp(Document* pDoc);            // Dumps last operation
00354     void DumpTree(BaseDocument* pDoc);              // Dumps document tree
00355     void DumpAllOps() {DumpAllOps(NULL);}           // The stupid QuickWatch window dosent allow default params!
00356     void DumpLastOp() {DumpLastOp(NULL);}           
00357     void DumpTree()   {DumpTree(NULL);}         
00358 
00359 protected:
00360     BOOL InitFilterManager();
00361     BOOL DeinitFilterManager();
00362 
00363     BOOL InitWizOps();
00364     BOOL DeinitWizOps();
00365 
00366 #ifdef AUTOMATION
00367     BOOL InitCCC();
00368     BOOL DestroyCCC();
00369 #endif
00370 
00371 private:
00372 
00373     RenderRegionList RenderList;
00374     BOOL ImmediateRenderPending;
00375 
00376     Preferences *CamelotPrefs;                          
00377 
00378     // The Colour System Manager. Call him Bob.
00379     ColourManager *TheColourManager;
00380 
00381 // WEBSTER - markn 25/4/97
00382 // No pen stuff required in Webster
00383 // Taken out by vector stroking code Neville 2/10/97
00384 #ifdef VECTOR_STROKING
00385     // A real or pretend pressure pen
00386     CCPen *PressurePen;
00387     BOOL PenInitialised;
00388 #endif // VECTOR_STROKING
00389 
00390     // The blob manager - He controls which blobs get displayed and when.
00391     BlobManager* BlobMgr;
00392 
00393     // List of registered document component classes.
00394     List* DocComponentClasses;
00395 
00396     // List of global bitmaps (OILBitmaps)
00397     GlobalBitmapList GlobalBitmaps;
00398 
00399     // List of global fractals
00400     GlobalFractalList GlobalFractals;
00401 
00402     // Lists for operation idle processing registery
00403     List IdleHighPriorityOps;
00404     List IdleLowPriorityOps;
00405 
00406     BOOL CallIdleProcessors();
00407 
00408     // The cache for stuff in the ATM ini file.
00409     ATMIniCache* pATMIniCache;
00410 
00411     // The Font Manager inside Camelot, Yes there's only one!
00412     FontManager* FontMgr;
00413 
00414     // The CMS (Colour Management system)
00415     XaraCMS* CMSManager;
00416 
00417     // The Print Marks manager
00418     PrintMarksMan* TheMarksManager;
00419 
00420     // The Plug-in Manager
00421     PlugInManager* ThePlugInManager;
00422 
00423     // Hmm...what could this be
00424     FilterManager*  TheFilterManager;
00425 
00426     // Camelot's plugin interface object
00427     APIObject *TheAPIObject;
00428 
00429     // The IMoaHandle Manager
00430     HandleManager* TheHandleManager;
00431 
00432     // The noise generation manager
00433     NoiseMan* TheNoiseManager;
00434 
00435     // The cache object
00436     ObjectCache *m_pObjCache;
00437 
00438     // The Bitmap Cache
00439     CBitmapCache* TheBitmapCache;
00440 
00441     // The WizOps local to this application
00442     WizOps* TheWizardOfOps;
00443 #ifdef AUTOMATION
00444     // For controlling all your concurrency needs...
00445     ConcurrencyController*  TheConcurrencyController;
00446 #endif
00447 
00448     // Temporary
00449     StatusLine* m_pStatusLine;
00450 
00451     std::auto_ptr<CTemplateManager> m_pTemplateManager;
00452 
00453 public:
00454     // Public access to the template manager
00455     CTemplateManager& GetTemplateManager()
00456     {
00457         return *m_pTemplateManager.get();
00458     }
00459 
00460     // return a pointer to the objectcache
00461     ObjectCache* GetObjectCache();
00462 
00463     // Call this to hide or show all view scroll-bars in all documents.
00464     void ShowViewScrollers(BOOL fIsVisible);
00465 
00466     // Preferences functions - just veneers to the Preferences object
00467     void WritePreferences()
00468         { CamelotPrefs->Write(); };
00469 
00470     void WipePreferenceFile()
00471         { CamelotPrefs->WipePreferenceFile(); };
00472     void WipeDangerousPrefs()
00473         { CamelotPrefs->WipeDangerousPrefs (); };
00474 
00475     BOOL DeclareSection(LPTCHAR Section, UINT32 InitialSize)
00476         { return CamelotPrefs->DeclareSection(Section, InitialSize); };
00477     
00478     BOOL DeclarePref(LPTCHAR Section, LPTCHAR Pref, 
00479                      INT32 *PrefVar, INT32 Min = INT_MIN, INT32 Max = INT_MAX)
00480         { return CamelotPrefs->DeclarePref(Section, Pref, PrefVar, Min, Max); };
00481 
00482     BOOL DeclarePref(LPTCHAR Section, LPTCHAR Pref, 
00483                      UINT32 *PrefVar, UINT32 Min = 0, UINT32 Max = UINT_MAX)
00484         { return CamelotPrefs->DeclarePref(Section, Pref, PrefVar, Min, Max); };
00485 
00486     BOOL DeclarePref(LPTCHAR Section, LPTCHAR Pref, 
00487                      double *PrefVar, double Min = DBL_MIN, double Max = DBL_MAX)
00488         { return CamelotPrefs->DeclarePref(Section, Pref, PrefVar, Min, Max); };
00489 
00490     BOOL DeclarePref(LPTCHAR Section, LPTCHAR Pref, StringBase *PrefVar)
00491         { return CamelotPrefs->DeclarePref(Section, Pref, PrefVar); };
00492 
00493     // Used by the application options/preferences dialog box
00494     BOOL GetPrefValue(LPTCHAR Section, LPTCHAR Pref, INT32 *PrefVar)
00495         { return CamelotPrefs->GetPrefValue(Section, Pref, PrefVar); };
00496     BOOL GetPrefValue(LPTCHAR Section, LPTCHAR Pref, UINT32 *PrefVar)
00497         { return CamelotPrefs->GetPrefValue(Section, Pref, PrefVar); };
00498     BOOL GetPrefValue(LPTCHAR Section, LPTCHAR Pref, double *PrefVar)
00499         { return CamelotPrefs->GetPrefValue(Section, Pref, PrefVar); };
00500 
00501     BOOL SetPrefValue(LPTCHAR Section, LPTCHAR Pref, INT32 *PrefVar)
00502         { return CamelotPrefs->SetPrefValue(Section, Pref, PrefVar); };
00503     BOOL SetPrefValue(LPTCHAR Section, LPTCHAR Pref, UINT32 *PrefVar)
00504         { return CamelotPrefs->SetPrefValue(Section, Pref, PrefVar); };
00505     BOOL SetPrefValue(LPTCHAR Section, LPTCHAR Pref, double *PrefVar)
00506         { return CamelotPrefs->SetPrefValue(Section, Pref, PrefVar); };
00507 
00508     // Used for direct partying on the preference file - mainly used for 'dynamic'
00509     // preferences that are interrogated on the fly as and when required.
00510     BOOL SetPrefDirect(LPTCHAR Section, LPTCHAR Pref, const TCHAR *pValue, BOOL Force = FALSE)
00511         { return CamelotPrefs->SetPrefDirect(Section, Pref, pValue, Force); }
00512     BOOL SetPrefDirect(LPTCHAR Section, LPTCHAR Pref, INT32 *pValue)
00513         { return CamelotPrefs->SetPrefDirect(Section, Pref, pValue); }
00514     BOOL SetPrefDirect(LPTCHAR Section, LPTCHAR Pref, UINT32 *pValue)
00515         { return CamelotPrefs->SetPrefDirect(Section, Pref, pValue); }
00516     BOOL SetPrefDirect(LPTCHAR Section, LPTCHAR Pref, double *pValue)
00517         { return CamelotPrefs->SetPrefDirect(Section, Pref, pValue); }
00518 
00519     BOOL GetPrefDirect(LPTCHAR Section, LPTCHAR Pref,StringBase *pValue)
00520         { return CamelotPrefs->GetPrefDirect(Section, Pref, pValue); }
00521     BOOL GetPrefDirect(LPTCHAR Section, LPTCHAR Pref,INT32 *pValue)
00522         { return CamelotPrefs->GetPrefDirect(Section, Pref, pValue); }
00523     BOOL GetPrefDirect(LPTCHAR Section, LPTCHAR Pref,UINT32 *pValue)
00524         { return CamelotPrefs->GetPrefDirect(Section, Pref, pValue); }
00525     BOOL GetPrefDirect(LPTCHAR Section, LPTCHAR Pref,double *pValue)
00526         { return CamelotPrefs->GetPrefDirect(Section, Pref, pValue); }
00527 
00528     BOOL GetConvertToEditableShapesDPI (INT32* pValue);
00529 
00530 private:
00531     BOOL CamelotShuttingDown;   // Set to TRUE at the point of no return when we are shutting
00532                                 // down camelot.  Note that if the user cancels the shut-down
00533                                 // this will be reset to FALSE again.
00534     BOOL DisabledRealDownload;  // did we disable real download?
00535 PORTNOTE("other","Removed HKEY usage")
00536 #ifndef EXCLUDE_FROM_XARALX
00537     HKEY key;                   // used for HKEY_CURRENT_USER
00538     HKEY key2;                  // used for HKEY_LOCAL_MACHINE
00539     BOOL ChangeRealDownloadBrowserOtion (HKEY rootKey, HKEY key, BOOL changeVal);   // actually changes the value
00540 #endif
00541 public:
00542 
00543     // Used to test if camelot is in the process of shutting itself down
00544     BOOL CamelotIsDying()   { return CamelotShuttingDown; }
00545     
00546     // Called in CCamApp::SaveAllModified to indicate that Camelot is shutting down.
00547     void ShuttingDown(BOOL fState = TRUE) { CamelotShuttingDown = fState; }
00548 
00549     void CheckRealDownload ();  // we need to check whether RealDownload exists!
00550     void ResetRealDownload ();  // we need to reset if we changed its state
00551 
00552 // StatusBar/StatusLine ...
00553 public:
00554     BOOL UpdateStatusBarText(String_256* text, BOOL PrefixSelDesc=TRUE);
00555     
00556     BOOL LockOutControlHelp ();             // status-line overide - no control help please
00557     BOOL UnlockControlHelp ();              // status-line overide - control help please
00558     
00559     CCStatusBar* GetpCCStatusBar();
00560     StatusLine*  GetpStatusLine();
00561 
00562     // regeneration list stuff to be regenerated at next click
00563     void RegenerateNodesInList();
00564     BOOL AddNodeToRegenList(Node * pNode);
00565 private:
00566     List RegenList;
00567 };
00568 
00569 
00570 /********************************************************************************************
00571 
00572 >   inline BOOL CCamApp CamelotIsDying()
00573 
00574     Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
00575     Created:    30/4/94
00576     Inputs:     -
00577     Outputs:    -
00578     Returns:    TRUE if camelot is in the process of shutting down
00579     Purpose:    To determine if we are currently shutting down Camelot. 
00580     Errors:     -
00581 
00582 ********************************************************************************************/
00583 
00584 
00585 // This is the application object itself:
00586 extern Application Camelot;
00587 
00588 // This is a global function which returns a pointer to the Camelot object. Try to use
00589 // this function instead of directly accessing the Camelot object, especially if you are
00590 // in a tool
00591 #if _AFXDLL
00592     Application* GetApplication();
00593 #else
00594     inline Application *GetApplication() { return &Camelot; }
00595 #endif
00596 
00597 const INT32 IDLEPRIORITY_HIGH = 1;
00598 const INT32 IDLEPRIORITY_LOW = 2;
00599 
00600 
00601 #endif
00602                                                        

Generated on Sat Nov 10 03:44:09 2007 for Camelot by  doxygen 1.4.4