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>
265 lines
9.9 KiB
C++
265 lines
9.9 KiB
C++
#if !defined( __TODOWIN_H )
|
|
#define __TODOWIN_H
|
|
|
|
//---------------------------------------------------------------------
|
|
//
|
|
// TODOWIN.H
|
|
//
|
|
// Copyright (c) 1991, 1993 by Borland International
|
|
// All Rights Reserved.
|
|
//
|
|
// Defines the following classes, which are useful for building
|
|
// general purpose windows applications:
|
|
//
|
|
// WinBase - provides basic data and functionality for
|
|
// windows programming.
|
|
//
|
|
// ModalDialog - provides for modal dialog boxes. Inherits from
|
|
// WinBase, which is a virtual base.
|
|
//
|
|
// Window - provides core functionality for a window under Windows.
|
|
// Inherits from WinBase, which is a virtual base.
|
|
//
|
|
//---------------------------------------------------------------------
|
|
|
|
#if !defined( STRICT )
|
|
#define STRICT
|
|
#endif
|
|
|
|
#include <windows.h>
|
|
#include <except.h>
|
|
#include <checks.h>
|
|
#include <cstring.h>
|
|
|
|
class FileError : public xmsg
|
|
{
|
|
|
|
public:
|
|
|
|
FileError( const char *fileName ) :
|
|
xmsg( string("File error in ") + fileName ) {}
|
|
|
|
};
|
|
|
|
//---------------------------------------------------------------------
|
|
//
|
|
// class WinBase
|
|
//
|
|
// provides the basic data and functionality for all classes
|
|
// used in the windows application. It is an abstract base class.
|
|
//
|
|
//---------------------------------------------------------------------
|
|
|
|
class WinBase
|
|
{
|
|
|
|
public:
|
|
|
|
virtual UINT Run() = 0; // the core function of all windows! For
|
|
// the main application window, this
|
|
// provides the message loop. In modal
|
|
// dialogs, it sets up the dialog box,
|
|
// calls the dialog proc, and closes down
|
|
// the dialog.
|
|
|
|
|
|
|
|
static HINSTANCE hInst; // the handle of the current instance
|
|
|
|
static HINSTANCE hPrevInst;// the handle of the previous instance
|
|
|
|
static LPSTR Cmd; // pointer to the command line
|
|
|
|
static int Show; // the nCmdShow parameter of the current
|
|
// instance
|
|
|
|
HWND hWnd(); // access function
|
|
|
|
protected:
|
|
|
|
HWND hWindow; // the window handle of the class. This is
|
|
// accessed through hWnd(), and it will
|
|
// provide the correct handle for any
|
|
// derived class.
|
|
|
|
// NOTE: this field is not initialized by
|
|
// the constructor of this class. It must
|
|
// be initialized by the constructor of a
|
|
// class derived from this class.
|
|
|
|
};
|
|
|
|
//---------------------------------------------------------------------
|
|
//
|
|
// class ModalDialog
|
|
//
|
|
// provides basic functionality for modal dialog boxes. It is an
|
|
// abstract base class.
|
|
//
|
|
//---------------------------------------------------------------------
|
|
|
|
class ModalDialog : public virtual WinBase
|
|
{
|
|
|
|
public:
|
|
|
|
ModalDialog( HWND ); // constructor. Since a modal dialog
|
|
// needs to know its owner, the handle
|
|
// of the owner is passed as a parameter
|
|
// to the constructor.
|
|
|
|
~ModalDialog();
|
|
|
|
virtual UINT Run(); // the core of a modal dialog. It sets
|
|
// up the dialog, executes it, and closes
|
|
// it down.
|
|
|
|
protected:
|
|
|
|
virtual BOOL Dispatch( HWND, UINT, WPARAM, LPARAM );
|
|
// the core of any window. Whenever
|
|
// DlgProc receives a message it passes
|
|
// the message on to Dispatch(). If
|
|
// Dispatch() doesn't handle the message
|
|
// itself, it should call the Dispatch()
|
|
// function in its base class. Ultimately,
|
|
// messages not handled higher up are
|
|
// handled by this version of Dispatch(),
|
|
// which just returns FALSE, indicating
|
|
// that the message wasn't handled by
|
|
// the dialog box at all.
|
|
|
|
UINT Result; // this holds the value which will be
|
|
// returned by Run(). If the dialog box
|
|
// needs to return a success code, that
|
|
// code should be stored here by the
|
|
// dialog handler.
|
|
|
|
private:
|
|
|
|
virtual LPSTR GetDialogName() = 0;
|
|
// returns a far pointer to a string
|
|
// that contains the name of the dialog
|
|
// resource for the current dialog box.
|
|
// This is used in Run() to load the
|
|
// resource.
|
|
|
|
static BOOL CALLBACK _export DlgProc( HWND, UINT, WPARAM, LPARAM );
|
|
// the dialog proc that windows calls
|
|
// when it has messages for the current
|
|
// dialog.
|
|
|
|
static ModalDialog *CurDlg;
|
|
// this holds a pointer to the currenly
|
|
// active ModalDialog. It is set up when
|
|
// the constructor is called, and is used
|
|
// by DlgProc() to route messages to the
|
|
// right Dispatch() function.
|
|
|
|
};
|
|
|
|
//---------------------------------------------------------------------
|
|
//
|
|
// class Window
|
|
//
|
|
// provides the basic functionality for a normal window under
|
|
// windows.
|
|
//
|
|
//---------------------------------------------------------------------
|
|
|
|
class Window : public virtual WinBase
|
|
{
|
|
|
|
public:
|
|
|
|
virtual BOOL Create(); // creates the window. This involves
|
|
// registering the window class if
|
|
// it hasn't already been registered,
|
|
// creating the actual window, and
|
|
// inserting the window into the internal
|
|
// window list.
|
|
|
|
virtual UINT Run(); // provides the message loop.
|
|
|
|
protected:
|
|
|
|
virtual LONG Dispatch( UINT, WPARAM, LPARAM );
|
|
// dispatches messages in a class derived
|
|
// from Window. When WndProc() receives
|
|
// a message, it determines which Window
|
|
// object the message should be routed
|
|
// to, and calls Dispatch() for that object.
|
|
// If the Dispatch() function in a derived
|
|
// class does not handle any particular
|
|
// message, it should pass that message
|
|
// on down to the Dispatch() function in
|
|
// its base class. The version of Dispatch()
|
|
// in Window itself just calls DefWindowProc.
|
|
|
|
virtual BOOL RegisterClass() = 0;
|
|
// the derived class should override this
|
|
// function and register a window class
|
|
// defined appropriately for the program.
|
|
|
|
virtual BOOL CreateNewWindow() = 0;
|
|
// the derived class should override this
|
|
// function and create a window that's
|
|
// appropriate for the program.
|
|
|
|
static LRESULT CALLBACK _export WndProc( HWND, UINT, WPARAM, LPARAM );
|
|
// the window proc that windows calls
|
|
// when it has messages for any window
|
|
// in the current application. WndProc()
|
|
// posts the message to the appropriate
|
|
// window.
|
|
|
|
void Insert(); // should be called from CreateNewWindow()
|
|
// after successfully calling the windows
|
|
// function CreateWindow(). Insert() adds
|
|
// the current object to the Window list,
|
|
// enabling normal dispatching of messages
|
|
// to the current object.
|
|
|
|
private:
|
|
|
|
static Window *WinList; // have to maintain a list of Windows so
|
|
Window *NextWin; // that we can dispatch messages to the
|
|
// correct one.
|
|
|
|
static Window *InCreate; // sort-of kludgy. But there are messages
|
|
// that are sent to a window during the
|
|
// call to CreateWindow(). We assume that
|
|
// any message received by WndProc() during
|
|
// a call to CreateWindow() is meant for
|
|
// the window being created, and dispatch
|
|
// those messages to that window.
|
|
|
|
};
|
|
|
|
inline HWND WinBase::hWnd()
|
|
{
|
|
return hWindow;
|
|
}
|
|
|
|
inline ModalDialog::ModalDialog( HWND hOwner ) : Result( 0 )
|
|
{
|
|
CHECK( CurDlg == 0 );
|
|
CurDlg = this;
|
|
hWindow = hOwner;
|
|
}
|
|
|
|
inline ModalDialog::~ModalDialog()
|
|
{
|
|
CHECK( CurDlg != 0 );
|
|
CurDlg = 0;
|
|
}
|
|
|
|
inline void Window::Insert()
|
|
{
|
|
NextWin = WinList;
|
|
WinList = this;
|
|
}
|
|
|
|
#endif // __TODOWIN_H
|
|
|