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