CrystalSpace

Public API Reference

csutil/scf.h

Go to the documentation of this file.
00001 /*
00002     Crystal Space Shared Class Facility (SCF)
00003     Copyright (C) 1999 by Andrew Zabolotny
00004               (C) 2005 by Marten Svanfeldt
00005               (C) 2005 by Michael Adams
00006 
00007     This library is free software; you can redistribute it and/or
00008     modify it under the terms of the GNU Library General Public
00009     License as published by the Free Software Foundation; either
00010     version 2 of the License, or (at your option) any later version.
00011 
00012     This library is distributed in the hope that it will be useful,
00013     but WITHOUT ANY WARRANTY; without even the implied warranty of
00014     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00015     Library General Public License for more details.
00016 
00017     You should have received a copy of the GNU Library General Public
00018     License along with this library; if not, write to the Free
00019     Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
00020 */
00021 
00022 #ifndef __CSSCF_H__
00023 #define __CSSCF_H__
00024 
00025 #include "csextern.h"
00026 
00027 #include "csutil/array.h"
00028 #include "csutil/ref.h"
00029 
00038 class csPathsList;
00039 
00040 #ifndef CS_TYPENAME
00041   #ifdef CS_REF_TRACKER
00042    #include <typeinfo>
00043    #define CS_TYPENAME(x)                   typeid(x).name()
00044   #else
00045    #define CS_TYPENAME(x)                   0
00046   #endif
00047 #endif
00048 
00049 // INTERFACE DEFINITIONS
00050 #include "csutil/scf_interface.h"
00051 // NEW STYLE IMPLEMENTATION
00052 //#include "csutil/scf_implementation.h"
00053 
00054 
00055 //-- Helper macros
00056 
00061 #ifdef SCF_DEBUG
00062 #  define SCF_TRACE(x)                                                  \
00063    {                                                                    \
00064      printf ("SCF [%s:%d]:\n", __FILE__, (int)__LINE__);                \
00065      printf x; SCF_PRINT_CALL_ADDRESS                                   \
00066    }
00067 #else
00068 #  define SCF_TRACE(x)
00069 #endif
00070 
00075 #if (__GNUC__ >= 3) || ((__GNUC__ >= 2) && (__GNUC_MINOR__ >= 8))
00076 #  define SCF_PRINT_CALL_ADDRESS                                        \
00077    printf ("  Called from address %p\n", __builtin_return_address (0));
00078 #else
00079 #  define SCF_PRINT_CALL_ADDRESS
00080 #endif
00081 
00082 
00083 #ifdef CS_REF_TRACKER
00084  /* @@@ HACK: Force an AddAlias() call for every contained interface
00085   * However, when iSCF::SCF == 0, don't call QI to prevent interface ID 
00086   * resolution (which will fail).
00087   */
00088  #define SCF_INIT_TRACKER_ALIASES    \
00089   if (iSCF::SCF != 0) QueryInterface ((scfInterfaceID)-1, -1);
00090 #else
00091  #define SCF_INIT_TRACKER_ALIASES
00092 #endif
00093 
00094 //-- Old style implementation
00099 #define SCF_DECLARE_IBASE                                               \
00100   int scfRefCount;              /* Reference counter */                 \
00101   csArray<void**>* scfWeakRefOwners;                                    \
00102   void scfRemoveRefOwners ();                                           \
00103   SCF_DECLARE_EMBEDDED_IBASE (iBase)
00104 
00109 #define SCF_DECLARE_EMBEDDED_IBASE(OuterClass)                          \
00110 public:                                                                 \
00111   OuterClass *scfParent;        /* The parent object */                 \
00112   virtual void IncRef ();                                               \
00113   virtual void DecRef ();                                               \
00114   virtual int GetRefCount ();                                           \
00115   virtual void AddRefOwner (void** ref_owner);                          \
00116   virtual void RemoveRefOwner (void** ref_owner);                       \
00117   virtual void *QueryInterface (scfInterfaceID iInterfaceID, int iVersion)
00118 
00128 #define SCF_CONSTRUCT_IBASE(Parent)                                     \
00129   csRefTrackerAccess::TrackConstruction (this);                         \
00130   csRefTrackerAccess::SetDescription (this, CS_TYPENAME(*this));        \
00131   scfRefCount = 1;                                                      \
00132   scfWeakRefOwners = 0;                                                 \
00133   scfParent = Parent; if (scfParent) scfParent->IncRef();               \
00134   SCF_INIT_TRACKER_ALIASES                                              
00135 
00145 #define SCF_CONSTRUCT_EMBEDDED_IBASE(Interface)                         \
00146   Interface.scfParent = this;                                           \
00147   csRefTrackerAccess::AddAlias (&Interface, this);
00148 
00154 #define SCF_DESTRUCT_IBASE()                                            \
00155   csRefTrackerAccess::TrackDestruction (this, scfRefCount);             \
00156   scfRemoveRefOwners ();
00157 
00164 #define SCF_DESTRUCT_EMBEDDED_IBASE(Interface)                          \
00165   csRefTrackerAccess::RemoveAlias (&Interface, this);                   \
00166   Interface.scfParent = 0;
00167 
00173 #define SCF_IMPLEMENT_IBASE_INCREF(Class)                               \
00174 void Class::IncRef ()                                                   \
00175 {                                                                       \
00176   SCF_TRACE (("  (%s *)%p->IncRef (%d)\n", #Class, this, scfRefCount + 1));\
00177   csRefTrackerAccess::TrackIncRef (this, scfRefCount);                  \
00178   scfRefCount++;                                                        \
00179 }
00180 
00189 #define SCF_IMPLEMENT_IBASE_DECREF(Class)                               \
00190 void Class::DecRef ()                                                   \
00191 {                                                                       \
00192   csRefTrackerAccess::TrackDecRef (this, scfRefCount);                  \
00193   if (scfRefCount == 1)                                                 \
00194   {                                                                     \
00195     SCF_TRACE ((" delete (%s *)%p\n", #Class, this));                   \
00196     scfRemoveRefOwners ();                                              \
00197     if (scfParent)                                                      \
00198       scfParent->DecRef ();                                             \
00199     delete this;                                                        \
00200     return;                                                             \
00201   }                                                                     \
00202   scfRefCount--;                                                        \
00203 }
00204 
00211 #define SCF_IMPLEMENT_IBASE_REMOVE_REF_OWNERS(Class)                    \
00212 void Class::scfRemoveRefOwners ()                                       \
00213 {                                                                       \
00214   if (!scfWeakRefOwners) return;                                        \
00215   for (size_t i = 0 ; i < scfWeakRefOwners->Length () ; i++)            \
00216   {                                                                     \
00217     void** p = (*scfWeakRefOwners)[i];                                  \
00218     *p = 0;                                                             \
00219   }                                                                     \
00220   delete scfWeakRefOwners;                                              \
00221   scfWeakRefOwners = 0;                                                 \
00222 }
00223 
00228 #define SCF_IMPLEMENT_IBASE_REFOWNER(Class)                             \
00229 void Class::AddRefOwner (void** ref_owner)                              \
00230 {                                                                       \
00231   if (!scfWeakRefOwners)                                                \
00232     scfWeakRefOwners = new csArray<void**> (0, 4);                      \
00233   scfWeakRefOwners->InsertSorted (ref_owner);                           \
00234 }                                                                       \
00235 void Class::RemoveRefOwner (void** ref_owner)                           \
00236 {                                                                       \
00237   if (!scfWeakRefOwners)                                                \
00238     return;                                                             \
00239   size_t index = scfWeakRefOwners->FindSortedKey (                      \
00240     csArrayCmp<void**, void**> (ref_owner));                            \
00241   if (index != csArrayItemNotFound) scfWeakRefOwners->DeleteIndex (     \
00242     index);                                                             \
00243 }
00244 
00249 #define SCF_IMPLEMENT_IBASE_GETREFCOUNT(Class)                          \
00250 int Class::GetRefCount ()                                               \
00251 {                                                                       \
00252   return scfRefCount;                                                   \
00253 }
00254 
00261 #define SCF_IMPLEMENT_IBASE_QUERY(Class)                                \
00262 void *Class::QueryInterface (scfInterfaceID iInterfaceID, int iVersion) \
00263 {                                                                       \
00264   SCF_TRACE (("  (%s *)%p->QueryInterface (%lu, %08X)\n",               \
00265     #Class, this, iInterfaceID, iVersion));
00266 
00273 #define SCF_IMPLEMENT_IBASE_QUERY_END                                   \
00274   return scfParent ?                                                    \
00275     scfParent->QueryInterface (iInterfaceID, iVersion) : 0;             \
00276 }
00277 
00283 #define SCF_IMPLEMENT_IBASE(Class)                                      \
00284   SCF_IMPLEMENT_IBASE_INCREF(Class)                                     \
00285   SCF_IMPLEMENT_IBASE_DECREF(Class)                                     \
00286   SCF_IMPLEMENT_IBASE_GETREFCOUNT(Class)                                \
00287   SCF_IMPLEMENT_IBASE_REFOWNER(Class)                                   \
00288   SCF_IMPLEMENT_IBASE_REMOVE_REF_OWNERS(Class)                          \
00289   SCF_IMPLEMENT_IBASE_QUERY(Class)
00290 
00295 #define SCF_IMPLEMENT_IBASE_END                                         \
00296   SCF_IMPLEMENT_IBASE_QUERY_END
00297 
00304 #define SCF_IMPLEMENT_EMBEDDED_IBASE_INCREF(Class)                      \
00305 void Class::IncRef ()                                                   \
00306 {                                                                       \
00307   SCF_TRACE (("  (%s *)%p->IncRef (%d)\n", #Class, this,                \
00308     scfParent->GetRefCount () + 1));                                    \
00309   scfParent->IncRef ();                                                 \
00310 }
00311 
00318 #define SCF_IMPLEMENT_EMBEDDED_IBASE_DECREF(Class)                      \
00319 void Class::DecRef ()                                                   \
00320 {                                                                       \
00321   SCF_TRACE (("  (%s *)%p->DecRef (%d)\n", #Class, this,                \
00322               scfParent->GetRefCount ()-1));                            \
00323   scfParent->DecRef ();                                                 \
00324 }
00325 
00330 #define SCF_IMPLEMENT_EMBEDDED_IBASE_GETREFCOUNT(Class)                 \
00331 int Class::GetRefCount ()                                               \
00332 {                                                                       \
00333   return scfParent->GetRefCount ();                                     \
00334 }
00335 
00340 #define SCF_IMPLEMENT_EMBEDDED_IBASE_REFOWNER(Class)                    \
00341 void Class::AddRefOwner (void** ref_owner)                              \
00342 {                                                                       \
00343   scfParent->AddRefOwner (ref_owner);                                   \
00344 }                                                                       \
00345 void Class::RemoveRefOwner (void** ref_owner)                           \
00346 {                                                                       \
00347   scfParent->RemoveRefOwner (ref_owner);                                \
00348 }
00349 
00356 #define SCF_IMPLEMENT_EMBEDDED_IBASE_QUERY(Class)                       \
00357 void *Class::QueryInterface (scfInterfaceID iInterfaceID, int iVersion) \
00358 {                                                                       \
00359   SCF_TRACE (("  (%s *)%p->QueryInterface (%lu, %08X)\n",               \
00360     #Class, this, iInterfaceID, iVersion));
00361 
00368 #define SCF_IMPLEMENT_EMBEDDED_IBASE_QUERY_END                          \
00369   return scfParent->QueryInterface (iInterfaceID, iVersion);            \
00370 }
00371 
00378 #define SCF_IMPLEMENT_EMBEDDED_IBASE(Class)                             \
00379   SCF_IMPLEMENT_EMBEDDED_IBASE_INCREF(Class)                            \
00380   SCF_IMPLEMENT_EMBEDDED_IBASE_DECREF(Class)                            \
00381   SCF_IMPLEMENT_EMBEDDED_IBASE_GETREFCOUNT(Class)                       \
00382   SCF_IMPLEMENT_EMBEDDED_IBASE_REFOWNER(Class)                          \
00383   SCF_IMPLEMENT_EMBEDDED_IBASE_QUERY(Class)
00384 
00389 #define SCF_IMPLEMENT_EMBEDDED_IBASE_END                                \
00390   SCF_IMPLEMENT_EMBEDDED_IBASE_QUERY_END
00391 
00398 #define SCF_IMPLEMENTS_INTERFACE(Interface)                             \
00399   csRefTrackerAccess::AddAlias (static_cast<Interface*> (this), this);\
00400   SCF_IMPLEMENTS_INTERFACE_COMMON (Interface, this)
00401 
00406 #define SCF_IMPLEMENTS_EMBEDDED_INTERFACE(Interface)                    \
00407   SCF_IMPLEMENTS_INTERFACE_COMMON (Interface, (&scf##Interface))
00408 
00412 #define SCF_IMPLEMENTS_INTERFACE_COMMON(Interface,Object)               \
00413   if (iInterfaceID == scfInterfaceTraits<Interface>::GetID() &&         \
00414     scfCompatibleVersion (iVersion, scfInterfaceTraits<Interface>::GetVersion())) \
00415   {                                                                     \
00416     (Object)->IncRef ();                                                \
00417     return static_cast<Interface*> (Object);                            \
00418   }
00419 
00430 #define SCF_DECLARE_IBASE_EXT(ParentClass)                              \
00431   typedef ParentClass __scf_superclass;                                 \
00432   virtual void IncRef ();                                               \
00433   virtual void DecRef ();                                               \
00434   virtual int GetRefCount ();                                           \
00435   virtual void AddRefOwner (void** ref_owner);                          \
00436   virtual void RemoveRefOwner (void** ref_owner);                       \
00437   virtual void *QueryInterface (scfInterfaceID iInterfaceID, int iVersion)
00438 
00445 #define SCF_IMPLEMENT_IBASE_EXT_INCREF(Class)                           \
00446 void Class::IncRef ()                                                   \
00447 {                                                                       \
00448   __scf_superclass::IncRef ();                                          \
00449 }
00450 
00457 #define SCF_IMPLEMENT_IBASE_EXT_DECREF(Class)                           \
00458 void Class::DecRef ()                                                   \
00459 {                                                                       \
00460   __scf_superclass::DecRef ();                                          \
00461 }
00462 
00469 #define SCF_IMPLEMENT_IBASE_EXT_GETREFCOUNT(Class)                      \
00470 int Class::GetRefCount ()                                               \
00471 {                                                                       \
00472   return __scf_superclass::GetRefCount ();                              \
00473 }
00474 
00479 #define SCF_IMPLEMENT_IBASE_EXT_REFOWNER(Class)                 \
00480 void Class::AddRefOwner (void** ref_owner)                              \
00481 {                                                                       \
00482   __scf_superclass::AddRefOwner (ref_owner);                            \
00483 }                                                                       \
00484 void Class::RemoveRefOwner (void** ref_owner)                           \
00485 {                                                                       \
00486   __scf_superclass::RemoveRefOwner (ref_owner);                         \
00487 }
00488 
00495 #define SCF_IMPLEMENT_IBASE_EXT_QUERY(Class)                            \
00496 void *Class::QueryInterface (scfInterfaceID iInterfaceID, int iVersion) \
00497 {
00498 
00505 #define SCF_IMPLEMENT_IBASE_EXT_QUERY_END                               \
00506   return __scf_superclass::QueryInterface (iInterfaceID, iVersion);     \
00507 }
00508 
00513 #define SCF_IMPLEMENT_IBASE_EXT(Class)                                  \
00514   SCF_IMPLEMENT_IBASE_EXT_INCREF(Class)                                 \
00515   SCF_IMPLEMENT_IBASE_EXT_DECREF(Class)                                 \
00516   SCF_IMPLEMENT_IBASE_EXT_GETREFCOUNT(Class)                            \
00517   SCF_IMPLEMENT_IBASE_EXT_REFOWNER(Class)                               \
00518   SCF_IMPLEMENT_IBASE_EXT_QUERY(Class)
00519 
00524 #define SCF_IMPLEMENT_IBASE_EXT_END                                     \
00525   SCF_IMPLEMENT_IBASE_EXT_QUERY_END
00526 
00542 #ifdef CS_MEMORY_TRACKER
00543 #include "memdebug.h" // needed for mtiRegisterModule
00544 // This special version of SCF_IMPLEMENT_FACTORY_INIT will make sure that
00545 // the memory tracker for this plugin is implemented.
00546 #define SCF_IMPLEMENT_FACTORY_INIT(Class)                               \
00547 static inline void Class ## _scfUnitInitialize(iSCF* SCF)               \
00548 {                                                                       \
00549   iSCF::SCF = SCF;                                                      \
00550   mtiRegisterModule (#Class);                                           \
00551 }                                                                       \
00552 CS_EXPORTED_FUNCTION                                                    \
00553 void CS_EXPORTED_NAME(Class,_scfInitialize)(iSCF* SCF)                  \
00554 { Class ## _scfUnitInitialize(SCF); }
00555 #else
00556 #define SCF_IMPLEMENT_FACTORY_INIT(Class)                               \
00557 static inline void Class ## _scfUnitInitialize(iSCF* SCF)               \
00558 { iSCF::SCF = SCF; }                                                    \
00559 CS_EXPORTED_FUNCTION                                                    \
00560 void CS_EXPORTED_NAME(Class,_scfInitialize)(iSCF* SCF)                  \
00561 { Class ## _scfUnitInitialize(SCF); }
00562 #endif
00563 
00569 #define SCF_IMPLEMENT_FACTORY_FINIS(Class)                              \
00570 CS_EXPORTED_FUNCTION                                                    \
00571 void CS_EXPORTED_NAME(Class,_scfFinalize)()                             \
00572 {                                                                       \
00573 CS_STATIC_VARIABLE_CLEANUP                                              \
00574 }
00575 
00582 #define SCF_IMPLEMENT_FACTORY_CREATE(Class)                             \
00583 CS_EXPORTED_FUNCTION                                                    \
00584 iBase* CS_EXPORTED_NAME(Class,_Create)(iBase *iParent)                  \
00585 {                                                                       \
00586   iBase *ret = new Class (iParent);                                     \
00587   SCF_TRACE (("  %p = new %s ()\n", ret, #Class));                      \
00588   return ret;                                                           \
00589 }
00590 
00597 #define SCF_IMPLEMENT_FACTORY(Class)                                    \
00598   SCF_IMPLEMENT_FACTORY_INIT(Class)                                     \
00599   SCF_IMPLEMENT_FACTORY_FINIS(Class)                                    \
00600   SCF_IMPLEMENT_FACTORY_CREATE(Class)
00601 
00602 #define SCF_STATIC_CLASS_CONTEXT      "*static*"
00603 
00612 #define SCF_REGISTER_STATIC_CLASS(Class,Ident,Desc,Dep)                 \
00613   CS_EXPORTED_FUNCTION iBase* CS_EXPORTED_NAME(Class,_Create)(iBase*);  \
00614   class Class##_StaticInit__                                            \
00615   {                                                                     \
00616   public:                                                               \
00617     Class##_StaticInit__()                                              \
00618     {                                                                   \
00619       scfRegisterStaticClass(                                           \
00620         CS_EXPORTED_NAME(Class,_Create), Ident, Desc, Dep);             \
00621     }                                                                   \
00622   } Class##_static_init__;
00623 
00628 #define SCF_REGISTER_STATIC_LIBRARY(Module, MetaInfo)                   \
00629   class Module##_StaticInit                                             \
00630   {                                                                     \
00631   public:                                                               \
00632     Module##_StaticInit()                                               \
00633     {                                                                   \
00634       scfRegisterStaticClasses (MetaInfo);                              \
00635     }                                                                   \
00636   } Module##_static_init__;
00637 
00642 #define SCF_DEFINE_FACTORY_FUNC_REGISTRATION(Class)                     \
00643   CS_EXPORTED_FUNCTION iBase* CS_EXPORTED_NAME(Class,_Create)(iBase*);  \
00644   class Class##_StaticInit                                              \
00645   {                                                                     \
00646   public:                                                               \
00647     Class##_StaticInit()                                                \
00648     {                                                                   \
00649       scfRegisterStaticFactoryFunc (CS_EXPORTED_NAME(Class,_Create),    \
00650         #Class);                                                        \
00651     }                                                                   \
00652   };
00653 
00658 #define SCF_USE_STATIC_PLUGIN(Module)                                   \
00659   namespace csStaticPluginInit                                          \
00660   {                                                                     \
00661     class Module { public: Module(); };                                 \
00662     Module Module##_StaticInit;                                         \
00663   }
00664 
00673 #define SCF_REGISTER_FACTORY_FUNC(Class)                                \
00674   SCF_DEFINE_FACTORY_FUNC_REGISTRATION(Class)                           \
00675   Class##_StaticInit Class##_static_init__;
00676 
00677 //--------------------------------------------- Class factory interface -----//
00678 
00692 struct iFactory : public iBase
00693 {
00695   virtual iBase *CreateInstance () = 0;
00697   virtual void TryUnload () = 0;
00699   virtual const char *QueryDescription () = 0;
00701   virtual const char *QueryDependencies () = 0;
00703   virtual const char *QueryClassID () = 0;
00705   virtual const char *QueryModuleName () = 0;
00706 };
00707 
00708 //----------------------------------------------- Client-side functions -----//
00709 
00714 enum
00715 {
00716   SCF_VERBOSE_NONE            = 0,      
00717   SCF_VERBOSE_PLUGIN_SCAN     = 1 << 0, 
00718   SCF_VERBOSE_PLUGIN_LOAD     = 1 << 1, 
00719   SCF_VERBOSE_PLUGIN_REGISTER = 1 << 2, 
00720   SCF_VERBOSE_CLASS_REGISTER  = 1 << 3, 
00721   SCF_VERBOSE_ALL             = ~0      
00722 };
00723 
00739 CS_CRYSTALSPACE_EXPORT void scfInitialize(csPathsList const* pluginPaths,
00740   unsigned int verbose = SCF_VERBOSE_NONE);
00741 
00746 CS_CRYSTALSPACE_EXPORT void scfInitialize(int argc, const char* const argv[]);
00747 
00749 
00755 CS_CRYSTALSPACE_EXPORT void scfRegisterStaticClass (scfFactoryFunc, 
00756   const char *iClassID, const char *Description, 
00757   const char *Dependencies = 0);
00758 CS_CRYSTALSPACE_EXPORT void scfRegisterStaticClasses (char const* xml);
00759 CS_CRYSTALSPACE_EXPORT void scfRegisterStaticFactoryFunc (scfFactoryFunc, 
00760   const char *FactClass);
00762   
00763 //---------- IMPLEMENTATION OF HELPER FUNCTIONS
00764 
00765 
00766 
00770 template<class Interface, class ClassPtr>
00771 inline csPtr<Interface> scfQueryInterface (ClassPtr object)
00772 {
00773   Interface *x = (Interface*)object->QueryInterface (
00774     scfInterfaceTraits<Interface>::GetID (),
00775     scfInterfaceTraits<Interface>::GetVersion ());
00776   return csPtr<Interface> (x);
00777 }
00778 
00779 //Compatibility macro for scfQueryInterface
00780 #define SCF_QUERY_INTERFACE(Object,Interface) \
00781   scfQueryInterface<Interface> (Object)
00782 
00787 template<class Interface, class ClassPtr>
00788 inline csPtr<Interface> scfQueryInterfaceSafe (ClassPtr object)
00789 {
00790   if (object == 0) return csPtr<Interface> (0);
00791 
00792   Interface *x = (Interface*)object->QueryInterface (
00793     scfInterfaceTraits<Interface>::GetID (),
00794     scfInterfaceTraits<Interface>::GetVersion ());
00795   return csPtr<Interface> (x);
00796 }
00797 //Compatibility macro for scfQueryInterfaceSafe
00798 #define SCF_QUERY_INTERFACE_SAFE(Object,Interface) \
00799   scfQueryInterfaceSafe<Interface> (Object)
00800 
00804 template<class Interface>
00805 inline csPtr<Interface> scfCreateInstance (char const * const ClassID)
00806 {
00807   iBase *base = iSCF::SCF->CreateInstance (ClassID);
00808 
00809   if (base == 0) return csPtr<Interface> (0);
00810 
00811   Interface *x = (Interface*)base->QueryInterface (
00812     scfInterfaceTraits<Interface>::GetID (),
00813     scfInterfaceTraits<Interface>::GetVersion ());
00814 
00815   if (x) base->DecRef (); //release our base interface
00816   return csPtr<Interface> (x);
00817 }
00818 
00819 // Compatibility macro for scfCreateInstance function
00820 #define SCF_CREATE_INSTANCE(ClassID,Interface) \
00821   scfCreateInstance<Interface> (ClassID)
00822 
00823 // Give versions to above declared classes.
00824 SCF_VERSION (iFactory, 0, 0, 2);
00825 
00826 // A bit hacky.
00827 #include "csutil/reftrackeraccess.h"
00828 
00831 #endif // __CSSCF_H__

Generated for Crystal Space 1.0.2 by doxygen 1.4.7