CydandClaude Fable 5
63312e07f9
- BORLAND/: Borland C++ 4.52 (chosen over 4.5 by byte-match: CODE/RP/CW32.LIB
is identical to 4.52's install lib). BCC32/TLINK32/TLIB/MAKE run natively on
Win11; CODE/BT/OPT.MAK is the shipped BTL4OPT.EXE's exact flag recipe
(extender = Borland PowerPack DPMI32, not Phar Lap TNT).
- restoration/source410/: the literal 1995-form reconstruction of the missing
BT game source (never mixed into CODE/). Round 1-3 state:
* 6 of 10 surviving original TUs COMPILE CLEAN under the period toolchain
(BTMSSN, BTCNSL, BTSCNRL, BTTEAM, BTL4MODE, BTL4ARND) - first builds
since 1996.
* BT_L4/BTL4APP.CPP pilot reconstruction: 12/12 functions, Fail() lands on
its binary-recorded line 400 exactly.
* BT/BTCNSL.HPP: console wire IDs recovered from the binary's ctors
(Killed=9, Damaged=10, ScoreUpdate=13, DeathWithoutHonor=15 [T1];
TeamScore=12 flagged [T4]).
* MUNGA/: 8 engine-header backfills back-dated from the BT412 WinTesla tree
(VDATA numbering decomp-verified; AUDREND's OpenAL-era virtual removed -
the period compiler is the drift detector).
* Tooling: backdate.py (WinTesla->1995 header transform), compile410.sh
(per-TU verification sweep under authentic OPT.MAK flags).
* README: corrected roadmap - MECH.HPP is the capstone grown with the mech
TU reconstructions; BTREG.CPP green = the header-family milestone.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
275 lines
11 KiB
C++
275 lines
11 KiB
C++
//----------------------------------------------------------------------------
|
|
// ObjectWindows
|
|
// (C) Copyright 1993, 1994 by Borland International, All Rights Reserved
|
|
//
|
|
// Defines classes TDocTemplate, TDocTemplateT<D,V>
|
|
//----------------------------------------------------------------------------
|
|
#if !defined(OWL_DOCTPL_H)
|
|
#define OWL_DOCTPL_H
|
|
|
|
#if !defined(OWL_OWLDEFS_H)
|
|
# include <owl/owldefs.h>
|
|
#endif
|
|
#if !defined(OSL_LOCALE_H)
|
|
# include <osl/locale.h>
|
|
#endif
|
|
#if !defined(CLASSLIB_OBJSTRM_H)
|
|
# include <classlib/objstrm.h>
|
|
#endif
|
|
|
|
#if defined(_OWLDLL) && defined(__DLL__) && !defined(BI_PLAT_WIN32)
|
|
# define _DOCVIEWENTRY __export // templates in a DLL using DLLs
|
|
#else
|
|
# define _DOCVIEWENTRY
|
|
#endif
|
|
|
|
class _OWLCLASS TDocTemplate;
|
|
class _OWLCLASS TDocManager;
|
|
class _OWLCLASS TModule;
|
|
class _OWLCLASS TDocument;
|
|
class _OWLCLASS TView;
|
|
|
|
extern TDocTemplate* DocTemplateStaticHead;// templates constructed before app
|
|
|
|
//
|
|
// class TDocTemplate
|
|
// ----- ------------
|
|
//
|
|
class _OWLCLASS TDocTemplate : public TRegLink, public TStreamableBase {
|
|
public:
|
|
virtual TDocument* ConstructDoc(TDocument* parent = 0) = 0;
|
|
virtual TView* ConstructView(TDocument& doc) = 0;
|
|
virtual TDocument* IsMyKindOfDoc(TDocument& doc) = 0;
|
|
virtual TView* IsMyKindOfView(TView& view) = 0;
|
|
virtual const char far* GetViewName() = 0;
|
|
bool IsVisible(); // displayable in file select dialogs
|
|
virtual TDocTemplate* Clone(TModule* module,
|
|
TDocTemplate*& phead=DocTemplateStaticHead)=0;
|
|
TDocManager* GetDocManager() const {return DocManager;}
|
|
void SetDocManager(TDocManager* dm) {DocManager = dm;}
|
|
const char far* GetDirectory() const;
|
|
void SetDirectory(const char far*);
|
|
void SetDirectory(const char far*, int len);
|
|
TDocTemplate* GetNextTemplate() const {return (TDocTemplate*)Next;}
|
|
bool IsFlagSet(long flag) const {return ToBool(GetFlags()&flag);}
|
|
long GetFlags() const {return Flags;}
|
|
void SetFlag(long flag);
|
|
void ClearFlag(long flag);
|
|
bool IsStatic() {return ToBool(RefCnt & 0x8000);}
|
|
TModule*& GetModule() {return *ModulePtr;}
|
|
void SetModule(TModule* module) {ModuleDeref = module;
|
|
ModulePtr = &ModuleDeref;}
|
|
|
|
protected: // called only from parameterized subclass
|
|
TDocTemplate(TRegList& regList, TModule*& module, TDocTemplate*& phead);
|
|
~TDocTemplate();
|
|
|
|
private:
|
|
char far* Directory; // current directory path, 0 until changed
|
|
long Flags; // dt??? bits for dialogs and creation modes
|
|
TDocManager* DocManager; // pointer back to document manager
|
|
int RefCnt; // documents attached + 1 if attached to docmgr
|
|
TModule** ModulePtr; // would be TModule*&, except for streaming
|
|
TModule* ModuleDeref; // used only when setting a new module
|
|
|
|
// The following functions are maintained for backward compatability
|
|
// with code generated for versions prior to enhanced document templates
|
|
//
|
|
public:
|
|
virtual TDocument* CreateDoc(const char far* path, long flags = 0) = 0;
|
|
virtual TView* CreateView(TDocument& doc, long flags = 0) = 0;
|
|
TDocument* InitDoc(TDocument* doc,const char far* path,long flags);
|
|
TView* InitView(TView* view);
|
|
bool SelectSave(TDocument& doc);
|
|
const char far* GetFileFilter() const;
|
|
const char far* GetDescription() const;
|
|
const char far* GetDefaultExt() const;
|
|
void SetFileFilter(const char far*);
|
|
void SetDescription(const char far*);
|
|
void SetDefaultExt(const char far*);
|
|
|
|
protected: // called only from parameterized subclass
|
|
TDocTemplate(const char* desc, const char* filt,
|
|
const char* dir, const char* ext, long flags,
|
|
TModule*& module, TDocTemplate*& phead);
|
|
private:
|
|
static bool (*SelectSave_)(TDocTemplate* tpl, TDocument& doc);
|
|
static TView* (*InitView_)(TView* view);
|
|
static TDocument* (*InitDoc_)(TDocTemplate& tpl, TDocument* doc,
|
|
const char far* path, long flags);
|
|
|
|
DECLARE_ABSTRACT_STREAMABLE(_OWLCLASS, TDocTemplate, 1);
|
|
friend class TDocument; // access to RefCnt
|
|
friend class TDocManager;
|
|
};
|
|
|
|
//
|
|
// class TDocTemplateT<D,V>
|
|
// ----- ------------------
|
|
//
|
|
template<class D, class V>
|
|
class _DOCVIEWENTRY TDocTemplateT : public TDocTemplate {
|
|
public:
|
|
TDocTemplateT(TRegList& regList, TModule*& module = ::Module,
|
|
TDocTemplate*& phead = DocTemplateStaticHead);
|
|
TDocTemplateT(const char* filt, const char* desc,
|
|
const char* dir, const char* ext, long flags = 0,
|
|
TModule*& module = ::Module,
|
|
TDocTemplate*& phead = DocTemplateStaticHead);
|
|
TDocTemplateT* Clone(TModule* module,
|
|
TDocTemplate*& phead = DocTemplateStaticHead);
|
|
D* ConstructDoc(TDocument* parent = 0);
|
|
V* ConstructView(TDocument& doc);
|
|
D* IsMyKindOfDoc(TDocument& doc); // returns 0 if template can't support
|
|
V* IsMyKindOfView(TView& view); // returns 0 if template incompatible
|
|
virtual const char far* GetViewName() {return V::StaticName();}
|
|
|
|
// The following functions are maintained for backward compatability
|
|
//
|
|
D* CreateDoc(const char far* path, long flags = 0);
|
|
TView* CreateView(TDocument& doc, long flags = 0);
|
|
|
|
// explicit expansion of DECLARE_STREAMABLE for use with parameterized class
|
|
// DECLARE_STREAMABLE_FROM_BASE(TDocTemplateT<D,V>);
|
|
//
|
|
#define TEMPLATECLASS TDocTemplateT<D,V>
|
|
DECLARE_CASTABLE;
|
|
DECLARE_STREAMABLE_CTOR(TDocTemplateT);
|
|
DECLARE_STREAMER_FROM_BASE(_DOCVIEWENTRY, TEMPLATECLASS, TDocTemplate);
|
|
DECLARE_STREAMABLE_OPS(TEMPLATECLASS);
|
|
#undef TEMPLATECLASS
|
|
};
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Template flags used in reg parameter "docflags"
|
|
//
|
|
|
|
//
|
|
// definitions of dt??? document/view flags for templates and CreateDoc()
|
|
//
|
|
const long dtNewDoc = 0x80000000L; // create new document, no path used
|
|
const long dtAutoDelete = 0x40000000L; // delete doc when last view is deleted
|
|
const long dtNoAutoView = 0x20000000L; // no automatic create of default view
|
|
const long dtSingleView = 0x10000000L; // only a single view per document
|
|
const long dtAutoOpen = 0x08000000L; // open document upon creation
|
|
const long dtUpdateDir = 0x04000000L; // syncronize directory with dialog dir
|
|
const long dtHidden = 0x02000000L; // hide template from user selection
|
|
const long dtSelected = 0x01000000L; // indicates template last selected
|
|
const long dtDynRegInfo = 0x00800000L; // reginfo table is dynamic, not static
|
|
const long dtSingleUse = 0x00400000L; // to be registered as single use
|
|
const long dtRegisterExt= 0x00200000L; // register extension with this app
|
|
|
|
//
|
|
// flags defined by Windows in <commdlg.h> - use the low order 17 bits
|
|
//
|
|
const long dtReadOnly = OFN_READONLY; // initial check readonly box
|
|
const long dtOverwritePrompt= OFN_OVERWRITEPROMPT; // prompt before overwrite
|
|
const long dtHideReadOnly = OFN_HIDEREADONLY; // no show readonly box
|
|
const long dtPathMustExist = OFN_PATHMUSTEXIST; // path must be valid
|
|
const long dtFileMustExist = OFN_FILEMUSTEXIST; // file must exist
|
|
const long dtCreatePrompt = OFN_CREATEPROMPT; // prompt before create
|
|
const long dtNoReadOnly = OFN_NOREADONLYRETURN; // return writable file
|
|
const long dtNoTestCreate = OFN_NOTESTFILECREATE; // skip create tests
|
|
|
|
//----------------------------------------------------------------------------
|
|
// inline implementations
|
|
//
|
|
|
|
inline bool
|
|
TDocTemplate::IsVisible() {
|
|
return ToBool(!(GetFlags() & dtHidden));
|
|
}
|
|
|
|
inline TDocument*
|
|
TDocTemplate::InitDoc(TDocument* doc,const char far* path,long flags)
|
|
{
|
|
return InitDoc_(*this, doc, path, flags);
|
|
}
|
|
|
|
inline TView*
|
|
TDocTemplate::InitView(TView* view)
|
|
{
|
|
return InitView_(view);
|
|
}
|
|
|
|
inline bool
|
|
TDocTemplate::SelectSave(TDocument& doc)
|
|
{
|
|
return SelectSave_(this, doc);
|
|
}
|
|
|
|
template<class D, class V> inline
|
|
TDocTemplateT<D,V>::TDocTemplateT(TRegList& regList,
|
|
TModule*& module, TDocTemplate*& phead)
|
|
: TDocTemplate(regList, module, phead){}
|
|
|
|
template<class D, class V> inline
|
|
TDocTemplateT<D,V>::TDocTemplateT(const char* desc, const char* filt,
|
|
const char* dir, const char* ext, long flags,
|
|
TModule*& module, TDocTemplate*& phead)
|
|
: TDocTemplate(desc, filt, dir, ext, flags, module, phead){}
|
|
|
|
template<class D, class V> inline TDocTemplateT<D,V>*
|
|
TDocTemplateT<D,V>::Clone(TModule* module, TDocTemplate*& phead) {
|
|
TDocTemplateT<D,V>* tpl = new TDocTemplateT<D,V>(GetRegList(),
|
|
GetModule(), phead);
|
|
tpl->SetModule(module);
|
|
return tpl;
|
|
}
|
|
|
|
template<class D, class V> inline D*
|
|
TDocTemplateT<D,V>::ConstructDoc(TDocument* parent = 0) {
|
|
return new D(parent);
|
|
}
|
|
|
|
template<class D, class V> inline V*
|
|
TDocTemplateT<D,V>::ConstructView(TDocument& doc) {
|
|
return new V((D&)doc);
|
|
}
|
|
|
|
template<class D, class V> inline D*
|
|
TDocTemplateT<D,V>::CreateDoc(const char far* path, long flags) {
|
|
return (D*)InitDoc(new D(0), path, flags);
|
|
}
|
|
|
|
template<class D, class V> inline TView*
|
|
TDocTemplateT<D,V>::CreateView(TDocument& doc, long flags) {
|
|
return (V*)InitView(new V((D&)doc));
|
|
}
|
|
|
|
#if defined(BI_NO_NEW_CASTS) // cannot use templates with TYPESEAFE_DOWNCAST
|
|
|
|
#define DEFINE_DOC_TEMPLATE_CLASS(docClass, viewClass, tplClass) \
|
|
typedef TDocTemplateT<docClass, viewClass> tplClass; \
|
|
IMPLEMENT_STREAMABLE_FROM_BASE(tplClass, TDocTemplate); \
|
|
docClass* tplClass::IsMyKindOfDoc(TDocument& doc) \
|
|
{ \
|
|
return TYPESAFE_DOWNCAST(&doc, docClass); \
|
|
} \
|
|
viewClass* tplClass::IsMyKindOfView(TView& view) \
|
|
{ \
|
|
return TYPESAFE_DOWNCAST(&view, viewClass); \
|
|
}
|
|
|
|
#else // with RTTI, all functions can be templatized
|
|
|
|
template<class D, class V> D*
|
|
TDocTemplateT<D,V>::IsMyKindOfDoc(TDocument& doc)
|
|
{
|
|
return dynamic_cast<D*>(&doc);
|
|
}
|
|
|
|
template<class D, class V> V*
|
|
TDocTemplateT<D,V>::IsMyKindOfView(TView& view)
|
|
{
|
|
return dynamic_cast<V*>(&view);
|
|
}
|
|
|
|
#define DEFINE_DOC_TEMPLATE_CLASS(docClass, viewClass, tplClass) \
|
|
typedef TDocTemplateT<docClass, viewClass> tplClass; \
|
|
IMPLEMENT_STREAMABLE_FROM_BASE(tplClass, TDocTemplate);
|
|
|
|
#endif
|
|
|
|
#endif // OWL_DOCTPL_H
|