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>
428 lines
17 KiB
C++
428 lines
17 KiB
C++
//----------------------------------------------------------------------------
|
|
// ObjectWindows
|
|
// (C) Copyright 1993, 1994 by Borland International, All Rights Reserved
|
|
//
|
|
// Defines classes TDocument, TView,TWindowView, TStream,TInStream,TOutStream
|
|
//----------------------------------------------------------------------------
|
|
#if !defined(OWL_DOCVIEW_H)
|
|
#define OWL_DOCVIEW_H
|
|
|
|
#if !defined(OWL_APPLICAT_H)
|
|
# include <owl/applicat.h>
|
|
#endif
|
|
#if !defined(OWL_FRAMEWIN_H)
|
|
# include <owl/framewin.h>
|
|
#endif
|
|
#if !defined(__COMMDLG_H)
|
|
# include <commdlg.h>
|
|
#endif
|
|
class _OWLCLASS TDocManager;
|
|
class _OWLCLASS TDocTemplate;
|
|
class _OWLCLASS TMenuDescr;
|
|
|
|
//
|
|
// Some types & functions available in Win32/Ole2 that are emulated under Win16
|
|
// NOTE: This must always be in synch with Win32/Ole2 headers
|
|
//
|
|
#if defined(BI_PLAT_WIN16)
|
|
# if !defined(_FILETIME_)
|
|
struct far tagFILETIME {uint32 dwLowDateTime; uint32 dwHighDateTime;};
|
|
typedef tagFILETIME FILETIME;
|
|
# define _FILETIME_
|
|
# endif
|
|
# include <io.h>
|
|
void DateTimeToFileTime(struct date* dosd, struct time* dost, FILETIME far* pft);
|
|
bool FileTimeToDateTime(FILETIME far* pft, struct date* dosd, struct time* dost);
|
|
int FormatDateTime(struct date, struct time, void far* dest, int textlen);
|
|
#endif
|
|
int _OWLFUNC FormatFileTime(FILETIME* pft, void far* dest, int textlen);
|
|
|
|
//
|
|
// document open and sharing modes - used in storage and stream constructors
|
|
// note: the bits values are those of file streams, not same as RTL or OLE
|
|
//
|
|
enum {
|
|
ofParent = 0, // use open mode of parent storage
|
|
ofRead = 0x0001, // ios::in, open for reading
|
|
ofWrite = 0x0002, // ios::out, open for writing
|
|
ofReadWrite = (ofRead|ofWrite),
|
|
ofAtEnd = 0x0004, // ios::ate, seek to eof upon original open
|
|
ofAppend = 0x0008, // ios::app, append mode: all additions at eof
|
|
ofTruncate = 0x0010, // ios::trunc, truncate file if already exists
|
|
ofNoCreate = 0x0020, // ios::nocreate, open fails if file doesn't exist
|
|
ofNoReplace = 0x0040, // ios::noreplace, open fails if file already exists
|
|
ofBinary = 0x0080, // ios::binary, binary (not text) file, no CR stripping
|
|
ofIosMask = 0x00FF, // all of the above bits as used by class ios
|
|
|
|
ofTransacted= 0x1000, // STGM_TRANSACTED, supports commit and revert
|
|
ofPreserve = 0x2000, // STGM_CONVERT, backup old data of same name
|
|
ofPriority = 0x4000, // STGM_PRIORITY, temporary efficient peeking
|
|
ofTemporary = 0x8000, // STGM_DELETEONRELEASE, delete when destructed
|
|
|
|
shCompat = 0x0600, // for non-compliant applications, avoid if possible
|
|
shNone = 0x0800, // EXCLUSIVE functionality
|
|
shRead = 0x0A00, // DENY_WRITE functionality
|
|
shWrite = 0x0C00, // DENY_READ functionality
|
|
shReadWrite = 0x0E00, // DENY_NONE functionality
|
|
shDefault = 0, // use stream implementation default value
|
|
shMask = (shCompat|shNone|shRead|shWrite)
|
|
};
|
|
#define PREV_OPEN (ofNoCreate|ofNoReplace)
|
|
#define IS_PREV_OPEN(omode) ((omode & PREV_OPEN)==PREV_OPEN)
|
|
|
|
//
|
|
// Definitions of vnXxxx view notification event IDs
|
|
// event ID's up to vnCustomBase reserved for general doc-view notifications
|
|
//
|
|
const int vnViewOpened = 1; // a new view has just been constructed
|
|
const int vnViewClosed = 2; // another view is about to be destructed
|
|
const int vnDocOpened = 3; // document has just been opened
|
|
const int vnDocClosed = 4; // document has just been closed
|
|
const int vnCommit = 5; // document is committing, flush cached changes
|
|
const int vnRevert = 6; // document has reverted, reload data from doc
|
|
const int vnIsDirty = 7; // respond true if uncommitted changes present
|
|
const int vnIsWindow = 8; // respond true if passed HWND is that of view
|
|
const int vnCustomBase = 100; // base of document class specific notifications
|
|
|
|
//
|
|
// Document and view property access flags
|
|
//
|
|
const int pfGetText = 1; // property accessible as text format
|
|
const int pfGetBinary = 2; // property accessible as native non-text format
|
|
const int pfConstant = 4; // property is invariant for object instance
|
|
const int pfSettable = 8; // property settable as native format
|
|
const int pfUnknown = 16; // property defined but unavailable in object
|
|
const int pfHidden = 32; // property should be hidden from normal browse
|
|
const int pfUserDef =128; // property has been user-defined at run time
|
|
|
|
//
|
|
// Classes defined later in this file
|
|
//
|
|
class _OWLCLASS_RTL TStream;
|
|
class _OWLCLASS_RTL TInStream;
|
|
class _OWLCLASS_RTL TOutStream;
|
|
class _OWLCLASS TDocument;
|
|
class _OWLCLASS TView;
|
|
|
|
//
|
|
// class TDocument - abstract base class for document/view management
|
|
// ----- ---------
|
|
//
|
|
class _OWLCLASS TDocument : public TStreamableBase {
|
|
public:
|
|
enum TDocProp {
|
|
PrevProperty = 0,
|
|
DocumentClass, // text
|
|
TemplateName, // text
|
|
ViewCount, // int
|
|
StoragePath, // text
|
|
DocTitle, // text
|
|
NextProperty,
|
|
};
|
|
|
|
class _OWLCLASS List {
|
|
public:
|
|
List() : DocList(0) {}
|
|
~List() {Destroy();}
|
|
bool Insert(TDocument* doc); // insert new document, fails if there
|
|
bool Remove(TDocument* doc); // remove document, fails if not there
|
|
TDocument* Next(const TDocument* doc); // returns first if doc=0
|
|
void Destroy(); // deletes all documents
|
|
private:
|
|
TDocument* DocList;
|
|
};
|
|
|
|
void far* Tag; // application hook, not used internally
|
|
List ChildDoc; // linked child document chain
|
|
|
|
TDocument(TDocument* parent = 0);
|
|
virtual ~TDocument();
|
|
virtual TInStream* InStream(int mode, const char far* strmId=0) {return 0;}
|
|
virtual TOutStream* OutStream(int mode, const char far* strmId=0) {return 0;}
|
|
virtual bool Open(int mode, const char far* path=0) {return true;}
|
|
virtual bool Close(); // close document, does not delete or detach
|
|
virtual bool Commit(bool force=false); // save current data, force write
|
|
virtual bool Revert(bool clear=false); // abort changes, no reload if true
|
|
virtual TDocument& RootDocument();
|
|
TDocManager& GetDocManager() {return *DocManager;}
|
|
void SetDocManager(TDocManager& dm);
|
|
TDocument* GetParentDoc() {return ParentDoc;}
|
|
|
|
TDocTemplate* GetTemplate() {return Template;}
|
|
bool SetTemplate(TDocTemplate* tpl);
|
|
virtual bool SetDocPath(const char far* path);
|
|
const char far* GetDocPath() {return DocPath;}
|
|
virtual void SetTitle(const char far* title);
|
|
const char far* GetTitle() {return Title;}
|
|
virtual bool IsDirty(); // also queries doc and view hierarchy
|
|
void SetDirty(bool dirty = true){DirtyFlag = dirty;}
|
|
virtual bool IsOpen() {return StreamList != 0;}
|
|
virtual bool CanClose(); // returns false if unable to close
|
|
virtual bool HasFocus(HWND hwnd);
|
|
bool NotifyViews(int event, long item=0, TView* exclude=0);
|
|
TView* QueryViews(int event, long item=0, TView* exclude=0);
|
|
virtual uint PostError(uint sid, uint choice = MB_OK);
|
|
|
|
virtual int PropertyCount() {return NextProperty-1;}
|
|
virtual int FindProperty(const char far* name);// return property index
|
|
virtual int PropertyFlags(int index); // pfXxxxx bit array
|
|
virtual const char* PropertyName(int index); // locale invariant name
|
|
virtual int GetProperty(int index, void far* dest, int textlen=0);
|
|
virtual bool SetProperty(int index, const void far* src); // native type
|
|
TStream* NextStream(const TStream* strm);
|
|
TView* NextView(const TView* view);
|
|
int GetOpenMode();
|
|
void SetOpenMode(int mode);
|
|
TView* InitView(TView* view); // called from template InitView
|
|
bool IsEmbedded() {return Embedded;}
|
|
void SetEmbedded(bool embed) {Embedded = embed;}
|
|
virtual bool InitDoc() {return true;}
|
|
TView* GetViewList() {return ViewList;}
|
|
|
|
protected:
|
|
bool DirtyFlag; // document changed, might not represent views
|
|
bool Embedded; // document is an embedding
|
|
static int UntitledIndex;// last used index for Untitled document
|
|
virtual void AttachStream(TStream& strm);// called from TStream constructor
|
|
virtual void DetachStream(TStream& strm);// called from TStream destructor
|
|
|
|
private:
|
|
TDocManager* DocManager; // pointer back to document manager
|
|
TDocument* NextDoc; // next in linked chain of active documents
|
|
TView* ViewList; // head of linked view chain, 0 if no views
|
|
TStream* StreamList; // head of linked stream chain, 0 if no streams
|
|
int OpenMode; // mode and protection flags
|
|
char far* DocPath; // path used to open/save document
|
|
char far* Title; // current document title, 0 if untitled
|
|
TDocument* ParentDoc; // parent document, 0 if this is root document
|
|
TDocTemplate* Template; // template associated with this document
|
|
|
|
void ReindexFrames(); // force view title and index update
|
|
void AttachView(TView& view); // called from TView constructor
|
|
bool DetachView(TView& view); // called from TView destructor
|
|
TDocument(TDocManager* docMan) : // create a dummy document
|
|
ParentDoc(this), DocManager(docMan){}
|
|
|
|
|
|
DECLARE_ABSTRACT_STREAMABLE(_OWLCLASS,TDocument,1);
|
|
friend class _OWLCLASS TDocTemplate; // access to InitView()
|
|
friend class _OWLCLASS TView; // access to AttachView(), DetatchView()
|
|
friend class _OWLCLASS_RTL TStream; // access to AttachStream(), DetachStream()
|
|
friend class _OWLCLASS TDocManager;
|
|
friend class _OWLCLASS List; // access to NextDoc
|
|
};
|
|
|
|
//
|
|
// class TStream - abstract base class for storage stream access
|
|
// ----- -------
|
|
//
|
|
|
|
class _OWLCLASS_RTL TStream {
|
|
public:
|
|
TDocument& GetDocument() {return Doc;}
|
|
~TStream() {Doc.DetachStream(*this);}
|
|
int GetOpenMode();
|
|
const char far* GetStreamName();
|
|
|
|
protected:
|
|
TDocument& Doc; // document owning this stream
|
|
TStream* NextStream; // next stream in linked list of active streams
|
|
|
|
TStream(TDocument& doc, const char far* name, int mode)
|
|
: Doc(doc), StreamName(name), OpenMode(mode)
|
|
{Doc.AttachStream(*this);}
|
|
|
|
private:
|
|
int OpenMode;
|
|
const char far* StreamName;
|
|
|
|
friend class TDocument;
|
|
};
|
|
|
|
//
|
|
// class TInStream - base class for input streams
|
|
// ----- ---------
|
|
//
|
|
class _OWLCLASS_RTL TInStream : public TStream, public istream {
|
|
public:
|
|
TInStream(TDocument& doc, const char far* name, int mode)
|
|
: TStream(doc, name, mode), istream() {}
|
|
};
|
|
|
|
//
|
|
// class TOutStream - base class for output streams
|
|
// ----- ---------
|
|
//
|
|
class _OWLCLASS_RTL TOutStream : public TStream, public ostream {
|
|
public:
|
|
TOutStream(TDocument& doc, const char far* name, int mode)
|
|
: TStream(doc, name, mode), ostream() {}
|
|
};
|
|
|
|
//
|
|
// class TView - abstract base class for view access from document
|
|
// ----- -----
|
|
//
|
|
class _OWLCLASS TView : virtual public TEventHandler,
|
|
virtual public TStreamableBase {
|
|
public:
|
|
enum {
|
|
PrevProperty = 0,
|
|
ViewClass, // text
|
|
ViewName, // text
|
|
NextProperty,
|
|
};
|
|
void far* Tag; // application hook, not used internally
|
|
|
|
TView(TDocument& doc);
|
|
virtual ~TView();
|
|
TDocument& GetDocument() {return *Doc;}
|
|
unsigned GetViewId() {return ViewId;}
|
|
virtual TMenuDescr* GetViewMenu() {return ViewMenu;}
|
|
void SetViewMenu(TMenuDescr* menu);
|
|
bool IsOK() {return ViewId != 0;} // true if successfully created
|
|
static unsigned GetNextViewId() {return NextViewId;} // next ID to assign
|
|
TView* GetNextView() {return NextView;}
|
|
|
|
// must implement, used by template manager for selection
|
|
// static const char far* StaticName() {return "name of view";}
|
|
virtual const char far* GetViewName()=0; // return static name of view
|
|
|
|
virtual TWindow* GetWindow() {return 0;} // if not derived from TWindow
|
|
virtual bool SetDocTitle(const char far* docname, int index) {return false;}
|
|
|
|
virtual int PropertyCount() {return NextProperty - 1;}
|
|
virtual int FindProperty(const char far* name);// return property index
|
|
virtual int PropertyFlags(int index); // pfXxxxx bit array
|
|
virtual const char* PropertyName(int index); // locale invariant name
|
|
virtual int GetProperty(int index, void far* dest, int textlen=0);
|
|
virtual bool SetProperty(int index, const void far* src) {return false;}
|
|
|
|
protected:
|
|
TDocument* Doc;
|
|
void NotOK() {ViewId = 0;} // to flag errors in creation
|
|
|
|
private:
|
|
TView* NextView; // linked view chain, 0 if no more views
|
|
unsigned ViewId; // unique ID for this view, used for controls
|
|
TMenuDescr* ViewMenu; // menu descriptor specific for this view or 0
|
|
static unsigned NextViewId; // next view ID to be assigned
|
|
|
|
DECLARE_ABSTRACT_STREAMABLE(_OWLCLASS,TView,1);
|
|
friend class _OWLCLASS TDocument; // needs access to NextView
|
|
friend class TDocument::Streamer; // needs access to NextView
|
|
};
|
|
|
|
//
|
|
// class TWindowView
|
|
// ----- -----------
|
|
//
|
|
class _OWLCLASS TWindowView : public TWindow, public TView {
|
|
public:
|
|
TWindowView(TDocument& doc, TWindow* parent = 0);
|
|
~TWindowView() {}
|
|
static const char far* StaticName() {return "Window View";} // put in resource
|
|
|
|
// inherited virtuals from TWindow
|
|
//
|
|
bool CanClose() {return TWindow::CanClose() && Doc->CanClose();}
|
|
|
|
// inherited virtuals from TView
|
|
//
|
|
const char far* GetViewName() {return StaticName();}
|
|
TWindow* GetWindow() {return (TWindow*)this;}
|
|
bool SetDocTitle(const char far* docname, int index)
|
|
{ return TWindow::SetDocTitle(docname, index); }
|
|
private:
|
|
// event handlers
|
|
//
|
|
bool VnIsWindow(HWND hWnd);
|
|
|
|
DECLARE_RESPONSE_TABLE(TWindowView);
|
|
DECLARE_STREAMABLE (_OWLCLASS, TWindowView,1);
|
|
};
|
|
|
|
//----------------------------------------------------------------------------
|
|
// View Notification Handler Definitions
|
|
//
|
|
|
|
//
|
|
// DocView aliases to actual dispatchers
|
|
//
|
|
#define U_void_Dispatch U_Dispatch
|
|
#define U_int_Dispatch U_U_Dispatch
|
|
#define U_pointer_Dispatch U_POINTER_Dispatch
|
|
#define U_long_Dispatch U_LPARAM_Dispatch
|
|
|
|
//
|
|
// Define a DocView notification signature
|
|
// 'id' is the vnXxxXxx name of the notification
|
|
// 'arg' is the type of the arg passed to the handler
|
|
//
|
|
#define NOTIFY_SIG(id, arg) \
|
|
template <class T> \
|
|
inline bool (T::*id##_Sig(bool (T::*pmf)(arg)))(arg) {return pmf;}
|
|
|
|
NOTIFY_SIG(vnViewOpened,TView*)
|
|
NOTIFY_SIG(vnViewClosed,TView*)
|
|
NOTIFY_SIG(vnDocOpened, int)
|
|
NOTIFY_SIG(vnDocClosed, int)
|
|
NOTIFY_SIG(vnCommit, bool)
|
|
NOTIFY_SIG(vnRevert, bool)
|
|
NOTIFY_SIG(vnIsDirty, void)
|
|
NOTIFY_SIG(vnIsWindow, HWND)
|
|
|
|
//
|
|
// Define a DocView notification response entry
|
|
// 'id' is the id from NOTIFY_SIG above
|
|
// 'method' is the method name called by the notification
|
|
// 'disp' is the type of the lParam dispacher to use, and can be:
|
|
// 'void' lParam not passed
|
|
// 'int' integer size (16bit for win16, or 32bit on win32)
|
|
// 'pointer' pointer size (16bit for small & medium, or 32bit all other)
|
|
// 'long' 32 bit passed always
|
|
//
|
|
#define VN_DEFINE(id, method, disp) \
|
|
{WM_OWLNOTIFY, id, \
|
|
(TAnyDispatcher) ::U_##disp##_Dispatch, \
|
|
(TMyPMF)id##_Sig(&TMyClass::method)}
|
|
|
|
#define EV_VN_VIEWOPENED VN_DEFINE(vnViewOpened, VnViewOpened, pointer)
|
|
#define EV_VN_VIEWCLOSED VN_DEFINE(vnViewClosed, VnViewClosed, pointer)
|
|
#define EV_VN_DOCOPENED VN_DEFINE(vnDocOpened, VnDocOpened, int)
|
|
#define EV_VN_DOCCLOSED VN_DEFINE(vnDocClosed, VnDocClosed, int)
|
|
#define EV_VN_COMMIT VN_DEFINE(vnCommit, VnCommit, int)
|
|
#define EV_VN_REVERT VN_DEFINE(vnRevert, VnRevert, int)
|
|
#define EV_VN_ISDIRTY VN_DEFINE(vnIsDirty, VnIsDirty, void)
|
|
#define EV_VN_ISWINDOW VN_DEFINE(vnIsWindow, VnIsWindow, int)
|
|
|
|
//----------------------------------------------------------------------------
|
|
// inline implementations
|
|
//
|
|
|
|
inline int
|
|
TDocument::GetOpenMode()
|
|
{
|
|
return OpenMode;
|
|
}
|
|
|
|
inline void
|
|
TDocument::SetOpenMode(int mode)
|
|
{
|
|
OpenMode = mode;
|
|
}
|
|
|
|
inline const char far*
|
|
TStream::GetStreamName()
|
|
{
|
|
return StreamName;
|
|
}
|
|
|
|
inline int
|
|
TStream::GetOpenMode()
|
|
{
|
|
return OpenMode;
|
|
}
|
|
|
|
#endif // OWL_DOCVIEW_H
|