home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1998 May / Pcwk5b98.iso / Borland / Cplus45 / BC45 / OWLINC.PAK / DOCTPL.H < prev    next >
C/C++ Source or Header  |  1995-08-29  |  11KB  |  275 lines
  1. //----------------------------------------------------------------------------
  2. // ObjectWindows
  3. // (C) Copyright 1993, 1994 by Borland International, All Rights Reserved
  4. //
  5. //   Defines classes TDocTemplate, TDocTemplateT<D,V>
  6. //----------------------------------------------------------------------------
  7. #if !defined(OWL_DOCTPL_H)
  8. #define OWL_DOCTPL_H
  9.  
  10. #if !defined(OWL_OWLDEFS_H)
  11. # include <owl/owldefs.h>
  12. #endif
  13. #if !defined(OSL_LOCALE_H)
  14. # include <osl/locale.h>
  15. #endif
  16. #if !defined(CLASSLIB_OBJSTRM_H)
  17. # include <classlib/objstrm.h>
  18. #endif
  19.  
  20. #if defined(_OWLDLL) && defined(__DLL__) && !defined(BI_PLAT_WIN32)
  21. # define _DOCVIEWENTRY __export   // templates in a DLL using DLLs
  22. #else
  23. # define _DOCVIEWENTRY
  24. #endif
  25.  
  26. class _OWLCLASS TDocTemplate;
  27. class _OWLCLASS TDocManager;
  28. class _OWLCLASS TModule;
  29. class _OWLCLASS TDocument;
  30. class _OWLCLASS TView;
  31.  
  32. extern TDocTemplate* DocTemplateStaticHead;// templates constructed before app
  33.  
  34. //
  35. //  class TDocTemplate
  36. //  ----- ------------
  37. //
  38. class _OWLCLASS TDocTemplate : public TRegLink, public TStreamableBase {
  39.   public:
  40.     virtual TDocument* ConstructDoc(TDocument* parent = 0) = 0;
  41.     virtual TView*     ConstructView(TDocument& doc) = 0;
  42.     virtual TDocument* IsMyKindOfDoc(TDocument& doc) = 0;
  43.     virtual TView*     IsMyKindOfView(TView& view) = 0;
  44.     virtual const char far* GetViewName() = 0;
  45.     bool               IsVisible();     // displayable in file select dialogs
  46.     virtual TDocTemplate* Clone(TModule* module,
  47.                                 TDocTemplate*& phead=DocTemplateStaticHead)=0;
  48.     TDocManager*    GetDocManager() const {return DocManager;}
  49.     void            SetDocManager(TDocManager* dm) {DocManager = dm;}
  50.     const char far* GetDirectory() const;
  51.     void            SetDirectory(const char far*);
  52.     void            SetDirectory(const char far*, int len);
  53.     TDocTemplate*   GetNextTemplate() const {return (TDocTemplate*)Next;}
  54.     bool            IsFlagSet(long flag) const {return ToBool(GetFlags()&flag);}
  55.     long            GetFlags() const {return Flags;}
  56.     void            SetFlag(long flag);
  57.     void            ClearFlag(long flag);
  58.     bool            IsStatic() {return ToBool(RefCnt & 0x8000);}
  59.     TModule*&       GetModule() {return *ModulePtr;}
  60.     void            SetModule(TModule* module) {ModuleDeref = module;
  61.                                                 ModulePtr = &ModuleDeref;}
  62.  
  63.   protected:                // called only from parameterized subclass
  64.     TDocTemplate(TRegList& regList, TModule*& module, TDocTemplate*& phead);
  65.    ~TDocTemplate();
  66.  
  67.   private:
  68.     char far* Directory;        // current directory path, 0 until changed
  69.     long      Flags;            // dt??? bits for dialogs and creation modes
  70.     TDocManager*  DocManager;   // pointer back to document manager
  71.     int       RefCnt;           // documents attached + 1 if attached to docmgr
  72.     TModule** ModulePtr;        // would be TModule*&, except for streaming
  73.     TModule*  ModuleDeref;      // used only when setting a new module
  74.  
  75.   // The following functions are maintained for backward compatability
  76.   // with code generated for versions prior to enhanced document templates
  77.   //
  78.   public:
  79.     virtual TDocument* CreateDoc(const char far* path, long flags = 0) = 0;
  80.     virtual TView*     CreateView(TDocument& doc, long flags = 0) = 0;
  81.     TDocument*         InitDoc(TDocument* doc,const char far* path,long flags);
  82.     TView*             InitView(TView* view);
  83.     bool               SelectSave(TDocument& doc);
  84.     const char far*    GetFileFilter() const;
  85.     const char far*    GetDescription() const;
  86.     const char far*    GetDefaultExt() const;
  87.     void               SetFileFilter(const char far*);
  88.     void               SetDescription(const char far*);
  89.     void               SetDefaultExt(const char far*);
  90.  
  91.   protected:                // called only from parameterized subclass
  92.     TDocTemplate(const char* desc, const char* filt,
  93.                  const char* dir,  const char* ext, long flags,
  94.                  TModule*& module, TDocTemplate*& phead);
  95.   private:
  96.     static bool       (*SelectSave_)(TDocTemplate* tpl, TDocument& doc);
  97.     static TView*     (*InitView_)(TView* view);
  98.     static TDocument* (*InitDoc_)(TDocTemplate& tpl, TDocument* doc,
  99.                                   const char far* path, long flags);
  100.  
  101.   DECLARE_ABSTRACT_STREAMABLE(_OWLCLASS, TDocTemplate, 1);
  102.   friend class TDocument;   // access to RefCnt
  103.   friend class TDocManager;
  104. };
  105.  
  106. //
  107. //  class TDocTemplateT<D,V>
  108. //  ----- ------------------
  109. //
  110. template<class D, class V>
  111. class _DOCVIEWENTRY TDocTemplateT : public TDocTemplate {
  112.   public:
  113.     TDocTemplateT(TRegList& regList, TModule*& module = ::Module,
  114.                   TDocTemplate*& phead = DocTemplateStaticHead);
  115.     TDocTemplateT(const char* filt, const char* desc,
  116.                   const char* dir, const char* ext, long flags = 0,
  117.                   TModule*& module = ::Module,
  118.                   TDocTemplate*& phead = DocTemplateStaticHead);
  119.     TDocTemplateT* Clone(TModule* module,
  120.                          TDocTemplate*& phead = DocTemplateStaticHead);
  121.     D* ConstructDoc(TDocument* parent = 0);
  122.     V* ConstructView(TDocument& doc);
  123.     D* IsMyKindOfDoc(TDocument& doc);  // returns 0 if template can't support
  124.     V* IsMyKindOfView(TView& view);    // returns 0 if template incompatible
  125.     virtual const char far* GetViewName() {return V::StaticName();}
  126.  
  127.     // The following functions are maintained for backward compatability
  128.     //
  129.     D* CreateDoc(const char far* path, long flags = 0);
  130.     TView* CreateView(TDocument& doc, long flags = 0);
  131.  
  132.   // explicit expansion of DECLARE_STREAMABLE for use with parameterized class
  133.   // DECLARE_STREAMABLE_FROM_BASE(TDocTemplateT<D,V>);
  134.   //
  135.   #define TEMPLATECLASS TDocTemplateT<D,V>
  136.   DECLARE_CASTABLE;
  137.   DECLARE_STREAMABLE_CTOR(TDocTemplateT);
  138.   DECLARE_STREAMER_FROM_BASE(_DOCVIEWENTRY, TEMPLATECLASS, TDocTemplate);
  139.   DECLARE_STREAMABLE_OPS(TEMPLATECLASS);
  140.   #undef TEMPLATECLASS
  141. };
  142.  
  143. //----------------------------------------------------------------------------
  144. // Template flags used in reg parameter "docflags"
  145. //
  146.  
  147. //
  148. // definitions of dt??? document/view flags for templates and CreateDoc()
  149. //
  150. const long dtNewDoc     = 0x80000000L; // create new document, no path used
  151. const long dtAutoDelete = 0x40000000L; // delete doc when last view is deleted
  152. const long dtNoAutoView = 0x20000000L; // no automatic create of default view
  153. const long dtSingleView = 0x10000000L; // only a single view per document
  154. const long dtAutoOpen   = 0x08000000L; // open document upon creation
  155. const long dtUpdateDir  = 0x04000000L; // syncronize directory with dialog dir
  156. const long dtHidden     = 0x02000000L; // hide template from user selection
  157. const long dtSelected   = 0x01000000L; // indicates template last selected
  158. const long dtDynRegInfo = 0x00800000L; // reginfo table is dynamic, not static
  159. const long dtSingleUse  = 0x00400000L; // to be registered as single use
  160. const long dtRegisterExt= 0x00200000L; // register extension with this app
  161.  
  162. //
  163. // flags defined by Windows in <commdlg.h> - use the low order 17 bits
  164. //
  165. const long dtReadOnly       = OFN_READONLY;      // initial check readonly box
  166. const long dtOverwritePrompt= OFN_OVERWRITEPROMPT;  // prompt before overwrite
  167. const long dtHideReadOnly   = OFN_HIDEREADONLY;     // no show readonly box
  168. const long dtPathMustExist  = OFN_PATHMUSTEXIST;    // path must be valid
  169. const long dtFileMustExist  = OFN_FILEMUSTEXIST;    // file must exist
  170. const long dtCreatePrompt   = OFN_CREATEPROMPT;     // prompt before create
  171. const long dtNoReadOnly     = OFN_NOREADONLYRETURN; // return writable file
  172. const long dtNoTestCreate   = OFN_NOTESTFILECREATE; // skip create tests
  173.  
  174. //----------------------------------------------------------------------------
  175. // inline implementations
  176. //
  177.  
  178. inline bool
  179. TDocTemplate::IsVisible() {
  180.   return ToBool(!(GetFlags() & dtHidden));
  181. }
  182.  
  183. inline TDocument*
  184. TDocTemplate::InitDoc(TDocument* doc,const char far* path,long flags)
  185. {
  186.   return InitDoc_(*this, doc, path, flags);
  187. }
  188.  
  189. inline TView*
  190. TDocTemplate::InitView(TView* view)
  191. {
  192.   return InitView_(view);
  193. }
  194.  
  195. inline bool
  196. TDocTemplate::SelectSave(TDocument& doc)
  197. {
  198.   return SelectSave_(this, doc);
  199. }
  200.  
  201. template<class D, class V> inline
  202. TDocTemplateT<D,V>::TDocTemplateT(TRegList& regList,
  203.                         TModule*& module, TDocTemplate*& phead)
  204.                   : TDocTemplate(regList, module, phead){}
  205.  
  206. template<class D, class V> inline
  207. TDocTemplateT<D,V>::TDocTemplateT(const char* desc, const char* filt,
  208.                         const char* dir,  const char* ext, long flags,
  209.                         TModule*& module, TDocTemplate*& phead)
  210.                   : TDocTemplate(desc, filt, dir, ext, flags, module, phead){}
  211.  
  212. template<class D, class V> inline TDocTemplateT<D,V>*
  213. TDocTemplateT<D,V>::Clone(TModule* module, TDocTemplate*& phead) {
  214.   TDocTemplateT<D,V>* tpl = new TDocTemplateT<D,V>(GetRegList(),
  215.                                                    GetModule(), phead);
  216.   tpl->SetModule(module);
  217.   return tpl;
  218. }
  219.  
  220. template<class D, class V> inline D*
  221. TDocTemplateT<D,V>::ConstructDoc(TDocument* parent = 0) {
  222.   return new D(parent);
  223. }
  224.  
  225. template<class D, class V> inline V*
  226. TDocTemplateT<D,V>::ConstructView(TDocument& doc) {
  227.   return new V((D&)doc);
  228. }
  229.  
  230. template<class D, class V> inline D*
  231. TDocTemplateT<D,V>::CreateDoc(const char far* path, long flags) {
  232.   return (D*)InitDoc(new D(0), path, flags);
  233. }
  234.  
  235. template<class D, class V> inline TView*
  236. TDocTemplateT<D,V>::CreateView(TDocument& doc, long flags) {
  237.   return (V*)InitView(new V((D&)doc));
  238. }
  239.  
  240. #if defined(BI_NO_NEW_CASTS)  // cannot use templates with TYPESEAFE_DOWNCAST
  241.  
  242. #define DEFINE_DOC_TEMPLATE_CLASS(docClass, viewClass, tplClass) \
  243.   typedef TDocTemplateT<docClass, viewClass> tplClass;           \
  244.   IMPLEMENT_STREAMABLE_FROM_BASE(tplClass, TDocTemplate);        \
  245.   docClass* tplClass::IsMyKindOfDoc(TDocument& doc)              \
  246.   {                                                              \
  247.     return TYPESAFE_DOWNCAST(&doc, docClass);                    \
  248.   }                                                              \
  249.   viewClass* tplClass::IsMyKindOfView(TView& view)               \
  250.   {                                                              \
  251.     return TYPESAFE_DOWNCAST(&view, viewClass);                  \
  252.   }
  253.  
  254. #else                         // with RTTI, all functions can be templatized
  255.  
  256. template<class D, class V> D*
  257. TDocTemplateT<D,V>::IsMyKindOfDoc(TDocument& doc)
  258. {
  259.   return dynamic_cast<D*>(&doc);
  260. }
  261.  
  262. template<class D, class V> V*
  263. TDocTemplateT<D,V>::IsMyKindOfView(TView& view)
  264. {
  265.   return dynamic_cast<V*>(&view);
  266. }
  267.  
  268. #define DEFINE_DOC_TEMPLATE_CLASS(docClass, viewClass, tplClass) \
  269.   typedef TDocTemplateT<docClass, viewClass> tplClass;           \
  270.   IMPLEMENT_STREAMABLE_FROM_BASE(tplClass, TDocTemplate);
  271.  
  272. #endif
  273.  
  274. #endif  // OWL_DOCTPL_H
  275.