home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Black Box 4
/
BlackBox.cdr
/
w3_prog
/
ddjwin.arj
/
CPP.ASC
< prev
next >
Wrap
Text File
|
1991-11-14
|
15KB
|
534 lines
_WINDOWS MEETS C++_
by Scott Robert Ladd
[LISTING ONE]
// WINDOWS CLASSES
// winclass.h -- Class definitions for Windows programming
// Copyright 1991 by Scott Robert Ladd. All Rights Reserved.
#if !defined(__WINCLASS_H)
#define __WINCLASS_H
#include "windows.h"
// macro resolving to size of this pointer
#define SIZEOF_THIS (sizeof(void *))
// macro resolving to number of extra bytes required by this window
#define PTR_BYTES (SIZEOF_THIS)
// macros used to store and extract class pointer from extra window bytes
#if sizeof(void *) == 4
#define SetWindowPtr(wdw,ptr) SetWindowLong((wdw),0,(DWORD)(ptr))
#define GetWindowPtr(wdw) (Window *)GetWindowLong(wdw,0)
#else
#define SetWindowPtr(wdw,ptr) SetWindowWord((wdw),0,(WORD)(ptr))
#define GetWindowPtr(wdw) (Window *)GetWindowWord(wdw,0)
#endif
// callback function types
typedef long (_far _pascal * WinCallBack)(HWND,WORD,WORD,DWORD);
typedef int (_far _pascal * DlgCallBack)(HWND,WORD,WORD,DWORD);
//------------- CLASS WinApp -------------
class WinApp
{
public:
static int Dispatcher();
static void SetInstance(HANDLE inst);
static HANDLE GetInstance();
private:
static HANDLE Instance;
};
// set instance handle
inline void WinApp::SetInstance(HANDLE inst)
{
if (Instance == NULL)
Instance = inst;
}
// get instance handle
inline HANDLE WinApp::GetInstance()
{
return Instance;
}
//------------------ CLASS WindowClass ------------------
class WindowClass : public WinApp
{
public:
WindowClass(); // constructor
BOOL Register(); // register
BOOL Unregister(); // unregister
const char * GetName() const; // get class name string
protected:
WNDCLASS ClassData;
};
//------------------ CLASS BasicWindow ------------------
class BasicWindow : private WinApp
{
public:
HWND GetHandle() const;
HANDLE GetInstance() const;
DWORD GetStyle() const;
void Show(int cmdShow = SW_SHOW);
void Update();
void SetText(char * text);
void GetText(char * buffer, int n) const;
void Disable();
void Enable();
void GetExtents(int * x, int * y, int * width, int * height) const;
void Move(int x, int y, int width, int height);
protected:
BasicWindow(const char * cname);
HWND Handle;
HANDLE Instance;
DWORD Style;
char ClassName[32];
};
inline HWND BasicWindow::GetHandle() const
{
return Handle;
}
inline HANDLE BasicWindow::GetInstance() const
{
return Instance;
}
inline DWORD BasicWindow::GetStyle() const
{
return Style;
}
inline void BasicWindow::Show(int cmdShow)
{
ShowWindow(Handle,cmdShow);
}
inline void BasicWindow::Update()
{
UpdateWindow(Handle);
}
inline void BasicWindow::SetText(char * text)
{
SetWindowText(Handle,text);
}
inline void BasicWindow::GetText(char * buffer, int n) const
{
GetWindowText(Handle,buffer,n);
}
inline void BasicWindow::Disable()
{
EnableWindow(Handle,FALSE);
}
inline void BasicWindow::Enable()
{
EnableWindow(Handle,TRUE);
}
inline void BasicWindow::GetExtents(int * x, int * y, int * width,
int * height) const
{
RECT r;
GetWindowRect(Handle,&r);
*x = r.left;
*y = r.top;
*width = r.right - r.left + 1;
*height = r.bottom - r.top + 1;
}
inline void BasicWindow::Move(int x, int y, int width, int height)
{
MoveWindow(Handle,x,y,width,height,TRUE);
}
//------------- CLASS Window -------------
class Window : public BasicWindow
{
public:
Window(const char * cname);
BOOL Actualize(const char * title,
int x = CW_USEDEFAULT,
int y = CW_USEDEFAULT,
int width = CW_USEDEFAULT,
int height = CW_USEDEFAULT);
HDC OpenDC();
void CloseDC(HDC dc);
protected:
virtual void Create(HWND wdw, CREATESTRUCT _far * cs);
virtual void Close(HWND wdw);
virtual void Paint(HDC dc);
virtual void Command(HWND wdw, WORD wParam, DWORD lParam);
virtual long AuxMsgHandler(HWND wdw, WORD message,
WORD wParam, DWORD lParam);
private:
static long _far _pascal _export MessageHandler(HWND wdw,
WORD message, WORD wParam, DWORD lParam);
};
inline HDC Window::OpenDC()
{
return GetDC(Handle);
}
inline void Window::CloseDC(HDC dc)
{
ReleaseDC(Handle,dc);
}
//-------------- CLASS Control --------------
class Control : public BasicWindow
{
public:
BOOL Actualize(const Window & parent, const char * text, WORD id,
int x, int y, int width, int height);
WORD GetID() const;
WinCallBack SubClass(WinCallBack newHandler);
protected:
Control(const char * cname);
};
inline WORD Control::GetID() const
{
return GetWindowWord(Handle,GWW_ID);
}
inline WinCallBack Control::SubClass(WinCallBack newHandler)
{
return (WinCallBack)SetWindowLong(Handle,GWL_WNDPROC,(DWORD)newHandler);
}
inline Control::Control(const char * cname) : BasicWindow(cname)
{
// does nothing else
}
//----------------- CLASS StaticLeft -----------------
class StaticLeft : public Control
{
public:
StaticLeft();
};
//----------------- CLASS PushButton -----------------
class PushButton : public Control
{
public:
PushButton();
};
#endif // __WINCLASS_H
[LISTING TWO]
// WINDOWS CLASSES
// winclass.cpp -- Windows class implementations.
// Copyright 1991 by Scott Robert Ladd. All Rights Reserved.
#include "winclass.h"
#include "string.h"
//------------- CLASS WinApp -------------
// define values for static member of WinApp class
HANDLE WinApp::Instance = NULL;
// message dispatcher
int WinApp::Dispatcher()
{
if (Instance == NULL)
return !0;
MSG msg;
while (GetMessage(&msg, NULL, NULL, NULL))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return msg.wParam;
}
//------------------ CLASS WindowClass ------------------
WindowClass::WindowClass()
{
#if defined(__BCPLUSPLUS__)
ClassData.lpfnWndProc = DefWindowProc;
#else
ClassData.lpfnWndProc = (long (_far _pascal *)())DefWindowProc;
#endif
ClassData.hInstance = WinApp::GetInstance();
ClassData.style = 0;
ClassData.cbClsExtra = 0;
ClassData.cbWndExtra = PTR_BYTES;
ClassData.hIcon = NULL;
ClassData.hCursor = LoadCursor(NULL,IDC_ARROW);
ClassData.hbrBackground = GetStockObject(WHITE_BRUSH);
ClassData.lpszMenuName = NULL;
ClassData.lpszClassName = "DefaultWindowClass";
}
BOOL WindowClass::Register()
{
if (!RegisterClass((WNDCLASS _far *)&ClassData))
return FALSE;
else
return TRUE;
}
BOOL WindowClass::Unregister()
{
if (!UnregisterClass(ClassData.lpszClassName,ClassData.hInstance))
return FALSE;
else
return TRUE;
}
const char * WindowClass::GetName() const
{
return (const char *)ClassData.lpszClassName;
}
//------------------ CLASS BasicWindow ------------------
BasicWindow::BasicWindow(const char * cname)
{
Handle = NULL;
Instance = WinApp::GetInstance();
Style = 0UL;
if (cname != NULL)
strncpy(ClassName,cname,32);
else
ClassName[0] = 0; // blank class name
}
//------------- CLASS Window -------------
Window::Window(const char * cname) : BasicWindow(cname)
{
Style = WS_OVERLAPPEDWINDOW;
}
BOOL Window::Actualize(const char * title, int x, int y, int width, int height)
{
Handle = CreateWindow(ClassName, (char *)title, Style, x, y,
width, height, NULL, NULL, Instance, 0L);
if (Handle == NULL)
return FALSE;
FARPROC fp = MakeProcInstance((FARPROC)((DWORD)(Window::MessageHandler)),
Instance);
SetWindowLong(Handle,GWL_WNDPROC,(DWORD)fp);
SetWindowPtr(Handle,this);
SendMessage(Handle,WM_CREATE,0,0L);
return TRUE;
}
void Window::Create(HWND wdw, CREATESTRUCT _far * cs)
{
// by default, does NOTHING!
}
void Window::Close(HWND wdw)
{
// by default, does NOTHING!
}
void Window::Paint(HDC dc)
{
// by default, does NOTHING!
}
void Window::Command(HWND wdw, WORD wParam, DWORD lParam)
{
// by default, does NOTHING!
}
long Window::AuxMsgHandler(HWND wdw, WORD message, WORD wParam, DWORD lParam)
{
return DefWindowProc(wdw,message,wParam,lParam);
}
long _far _pascal _export Window::MessageHandler(HWND wdw, WORD message,
WORD wParam, DWORD lParam)
{
HDC dc;
PAINTSTRUCT ps;
Window * wptr;
wptr = GetWindowPtr(wdw);
switch (message)
{
case WM_CREATE:
wptr->Create(wdw, (CREATESTRUCT _far *)lParam);
break;
case WM_CLOSE:
wptr->Close(wdw);
break;
case WM_PAINT:
dc = BeginPaint(wdw,&ps);
wptr->Paint(dc);
EndPaint(wdw,&ps);
break;
case WM_COMMAND:
wptr->Command(wdw,wParam,lParam);
break;
default:
return wptr->AuxMsgHandler(wdw,message,wParam,lParam);
}
return 0L;
}
//-------------- CLASS Control --------------
BOOL Control::Actualize(const Window & parent, const char * text, WORD id,
int x, int y, int width, int height)
{
Handle = CreateWindow(ClassName, (char *)text, Style, x,y,width,height,
parent.GetHandle(), id, parent.GetInstance(), 0L);
if (Handle == NULL)
return FALSE;
return TRUE;
}
//----------------- CLASS StaticLeft -----------------
StaticLeft::StaticLeft() : Control("STATIC")
{
Style = WS_CHILD | SS_LEFT | SS_NOPREFIX | WS_BORDER;
}
//----------------- CLASS PushButton -----------------
PushButton::PushButton() : Control("BUTTON")
{
Style = WS_CHILD | BS_PUSHBUTTON;
}
[LISTING THREE]
// WINDOWS CLASSES
// woop.cpp -- A program to test basic windows classes.
// Copyright 1991 by Scott Robert Ladd. All Rights Reserved.
#include "winclass.h"
#include "woop.h"
#define IDC_BUTTON 1000
//---------------------- CLASS MainWindowClass ----------------------
class WOOPWindowClass : public WindowClass
{
public:
WOOPWindowClass();
};
WOOPWindowClass::WOOPWindowClass() : WindowClass()
{
ClassData.hIcon = LoadIcon(WinApp::GetInstance(),"WOOPIcon");
ClassData.hbrBackground = GetStockObject(LTGRAY_BRUSH);
ClassData.lpszMenuName = "WOOPMenu";
ClassData.lpszClassName = "MainWindowClass";
}
//----------------- CLASS WOOPWindow -----------------
class WOOPWindow : public Window
{
public:
WOOPWindow(const char * cname);
virtual BOOL Actualize();
protected:
virtual void Close(HWND wdw);
virtual void Command(HWND wdw, WORD wParam, DWORD lParam);
StaticLeft SCtl;
PushButton BCtl;
};
WOOPWindow::WOOPWindow(const char * cname) : Window(cname)
{
}
BOOL WOOPWindow::Actualize()
{
BOOL res;
res = Window::Actualize("WOOP Window"); // call base class member
if (res == FALSE)
return FALSE;
res = SCtl.Actualize(*this,"Static control",0,100,10,120,16);
if (res == FALSE)
return FALSE;
SCtl.Show();
SCtl.Update();
res = BCtl.Actualize(*this,"Button",IDC_BUTTON,100,50,60,40);
if (res == FALSE)
return FALSE;
BCtl.Show();
BCtl.Update();
return TRUE;
}
void WOOPWindow::Close(HWND wdw)
{
PostQuitMessage(0);
}
void WOOPWindow::Command(HWND wdw, WORD wParam, DWORD lParam)
{
switch (wParam)
{
case IDM_EXIT:
PostQuitMessage(0);
break;
case IDM_ABOUT:
MessageBox(GetFocus(),"WOOP version 1.00","About...",MB_OK);
break;
case IDM_SET:
SCtl.SetText("Set!");
break;
case IDM_RESET:
SCtl.SetText("Reset!");
break;
case IDC_BUTTON:
MessageBeep(0);
MessageBeep(0);
}
}
//----------------- FUNCTION WinMain -----------------
int _pascal WinMain(HANDLE instance,HANDLE prevInst,LPSTR cmdLine,int cmdShow)
{
WinApp::SetInstance(instance);
WOOPWindowClass wc;
if (prevInst == NULL)
wc.Register();
WOOPWindow wdw(wc.GetName());
wdw.Actualize();
wdw.Show(cmdShow);
wdw.Update();
return WinApp::Dispatcher();
};
[LISTING FOUR]
#include "windows.h"
#include "woop.h"
WOOPIcon ICON WOOP.ICO
WOOPMenu MENU
BEGIN
POPUP "&Menu"
BEGIN
MENUITEM "Set", IDM_SET
MENUITEM "Reset", IDM_RESET
MENUITEM SEPARATOR
MENUITEM "&About...", IDM_ABOUT
MENUITEM SEPARATOR
MENUITEM "E&xit", IDM_EXIT
END
END
[LISTING FIVE]
#define IDM_SET 100
#define IDM_RESET 101
#define IDM_ABOUT 102
#define IDM_EXIT 103
[LISTING SIX]
NAME OOPAPP
DESCRIPTION 'OPP Windows App'
EXETYPE WINDOWS
STUB 'WINSTUB.EXE'
CODE PRELOAD MOVEABLE DISCARDABLE
DATA PRELOAD MOVEABLE MULTIPLE
HEAPSIZE 4096
STACKSIZE 4096
[MAKE FILE]
windows = y
woop.exe : woop.obj winclass.obj woop.res woop.def
woop.obj : woop.cpp winclass.h woop.h
winclass.obj : winclass.cpp winclass.h
woop.res : woop.rc woop.h woop.ico