static MRESULT APIENTRY Destroy ( HWND Window, MESG, MPARAM1, MPARAM2 ) {
/**************************************************************************
* Find the instance data. *
**************************************************************************/
PDATA Data = PDATA ( Sys_GetWindowData ( Window ) ) ;
/**************************************************************************
* Discard the pointers. *
**************************************************************************/
WinDestroyPointer ( Data->MarginPtr ) ;
WinDestroyPointer ( Data->TabstopPtr ) ;
/**************************************************************************
* Destroy the device context object for the window. *
**************************************************************************/
delete Data->pDevice ;
/**************************************************************************
* Release the instance data. *
**************************************************************************/
free ( Data ) ;
/**************************************************************************
* We're done. *
**************************************************************************/
return ( MRFROMSHORT ( 0 ) ) ;
}
extern MRESULT APIENTRY HelpIndex
(
HWND hwnd,
ULONG msg,
MPARAM mp1,
MPARAM mp2
)
{
/***************************************************************************
* Get the help instance window handle, if any. *
***************************************************************************/
HWND hwndHelp = WinQueryHelpInstance ( hwnd ) ;
/***************************************************************************
* If help is available, pass the request on to the help window. *
***************************************************************************/
if ( hwndHelp )
{
WinSendMsg ( hwndHelp, HM_HELP_INDEX, 0L, 0L ) ;
}
/***************************************************************************
* Done. *
***************************************************************************/
return ( MRFROMSHORT ( 0 ) ) ;
}
MRESULT EXPENTRY
NewFrameProc( HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2 )
{
PFNWP oldFrameProc ;
/* ------- get original frame procedure --------- */
oldFrameProc = (PFNWP) WinQueryWindowULong( hwnd, QWL_USER );
switch (msg) {
case WM_QUERYFRAMECTLCOUNT :
{
USHORT itemCount ;
/* ---- get count of original frame controls --- */
itemCount = SHORT1FROMMR( oldFrameProc( hwnd, msg, mp1, mp2 ));
/* ------- add 1 for new toolbar control ------ */
return ( (MRESULT) ++itemCount );
}
case WM_FORMATFRAME :
{
PSWP pSWP ;
PRECTL pFrameRect ;
USHORT itemCount ;
pFrameRect = PVOIDFROMMP( mp2 );
pSWP = PVOIDFROMMP( mp1 );
/* ---- run regular processing on original controls --- */
itemCount = SHORT1FROMMR( oldFrameProc( hwnd, msg, mp1, mp2 ));
/* ---- get size values for 2nd menu bar -------- */
pSWP[ itemCount ].fl = SWP_SIZE;
pSWP[ itemCount ].cy = pSWP[(itemCount-1)].cy ; /* set some */
pSWP[ itemCount ].cx = pSWP[(itemCount-1)].cx ; /* defaults */
pSWP[ itemCount ].hwndInsertBehind = HWND_TOP ;
pSWP[ itemCount ].hwnd = hwndMenuBar ;
WinSendMsg( hwndMenuBar, /* let the menu code make */
WM_ADJUSTWINDOWPOS, /* the actual size */
MPFROMP( pSWP+itemCount ), /* adjustments */
(MPARAM) 0L );
/* ------ position menu directly below other menu ------- */
pSWP[itemCount].x = pSWP[(itemCount-2)].x ;
pSWP[itemCount].y = pSWP[(itemCount-2)].y - pSWP[itemCount].cy ;
pSWP[itemCount].fl = pSWP[(itemCount-2)].fl ;
/* -------- adjust client window size for 2nd menu ------- */
pSWP[(itemCount-1)].cy -= pSWP[itemCount].cy ;
/* -------- return total count of frame controls ------- */
return( MRFROMSHORT( ++itemCount ) );
}
break;
default:
return oldFrameProc(hwnd,msg,mp1,mp2);
} /* end of switch () */
return( FALSE );
} /* end of NewFrameProc */
static MRESULT APIENTRY InitDlg ( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 ) {
/***************************************************************************
* Get parameters from initialization message. *
***************************************************************************/
PPROFILE_PARMS Parms = (PPROFILE_PARMS) ( PVOIDFROMMP ( mp2 ) ) ;
WinSetWindowPtr ( hwnd, QWL_USER, Parms ) ;
/***************************************************************************
* Set the dialog help instance. *
***************************************************************************/
WinSetWindowUShort ( hwnd, QWS_ID, Parms->id ) ;
if ( Parms->hwndHelp ) {
WinAssociateHelpInstance ( Parms->hwndHelp, hwnd ) ;
}
/***************************************************************************
* Set the entry field contents. *
***************************************************************************/
WinSetDlgItemText ( hwnd, Parms->id+ENTRY, Parms->Path ) ;
/***************************************************************************
* Return no error. *
***************************************************************************/
return ( MRFROMSHORT ( FALSE ) ) ;
}
/*---------------------------------------------------------------------------
FindWndProc
---------------------------------------------------------------------------*/
MRESULT EXPENTRY FindWndProc( HWND wnd, ULONG msg, MPARAM mp1, MPARAM mp2 )
{
MRESULT MRes;
HWND entryfield;
switch (msg) {
case WM_INITDLG:
PositionDialog( wnd );
entryfield = WinWindowFromID( wnd, ID_FINDENTRY );
WinSendMsg( entryfield, EM_SETTEXTLIMIT,
MPFROMSHORT( sizeof FindDat.text - 1 ), 0 );
WinSetDlgItemText( wnd, ID_FINDENTRY, FindDat.text );
WinSendMsg( entryfield, EM_SETSEL,
MPFROM2SHORT( 0, sizeof FindDat.text ), 0 );
MRes = MRFROMSHORT( FALSE );
break;
case WM_CHAR:
if (SHORT2FROMMP( mp2 ) == VK_NEWLINE) {
WinQueryDlgItemText( wnd,
ID_FINDENTRY,
sizeof FindDat.text - 1,
FindDat.text );
FindDat.sense = WinQueryButtonCheckstate( wnd, ID_FINDCHECK );
WinDismissDlg( wnd, 0 );
}
default:
MRes = WinDefDlgProc( wnd, msg, mp1, mp2 );
break;
}
return MRes;
}
MRESULT EXPENTRY ClientWndProc (HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
static CHAR *szMenuText [3] = { NULL,
"A~bout PoorMenu...",
"~Help..." } ;
static MENUITEM mi [3] = {
MIT_END, MIS_SEPARATOR, 0, 0, 0, 0,
MIT_END, MIS_TEXT, 0, IDM_ABOUT, 0, 0,
MIT_END, MIS_TEXT, 0, IDM_HELP, 0, 0
} ;
HWND hwndSysMenu, hwndSysSubMenu ;
INT iItem, idSysMenu ;
MENUITEM miSysMenu ;
switch (msg)
{
case WM_CREATE:
hwndSysMenu = WinWindowFromID (
WinQueryWindow (hwnd, QW_PARENT),
FID_SYSMENU) ;
idSysMenu = SHORT1FROMMR (WinSendMsg (hwndSysMenu,
MM_ITEMIDFROMPOSITION,
NULL, NULL)) ;
WinSendMsg (hwndSysMenu, MM_QUERYITEM,
MPFROM2SHORT (idSysMenu, FALSE),
MPFROMP (&miSysMenu)) ;
hwndSysSubMenu = miSysMenu.hwndSubMenu ;
for (iItem = 0 ; iItem < 3 ; iItem++)
WinSendMsg (hwndSysSubMenu, MM_INSERTITEM,
MPFROMP (mi + iItem),
MPFROMP (szMenuText [iItem])) ;
return 0 ;
case WM_COMMAND:
switch (COMMANDMSG(&msg)->cmd)
{
case IDM_ABOUT:
WinMessageBox (HWND_DESKTOP, hwnd,
"(C) Charles Petzold, 1993",
szCaption, 0, MB_OK | MB_INFORMATION) ;
return 0 ;
case IDM_HELP:
WinMessageBox (HWND_DESKTOP, hwnd,
"Help not yet implemented",
szCaption, 0, MB_OK | MB_WARNING) ;
return 0 ;
}
break ;
case WM_ERASEBACKGROUND:
return MRFROMSHORT (1) ;
}
return WinDefWindowProc (hwnd, msg, mp1, mp2) ;
}
MRESULT hchlb_umQueryTopIndex( HWND hwnd, MPARAM mp1, MPARAM mp2 )
{
PHCHLB hchlb = WinQueryWindowPtr( hwnd, 0 );
if( hchlb == NULL )
return MRFROMLONG( HCHLIT_ERROR);
return MRFROMSHORT( hchlb->topIndex );
}
MRESULT hchlb_umQuerySelection( HWND hwnd, MPARAM mp1, MPARAM mp2 )
{
PHCHLB hchlb = WinQueryWindowPtr( hwnd, 0 );
// SHORT index = SHORT1FROMMP( mp1 );
if( hchlb == NULL )
return MRFROMLONG( HCHLIT_ERROR);
return MRFROMSHORT( hchlb->curIndex );
}
MRESULT hia_usermQueryWorkingHch(HWND hwnd,MPARAM mp1,MPARAM mp2)
{
HIA *hia = WinQueryWindowPtr(hwnd,WINWORD_INSTANCE);
HANCHAR hch;
// printf("HIAM_QUERYWORKINGHCH\n");
hch = HIABufPeekHch(hia->inbuf);
return MRFROMSHORT(hch);
}
/*-------------------------------------------------------------------------
ActMsgContextMenu
--------------------------------------------------------------------------*/
MRESULT ActMsgContextMenu( WNDATTR *wndattr, USHORT x, USHORT y )
{
BOOL state;
if (Popup == NULLHANDLE)
return MRFROMSHORT( TRUE );
if (MateScrollWnd != NULLHANDLE) {
if (WinIsWindow( wndattr->hab, MateScrollWnd ) == FALSE)
MateScrollWnd = NULLHANDLE;
}
state = (LPListMarkedLines( wndattr->list ) == 0);
SetAttr( CMD_COPY, MIA_DISABLED, state );
SetAttr( CMD_UNMARK, MIA_DISABLED, state );
SetAttr( CMD_REARRANGE, MIA_DISABLED, state );
WinOpenClipbrd( wndattr->hab );
state = (WinQueryClipbrdData( wndattr->hab, CF_TEXT ) == 0);
WinCloseClipbrd( wndattr->hab );
SetAttr( CMD_PASTE, MIA_DISABLED, state );
state = (WinQueryClipbrdViewer( wndattr->hab ) == wndattr->Client);
SetAttr( CMD_ACCUM, MIA_CHECKED, state );
state = (MateScrollWnd != NULLHANDLE);
SetAttr( CMD_MATE, MIA_CHECKED, state );
WinPopupMenu( wndattr->Frame,
wndattr->Frame,
Popup,
x, y, CMD_ABOUT,
PU_HCONSTRAIN | PU_VCONSTRAIN | PU_POSITIONONITEM |
PU_KEYBOARD | PU_MOUSEBUTTON1 | PU_MOUSEBUTTON2 );
return MRFROMSHORT( FALSE );
}
static MRESULT APIENTRY SetRuler ( HWND Window, MESG, MPARAM1 mp1, MPARAM2 ) {
/**************************************************************************
* Find the instance data. *
**************************************************************************/
PDATA Data = PDATA ( Sys_GetWindowData ( Window ) ) ;
/**************************************************************************
* If ruler parameters have changed, save them and invalidate the window. *
**************************************************************************/
PHORZRULER_SETPARMS Parms = PHORZRULER_SETPARMS ( PVOIDFROMMP ( mp1 ) ) ;
if ( ( Data->Metric != Parms->Metric )
OR ( Data->fxZoom != Parms->fxZoom )
OR ( Data->TopLeft != Parms->TopLeft )
OR ( Data->PageWidth != Parms->PageWidth )
OR ( Data->LeftMargin != Parms->LeftMargin )
OR ( Data->RightMargin != Parms->RightMargin )
OR ( Data->TabCount != Parms->TabCount )
OR memcmp ( Data->Tabs, Parms->Tabs, sizeof(Data->Tabs) ) ) {
#ifdef DEBUG
Log ( "HRuler::SetRuler: Setting Margins to %i, %i.", Parms->LeftMargin, Parms->RightMargin ) ;
#endif
Data->Metric = Parms->Metric ;
Data->fxZoom = Parms->fxZoom ;
Data->TopLeft = Parms->TopLeft ;
Data->PageWidth = Parms->PageWidth ;
Data->LeftMargin = Parms->LeftMargin ;
Data->RightMargin = Parms->RightMargin ;
Data->TabCount = Parms->TabCount ;
memcpy ( Data->Tabs, Parms->Tabs, sizeof(Data->Tabs) ) ;
Sys_InvalidateWindow ( Window ) ;
} /* endif */
/********************************h*****************************************
* We're done. *
**************************************************************************/
return ( MRFROMSHORT ( 0 ) ) ;
}
/*
*
* AboutBoxDlgProc
*
* DESCRIPTION:
*
* Processes messages for the product information dialog box
*
*/
MRESULT EXPENTRY
AboutBoxDlgProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
switch(msg)
{
case WM_INITDLG:
SetSysMenu(hwnd); /* system menu for this dialog */
return MRFROMSHORT(FALSE);
case WM_COMMAND:
/* no matter what the command, close the dialog */
WinDismissDlg(hwnd, TRUE);
break;
default:
return(WinDefDlgProc(hwnd, msg, mp1, mp2));
}
return (MRESULT)NULL;
}
extern MRESULT APIENTRY Exit
(
HWND hwnd,
ULONG msg,
MPARAM mp1,
MPARAM mp2
)
{
/***************************************************************************
* Send a WM_CLOSE message to the window. *
***************************************************************************/
WinSendMsg ( hwnd, WM_CLOSE, 0L, 0L ) ;
/***************************************************************************
* Done. *
***************************************************************************/
return ( MRFROMSHORT ( 0 ) ) ;
}
MRESULT EXPENTRY SwapProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2) {
static HWND hwndMenu = (HWND)0;
switch(msg) {
case WM_CREATE:
{
MRESULT mr = PFNWPStatic(hwnd,msg,mp1,mp2);
WinSendMsg(hwnd,
UM_SETUP,
MPVOID,
MPVOID);
return mr;
}
case WM_MOUSEMOVE:
break;
case WM_PRESPARAMCHANGED:
{
char *rootname = "SwapMon";
switch(WinQueryWindowUShort(hwnd,QWS_ID)) {
case CLOCK_FRAME:
rootname = "Clock";
break;
case HARD_FRAME:
rootname = "Hard";
break;
case CPU_FRAME:
rootname = "CPU";
break;
case CLP_FRAME:
rootname = "ClipMon";
break;
case MEM_FRAME:
rootname = "Mem";
break;
case TSK_FRAME:
rootname = "Task";
break;
}
PresParamChanged(hwnd,
rootname,
mp1,
mp2);
PostMsg(hwnd,
UM_TIMER,
MPVOID,
MPVOID);
PostMsg(hwnd,
UM_REFRESH,
MPVOID,
MPFROMSHORT(TRUE));
}
break;
case WM_APPTERMINATENOTIFY:
if(WinQueryWindowUShort(hwnd,QWS_ID) == CPU_FRAME) {
if(!StartCPUThreads())
WinDestroyWindow(hwnd);
}
break;
case WM_BUTTON1MOTIONSTART:
{
POINTL ptl;
ptl.x = SHORT1FROMMP(mp1);
ptl.y = SHORT2FROMMP(mp1);
WinMapWindowPoints(hwnd,
HWND_DESKTOP,
&ptl,
1L);
PostMsg(hwndConfig,
UM_SHOWME,
MPFROM2SHORT((USHORT)ptl.x,(USHORT)ptl.y),
mp2);
}
return MRFROMSHORT(TRUE);
case WM_BUTTON2MOTIONSTART:
{
TRACKINFO TrackInfo;
SWP Position;
memset(&TrackInfo,0,sizeof(TrackInfo));
TrackInfo.cxBorder = 1 ;
TrackInfo.cyBorder = 1 ;
TrackInfo.cxGrid = 1 ;
TrackInfo.cyGrid = 1 ;
TrackInfo.cxKeyboard = 8 ;
TrackInfo.cyKeyboard = 8 ;
WinQueryWindowPos(hwnd,&Position);
TrackInfo.rclTrack.xLeft = Position.x ;
TrackInfo.rclTrack.xRight = Position.x + Position.cx ;
TrackInfo.rclTrack.yBottom = Position.y ;
TrackInfo.rclTrack.yTop = Position.y + Position.cy ;
WinQueryWindowPos(HWND_DESKTOP,&Position);
TrackInfo.rclBoundary.xLeft = Position.x ;
TrackInfo.rclBoundary.xRight = Position.x + Position.cx ;
TrackInfo.rclBoundary.yBottom = Position.y ;
TrackInfo.rclBoundary.yTop = Position.y + Position.cy ;
TrackInfo.ptlMinTrackSize.x = 0 ;
TrackInfo.ptlMinTrackSize.y = 0 ;
TrackInfo.ptlMaxTrackSize.x = Position.cx ;
TrackInfo.ptlMaxTrackSize.y = Position.cy ;
TrackInfo.fs = TF_MOVE | TF_STANDARD | TF_ALLINBOUNDARY ;
if(WinTrackRect(HWND_DESKTOP,
(HPS)0,
&TrackInfo)) {
WinSetWindowPos(hwnd,
HWND_TOP,
TrackInfo.rclTrack.xLeft,
TrackInfo.rclTrack.yBottom,
0,
0,
SWP_MOVE);
switch(WinQueryWindowUShort(hwnd,QWS_ID)) {
case SWAP_FRAME:
WinQueryWindowPos(hwnd,&swpSwap);
SavePrf("SwapSwp",
&swpSwap,
sizeof(SWP));
break;
case CLOCK_FRAME:
WinQueryWindowPos(hwnd,&swpClock);
SavePrf("ClockSwp",
&swpClock,
sizeof(SWP));
break;
case HARD_FRAME:
WinQueryWindowPos(hwnd,&swpHard);
SavePrf("HardSwp",
&swpHard,
sizeof(SWP));
break;
case CPU_FRAME:
WinQueryWindowPos(hwnd,&swpCPU);
SavePrf("CPUSwp",
&swpCPU,
sizeof(SWP));
break;
case CLP_FRAME:
WinQueryWindowPos(hwnd,&swpClip);
SavePrf("ClipSwp",
&swpClip,
sizeof(SWP));
break;
case MEM_FRAME:
WinQueryWindowPos(hwnd,&swpMem);
SavePrf("MemSwp",
&swpMem,
sizeof(SWP));
break;
case TSK_FRAME:
WinQueryWindowPos(hwnd,&swpTask);
SavePrf("TaskSwp",
&swpTask,
sizeof(SWP));
break;
}
}
}
return MRFROMSHORT(TRUE);
case WM_BUTTON1DOWN:
WinSetWindowPos(hwnd,
HWND_TOP,
0,
0,
0,
0,
SWP_ZORDER | SWP_DEACTIVATE);
return MRFROMSHORT(TRUE);
case WM_BUTTON1DBLCLK:
case WM_BUTTON1CLICK:
if((!fNoMonClick &&
msg == WM_BUTTON1CLICK) ||
(fNoMonClick &&
msg == WM_BUTTON1DBLCLK)) {
switch(WinQueryWindowUShort(hwnd,QWS_ID)) {
case HARD_FRAME:
{
ULONG ulDriveNum,ulDriveMap,x;
ulDriveMon = min(ulDriveMon,26);
if(!DosQCurDisk(&ulDriveNum,
&ulDriveMap)) {
for(x = ulDriveMon + 1;x < 26;x++) {
if(ulDriveMap & (1 << x)) {
ulDriveMon = x;
break;
}
}
if(x >= 26) {
for(x = 3;x < ulDriveMon - 1;x++) {
if(ulDriveMap & (1 << x)) {
ulDriveMon = x;
break;
}
}
}
SavePrf("MonDrive",
&ulDriveMon,
sizeof(ULONG));
}
PostMsg(hwnd,
UM_TIMER,
MPVOID,
MPVOID);
}
break;
case CLP_FRAME:
case MEM_FRAME:
case TSK_FRAME:
case SWAP_FRAME:
case CLOCK_FRAME:
case CPU_FRAME:
{
USHORT cmd = CPU_PULSE;
switch(WinQueryWindowUShort(hwnd,QWS_ID)) {
case MEM_FRAME:
cmd = CLOCK_CMDLINE;
break;
case TSK_FRAME:
cmd = CPU_KILLPROC;
break;
case CLP_FRAME:
cmd = CLOCK_CLIPBOARD;
break;
case SWAP_FRAME:
cmd = SWAP_LAUNCHPAD;
break;
case CLOCK_FRAME:
cmd = CLOCK_SETTINGS;
if((WinGetKeyState(HWND_DESKTOP,VK_SHIFT) & 0x8000) != 0)
cmd = CLOCK_CLOCK;
break;
}
PostMsg(hwnd,
WM_COMMAND,
MPFROM2SHORT(cmd,0),
MPVOID);
}
break;
}
return MRFROMSHORT(TRUE);
}
else
PostMsg(hwnd,
UM_TIMER,
MPVOID,
MPVOID);
break;
case WM_CONTEXTMENU:
WinInvalidateRect(hwnd,
NULL,
FALSE);
WinSendMsg(hwnd,
UM_TIMER,
MPVOID,
MPVOID);
WinSetWindowPos(hwnd,
HWND_TOP,
0,
0,
0,
0,
SWP_ZORDER | SWP_DEACTIVATE);
{
USHORT id;
id = WinQueryWindowUShort(hwnd,QWS_ID);
hwndMenu = WinLoadMenu(HWND_DESKTOP,
0,
id);
if(hwndMenu) {
POINTL ptl;
SWP swp;
ULONG ulDriveNum,ulDriveMap,x;
MENUITEM mi;
char s[80];
SetPresParams(hwndMenu,
-1,
-1,
-1,
helvtext);
switch(id) {
case CLP_FRAME:
WinSendMsg(hwndMenu,
MM_SETITEMATTR,
MPFROM2SHORT(CLP_APPEND,FALSE),
MPFROM2SHORT(MIA_CHECKED,
((fClipAppend) ? MIA_CHECKED : 0)));
break;
case HARD_FRAME:
if(!DosQCurDisk(&ulDriveNum,
&ulDriveMap)) {
mi.iPosition = 0;
mi.hwndSubMenu = (HWND)0;
mi.hItem = 0L;
mi.afStyle = MIS_TEXT | MIS_STATIC;
mi.afAttribute = MIA_FRAMED;
mi.id = -1;
sprintf(s,
"Current drive is %c:",
(char)(ulDriveMon + '@'));
WinSendMsg(hwndMenu,
MM_INSERTITEM,
MPFROMP(&mi),
MPFROMP(s));
mi.iPosition = MIT_END;
for(x = 2;x < 26;x++) {
if(ulDriveMap & (1 << x)) {
if(x != ulDriveMon - 1) {
mi.afStyle = MIS_TEXT;
mi.afAttribute = 0;
mi.id = HARD_C + (x - 2);
if(fShowFreeInMenus)
SetDriveText(x + 1,
s);
else
sprintf(s,
"%c:",
(char)(x + 'A'));
WinSendMsg(hwndMenu,
MM_INSERTITEM,
MPFROMP(&mi),
MPFROMP(s));
}
}
}
}
break;
case CLOCK_FRAME:
WinEnableMenuItem(hwndMenu,
CLOCK_VIRTUAL,
fDesktops);
WinEnableMenuItem(hwndMenu,
CLOCK_CLIPBOARD,
(ClipHwnd != (HWND)0));
break;
default:
break;
}
WinQueryWindowPos(hwnd,
&swp);
ptl.x = SHORT1FROMMP(mp1);
ptl.y = SHORT2FROMMP(mp1);
WinMapWindowPoints(hwnd,
HWND_DESKTOP,
&ptl,
1L);
ptl.y = max(ptl.y,swp.y + swp.cy + 4);
if(!WinPopupMenu(HWND_DESKTOP,
hwnd,
hwndMenu,
ptl.x - 4,
ptl.y - 4,
0,
PU_HCONSTRAIN | PU_VCONSTRAIN |
PU_KEYBOARD | PU_MOUSEBUTTON1)) {
WinDestroyWindow(hwndMenu);
hwndMenu = (HWND)0;
}
}
}
return MRFROMSHORT(TRUE);
case WM_MENUEND:
WinSetFocus(HWND_DESKTOP,
HWND_DESKTOP);
WinDestroyWindow((HWND)mp2);
if(hwndMenu == (HWND)mp2)
hwndMenu = (HWND)0;
return 0;
case UM_SETUP:
{
char *rootname = "SwapMon";
switch(WinQueryWindowUShort(hwnd,QWS_ID)) {
case SWAP_FRAME:
SwapHwnd = hwnd;
swaptick = 0;
break;
case CLOCK_FRAME:
ClockHwnd = hwnd;
rootname = "Clock";
break;
case TSK_FRAME:
TaskHwnd = hwnd;
rootname = "Task";
break;
case MEM_FRAME:
MemHwnd = hwnd;
rootname = "Mem";
break;
case HARD_FRAME:
HardHwnd = hwnd;
rootname = "Hard";
break;
case CPU_FRAME:
CPUHwnd = hwnd;
rootname = "CPU";
PostMsg(hwnd,
UM_REFRESH,
MPVOID,
MPFROMSHORT(TRUE));
break;
case CLP_FRAME:
ClipMonHwnd = hwnd;
rootname = "ClipMon";
PostMsg(hwnd,
UM_REFRESH,
MPVOID,
MPFROMSHORT(TRUE));
break;
}
if(!RestorePresParams(hwnd,rootname))
SetPresParams(hwnd,
RGB_WHITE,
RGB_BLACK,
RGB_BLACK,
helvtext);
}
PostMsg(hwnd,
UM_TIMER,
MPVOID,
MPVOID);
return 0;
case UM_REFRESH:
switch(WinQueryWindowUShort(hwnd,QWS_ID)) {
case CLP_FRAME:
{
char s[] = " Clip: [TtBbMmP] + ",*p;
ULONG fmt[] = {CF_TEXT,CF_DSPTEXT,
CF_BITMAP,CF_DSPBITMAP,
CF_METAFILE,CF_DSPMETAFILE,
CF_PALETTE,0};
ULONG x,ret;
if(WinOpenClipbrd(WinQueryAnchorBlock(hwnd))) {
p = s + 8;
for(x = 0;fmt[x];x++) {
ret = WinQueryClipbrdData(WinQueryAnchorBlock(hwnd),
fmt[x]);
if(!ret)
*p = '-';
p++;
}
p += 2;
if(!fClipAppend)
*p = 0;
WinCloseClipbrd(WinQueryAnchorBlock(hwnd));
}
else
strcpy(s + 7,
"Can't open. ");
SetMonitorSize(hwnd,
hwndMenu,
&swpClip,
s);
}
break;
case CPU_FRAME:
{
char s[32];
ULONG percent,lastaverage;
static BOOL lastavgset = 0;
*s = 0;
if(mp2) {
strcpy(s," CPU: -% ");
if(fAverage)
strcat(s,"Avg: -%) ");
}
else {
percent = ((MaxCount - (ULONG)mp1) * 100) / MaxCount;
lastaverage = AveCPU;
AveCPU = (((AveCPU * NumAveCPU) + percent) /
((ULONG)NumAveCPU + 1));
NumAveCPU++;
if(!NumAveCPU)
NumAveCPU = 65535;
if(percent != LastPercent ||
(AveCPU != lastaverage &&
fAverage) ||
NumAveCPU == 1 ||
lastavgset != fAverage) {
lastavgset = fAverage;
LastPercent = percent;
sprintf(s,
" CPU: %lu%% ",
percent);
if(fAverage)
sprintf(s + strlen(s),
"(Avg: %lu%%) ",
AveCPU);
}
}
if(*s)
SetMonitorSize(hwnd,
hwndMenu,
&swpCPU,
s);
}
break;
}
return 0;
case WM_TIMER:
if(fSwapFloat &&
!hwndMenu)
WinSetWindowPos(hwnd,
HWND_TOP,
0,
0,
0,
0,
SWP_ZORDER | SWP_SHOW);
if(WinQueryWindowUShort(hwnd,QWS_ID) == CLP_FRAME) {
if(!ClipHwnd)
WinDestroyWindow(hwnd);
else
TakeClipboard();
}
return 0;
case UM_TIMER:
switch(WinQueryWindowUShort(hwnd,QWS_ID)) {
case CLP_FRAME:
ClipMonHwnd = hwnd;
WinSendMsg(hwnd,
WM_TIMER,
MPVOID,
MPVOID);
break;
case CPU_FRAME:
CPUHwnd = hwnd;
WinSendMsg(hwnd,
WM_TIMER,
MPVOID,
MPVOID);
break;
case HARD_FRAME:
{
char s[80];
HardHwnd = hwnd;
SetDriveText(ulDriveMon,
s);
SetMonitorSize(hwnd,
hwndMenu,
&swpHard,
s);
}
break;
case SWAP_FRAME:
{
FILEFINDBUF3 ffb;
ULONG nm = 1,fl = SWP_SIZE | SWP_SHOW | SWP_MOVE,
sh,sl,nh;
HDIR hdir = HDIR_CREATE;
FSALLOCATE fsa;
char s[128],ss[8],sss[8],mb,smb;
static ULONG lastcbFile = 0;
static BOOL warned = FALSE;
static char SwapperDat[CCHMAXPATH] = "";
strcpy(s,
" Unable to locate SWAPPER.DAT. ");
SwapHwnd = hwnd;
if(!*SwapperDat)
FindSwapperDat(SwapperDat);
if(*SwapperDat) {
DosError(FERR_DISABLEHARDERR);
if(!DosFindFirst(SwapperDat,
&hdir,
FILE_NORMAL | FILE_HIDDEN |
FILE_SYSTEM | FILE_ARCHIVED | FILE_READONLY,
&ffb,
sizeof(ffb),
&nm,
FIL_STANDARD)) {
DosFindClose(hdir);
if(ffb.cbFile != lastcbFile && lastcbFile)
swaptick = 9;
lastcbFile = ffb.cbFile;
DosError(FERR_DISABLEHARDERR);
if(!DosQueryFSInfo(toupper(*SwapperDat) - '@',
FSIL_ALLOC,
&fsa,
sizeof(FSALLOCATE)))
nm = fsa.cUnitAvail * (fsa.cSectorUnit * fsa.cbSector);
else
nm = 0;
if(nm <= 32768 * 1024) {
swaptick = 10;
if(!warned) {
SetPresParams(hwnd,
RGB_RED,
-1,
-1,
NULL);
warned = TRUE;
DosBeep(250,15);
}
}
else if(warned) {
PostMsg(hwnd,
UM_SETUP,
MPVOID,
MPVOID);
warned = FALSE;
}
mb = MakeNumber(nm,
&nh,
&sl);
*sss = 0;
if(sl)
sprintf(sss,
".%02lu",
sl);
smb = MakeNumber(ffb.cbFile,
&sh,
&sl);
*ss = 0;
if(sl)
sprintf(ss,
".%02lu",
sl);
sprintf(s,
" Swap: %lu%s%cb ",
sh,
ss,
smb);
if(fShowSwapFree)
sprintf(s + strlen(s),
"(%lu%s%cb free) ",
nh,
sss,
mb);
}
}
SetMonitorSize(hwnd,
hwndMenu,
&swpSwap,
s);
}
break;
case TSK_FRAME:
{
PROCESSINFO *ppi;
BUFFHEADER *pbh = NULL;
MODINFO *pmi;
long numprocs = -1,numthreads = -1;
char s[80];
if(!DosAllocMem((PVOID)&pbh,
USHRT_MAX + 4096,
PAG_COMMIT | OBJ_TILE | PAG_READ | PAG_WRITE)) {
if(!DosQProcStatus(pbh,
USHRT_MAX)) {
numprocs = numthreads = 0;
ppi = pbh->ppi;
while(ppi->ulEndIndicator != PROCESS_END_INDICATOR ) {
pmi = pbh->pmi;
while(pmi &&
ppi->hModRef != pmi->hMod)
pmi = pmi->pNext;
if(pmi) {
numprocs++;
numthreads += ppi->usThreadCount;
}
ppi = (PPROCESSINFO)(ppi->ptiFirst + ppi->usThreadCount);
}
}
DosFreeMem(pbh);
sprintf(s,
" Procs: %ld Thrds: %ld ",
numprocs,
numthreads);
SetMonitorSize(hwnd,
hwndMenu,
&swpTask,
s);
}
}
break;
case MEM_FRAME:
{
ULONG sh,sl,nh,amem;
char s[128],ss[8],sss[8],mb,smb;
strcpy(s,
"Can't check virtual memory.");
MemHwnd = hwnd;
if(!DosQuerySysInfo(QSV_TOTAVAILMEM,
QSV_TOTAVAILMEM,
&amem,
sizeof(amem))) {
mb = MakeNumber(amem,
&nh,
&sl);
*ss = 0;
if(sl)
sprintf(ss,
".%02lu",
sl);
sprintf(s,
" VMem: %lu%s%cb ",
nh,
ss,
mb);
}
if(fShowPMem) {
if(!Dos16MemAvail(&amem)) {
mb = MakeNumber(amem,
&nh,
&sl);
*ss = 0;
if(sl)
sprintf(ss,
".%02lu",
sl);
sprintf(s + strlen(s),
" PMem: %lu%s%cb ",
nh,
ss,
mb);
}
}
SetMonitorSize(hwnd,
hwndMenu,
&swpMem,
s);
}
break;
case CLOCK_FRAME:
{
char s[80];
DATETIME dt;
ClockHwnd = hwnd;
if(!DosGetDateTime(&dt)) {
sprintf(s,
" %0*u:%02u%s ",
((ampm) ? 0 : 2),
(dt.hours % ((ampm) ? 12 : 24)) +
((ampm && !(dt.hours % 12)) ? 12 : 0),
dt.minutes,
((ampm) ? (dt.hours > 11) ? "pm" : "am" : ""));
if(showdate)
sprintf(s + strlen(s),
"%02u/%02u ",
dt.month,
dt.day);
}
else
strcpy(s,"Unknown time");
SetMonitorSize(hwnd,
hwndMenu,
&swpClock,
s);
}
break;
}
return 0;
case WM_COMMAND:
{
BOOL ctrl,shift;
ctrl = ((WinGetKeyState(HWND_DESKTOP,VK_CTRL) & 0x8000) != 0);
shift = ((WinGetKeyState(HWND_DESKTOP,VK_SHIFT) & 0x8000) != 0);
switch(SHORT1FROMMP(mp1)) {
case CLP_CLEAR:
if(WinOpenClipbrd(WinQueryAnchorBlock(hwnd))) {
WinEmptyClipbrd(WinQueryAnchorBlock(hwnd));
WinCloseClipbrd(WinQueryAnchorBlock(hwnd));
PostMsg(hwnd,
UM_REFRESH,
MPVOID,
MPVOID);
}
break;
case CLP_APPEND:
fClipAppend = (fClipAppend) ? FALSE : TRUE;
SavePrf("ClipAppend",
&fClipAppend,
sizeof(BOOL));
PostMsg(hwnd,
UM_REFRESH,
MPVOID,
MPVOID);
if(ClipSetHwnd)
PostMsg(ClipSetHwnd,
UM_REFRESH,
MPVOID,
MPVOID);
break;
case MSE_HELP:
ViewHelp(hwnd,
"Monitors page");
break;
case CPU_PULSE:
{
PROGDETAILS pgd;
WinSetWindowPos(hwnd,
HWND_TOP,
0,
0,
0,
0,
SWP_ACTIVATE | SWP_FOCUSACTIVATE);
memset(&pgd,
0,
sizeof(pgd));
pgd.Length = sizeof(pgd);
pgd.swpInitial.fl = SWP_ACTIVATE | SWP_ZORDER;
pgd.swpInitial.hwndInsertBehind = HWND_TOP;
pgd.progt.fbVisible = SHE_VISIBLE;
pgd.progt.progc = PROG_DEFAULT;
pgd.pszExecutable = "PULSE.EXE";
if(WinStartApp(CPUHwnd,
&pgd,
NULL,
NULL,
0)) {
if(CPUHwnd) {
closethreads = 1;
DosSleep(1);
PostMsg(CPUHwnd,
UM_REFRESH,
MPVOID,
MPFROMSHORT(TRUE));
}
}
}
break;
case CPU_RESET:
AveCPU = 0;
NumAveCPU = 0;
break;
case CLOCK_VIRTUAL:
case CLOCK_SWITCHLIST:
case CLOCK_CMDLINE:
case CLOCK_CLIPBOARD:
case CLOCK_CALCULATOR:
case HARD_FM2:
case MSE_FRAME:
{
ULONG msg2 = UM_SHOWME;
MPARAM mp12 = 0,mp22 = 0;
HWND hwndP = hwndConfig;
switch(SHORT1FROMMP(mp1)) {
case CLOCK_CMDLINE:
mp12 = MPFROMLONG(((WinGetKeyState(HWND_DESKTOP,VK_CTRL) & 0x8000) != 0));
msg2 = UM_CMDLINE;
break;
case CLOCK_CLIPBOARD:
msg2 = UM_CLIPMGR;
hwndP = ObjectHwnd3;
break;
case CLOCK_SWITCHLIST:
msg2 = UM_SWITCHLIST;
break;
case CLOCK_VIRTUAL:
msg2 = UM_VIRTUAL;
break;
case CLOCK_CALCULATOR:
msg2 = UM_CALC;
break;
case HARD_FM2:
msg2 = UM_STARTWIN;
mp12 = MPFROM2SHORT(C_STARTFM2,0);
break;
}
PostMsg(hwndP,
msg2,
mp12,
mp22);
}
break;
case CLOCK_SETTINGS:
case CLOCK_CLOCK:
case SWAP_LAUNCHPAD:
case SWAP_WARPCENTER:
case SWAP_CONNECTIONS:
case SWAP_INFO:
case SWAP_SETTINGS:
case SWAP_SYSTEM:
case SWAP_TEMPS:
case SWAP_FM2:
case HARD_OPEN:
case CVR_COLORPALETTE:
case CVR_HICOLORPALETTE:
case CVR_FONTPALETTE:
case CPU_KILLPROC:
case CPU_HARDWARE:
{
char *p = "<WP_CLOCK>",*pp = defopen;
char s[8];
switch(SHORT1FROMMP(mp1)) {
case HARD_OPEN:
sprintf(s,
"%c:\\",
(char)(ulDriveMon + '@'));
p = s;
break;
case SWAP_FM2:
p = "<FM3_Folder>";
break;
case SWAP_TEMPS:
p = "<WP_TEMPS>";
break;
case SWAP_SYSTEM:
p = "<WP_OS2SYS>";
break;
case SWAP_SETTINGS:
p = "<WP_CONFIG>";
break;
case SWAP_INFO:
p = "<WP_INFO>";
break;
case SWAP_CONNECTIONS:
p = "<WP_CONNECTIONSFOLDER>";
break;
case SWAP_WARPCENTER:
p = "<WP_WARPCENTER>";
break;
case SWAP_LAUNCHPAD:
p = "<WP_LAUNCHPAD>";
break;
case CLOCK_SETTINGS:
pp = setopen;
break;
case CVR_COLORPALETTE:
p = "<WP_LORESCLRPAL>";
break;
case CVR_HICOLORPALETTE:
p = "<WP_HIRESCLRPAL>";
break;
case CVR_FONTPALETTE:
p = "<WP_FNTPAL>";
break;
case CPU_KILLPROC:
p = "<FM/2_KILLPROC>";
break;
case CPU_HARDWARE:
p = "<WP_HWMGR>";
break;
}
OpenObject(p,
pp);
}
break;
case HARD_VDIR:
{
PROGDETAILS pgd;
char s[36];
sprintf(s,
"/C VDIR.CMD %c:\\",
(char)(ulDriveMon + '@'));
memset(&pgd,
0,
sizeof(pgd));
pgd.Length = sizeof(pgd);
pgd.swpInitial.fl = SWP_MINIMIZE | SWP_ACTIVATE | SWP_ZORDER;
pgd.swpInitial.hwndInsertBehind = HWND_TOP;
pgd.progt.fbVisible = SHE_VISIBLE;
pgd.progt.progc = PROG_DEFAULT;
pgd.pszExecutable = "CMD.EXE";
WinStartApp((HWND)0,
&pgd,
s,
NULL,
0);
}
break;
case HARD_CHKDSK:
{
PROGDETAILS pgd;
char s[8];
WinSetWindowPos(hwnd,
HWND_TOP,
0,
0,
0,
0,
SWP_ACTIVATE | SWP_FOCUSACTIVATE);
sprintf(s,
"%c:",
(char)(ulDriveMon + '@'));
memset(&pgd,
0,
sizeof(pgd));
pgd.Length = sizeof(pgd);
pgd.swpInitial.fl = SWP_ACTIVATE | SWP_ZORDER;
pgd.swpInitial.hwndInsertBehind = HWND_TOP;
pgd.progt.fbVisible = SHE_VISIBLE;
pgd.progt.progc = PROG_DEFAULT;
pgd.pszExecutable = "PMCHKDSK.EXE";
WinStartApp((HWND)0,
&pgd,
s,
NULL,
0);
}
break;
default:
if(SHORT1FROMMP(mp1) >= HARD_C &&
SHORT1FROMMP(mp1) <= HARD_C + 24) {
ulDriveMon = (SHORT1FROMMP(mp1) - HARD_C) + 3;
PostMsg(hwnd,
UM_TIMER,
MPVOID,
MPVOID);
if(ctrl)
PostMsg(hwnd,
WM_COMMAND,
MPFROM2SHORT(HARD_OPEN,0),
MPVOID);
else if(shift)
PostMsg(hwnd,
WM_COMMAND,
MPFROM2SHORT(HARD_VDIR,0),
MPVOID);
}
break;
}
}
return 0;
case WM_DESTROY:
switch(WinQueryWindowUShort(hwnd,QWS_ID)) {
case SWAP_FRAME:
SwapHwnd = (HWND)0;
break;
case CLOCK_FRAME:
ClockHwnd = (HWND)0;
break;
case HARD_FRAME:
HardHwnd = (HWND)0;
break;
case CPU_FRAME:
closethreads = 1;
DosSleep(1);
CPUHwnd = (HWND)0;
break;
case CLP_FRAME:
ClipMonHwnd = (HWND)0;
break;
case MEM_FRAME:
MemHwnd = (HWND)0;
break;
case TSK_FRAME:
TaskHwnd = (HWND)0;
break;
}
break;
}
return PFNWPStatic(hwnd,msg,mp1,mp2);
}
MRESULT EXPENTRY ClientWndProc (HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
static CHAR szErrorMsg [] = "File not found or could not be opened" ;
static INT cxClient, cyClient, cxChar, cyChar, cyDesc ;
CHAR *pcReadBuffer ;
FILE *fileInput ;
FONTMETRICS fm ;
HPS hps ;
INT iLength ;
POINTL ptl ;
switch (msg)
{
case WM_CREATE:
hps = WinGetPS (hwnd) ;
EzfQueryFonts (hps) ;
if (!EzfCreateLogFont (hps, LCID_FIXEDFONT, FONTFACE_MONO,
FONTSIZE_10, 0))
{
WinReleasePS (hps) ;
WinMessageBox (HWND_DESKTOP, HWND_DESKTOP,
"Cannot find a fixed-pitch font. Load the Courier "
"fonts from the Control Panel and try again.",
szClientClass, 0, MB_OK | MB_WARNING) ;
return MRFROMSHORT (1) ;
}
GpiQueryFontMetrics (hps, (LONG) sizeof fm, &fm) ;
cxChar = fm.lAveCharWidth ;
cyChar = fm.lMaxBaselineExt ;
cyDesc = fm.lMaxDescender ;
GpiSetCharSet (hps, LCID_DEFAULT) ;
GpiDeleteSetId (hps, LCID_FIXEDFONT) ;
WinReleasePS (hps) ;
return 0 ;
case WM_SIZE:
cxClient = SHORT1FROMMP (mp2) ;
cyClient = SHORT2FROMMP (mp2) ;
return 0 ;
case WM_COMMAND:
switch (COMMANDMSG(&msg)->cmd)
{
case IDM_OPEN:
if (WinDlgBox (HWND_DESKTOP, hwnd, OpenDlgProc,
NULLHANDLE, IDD_OPEN, NULL))
WinInvalidateRect (hwnd, NULL, FALSE) ;
return 0 ;
case IDM_ABOUT:
WinDlgBox (HWND_DESKTOP, hwnd, AboutDlgProc,
NULLHANDLE, IDD_ABOUT, NULL) ;
return 0 ;
}
break ;
case WM_PAINT:
hps = WinBeginPaint (hwnd, NULLHANDLE, NULL) ;
GpiErase (hps) ;
if (szFileName [0] != '\0')
{
EzfCreateLogFont (hps, LCID_FIXEDFONT, FONTFACE_MONO,
FONTSIZE_10, 0) ;
EzfCreateLogFont (hps, LCID_BOLDFONT, FONTFACE_MONO,
FONTSIZE_10, FATTR_SEL_BOLD) ;
GpiSetCharSet (hps, LCID_BOLDFONT) ;
ptl.x = cxChar ;
ptl.y = cyClient - cyChar + cyDesc ;
GpiCharStringAt (hps, &ptl, strlen (szFileName),
szFileName) ;
ptl.y -= cyChar ;
if ((fileInput = fopen (szFileName, "r")) != NULL)
{
GpiSetCharSet (hps, LCID_FIXEDFONT) ;
pcReadBuffer = (PCHAR) malloc (cxClient / cxChar) ;
while ((ptl.y -= cyChar) > 0 &&
fgets (pcReadBuffer, cxClient / cxChar - 2,
fileInput) != NULL)
{
iLength = strlen (pcReadBuffer) ;
if (pcReadBuffer [iLength - 1] == '\n')
iLength-- ;
if (iLength > 0)
GpiCharStringAt (hps, &ptl, iLength,
pcReadBuffer) ;
}
free (pcReadBuffer) ;
fclose (fileInput) ;
}
else // file cannot be opened
{
ptl.y -= cyChar ;
GpiCharStringAt (hps, &ptl, strlen (szErrorMsg),
szErrorMsg) ;
}
GpiSetCharSet (hps, LCID_DEFAULT) ;
GpiDeleteSetId (hps, LCID_FIXEDFONT) ;
GpiDeleteSetId (hps, LCID_BOLDFONT) ;
}
WinEndPaint (hps) ;
return 0 ;
}
return WinDefWindowProc (hwnd, msg, mp1, mp2) ;
}
MRESULT EXPENTRY
NewFrameProc( HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2 )
{
PFNWP pfnwpOldFrameProc ;
/* ------- get original frame procedure --------- */
pfnwpOldFrameProc = (PFNWP) WinQueryWindowULong( hwnd, QWL_USER );
switch (msg) {
case WM_QUERYFRAMECTLCOUNT :
{
USHORT usItemCount ;
/* ---- get count of original frame controls --- */
usItemCount = SHORT1FROMMR( pfnwpOldFrameProc( hwnd,
msg,
mp1, mp2 ));
/* ------- add 1 for new toolbar control ------ */
return ( (MRESULT) ++usItemCount );
}
case WM_FORMATFRAME :
{
PSWP pSWP ; // pointer to array of frame ctl SWPs
USHORT usItemCount ; // count of original frame controls
USHORT usNewMenuIndex ; // index of new menu SWP
USHORT usToolBarIndex ; // index of Tool Bar menu SWP
USHORT usClientIndex ; // index of client window SWP
USHORT usVertScrollIndex ; // index of vertical scrollbar SWP
HWND hwndVertScroll ; // hwnd of vertical scrollbar
/* ------- get a pointer to the SWP array ---------- */
pSWP = PVOIDFROMMP( mp1 );
/* ---- run regular processing for original controls --- */
/*
* Note that the original frame proc will setup all
* the SWP sturctures for the standard frame window
* controls starting at the beginning of the array.
* A count of how many SWP structures were initialized
* is returned.
* All SWP structures for new controls that are to be
* added ( in our case, 1 ) will be uninitialized and
* at the end of the array. The start of the uninitialied
* SWP structure start at an index equal to the returned
* count.
*/
usItemCount = SHORT1FROMMR( pfnwpOldFrameProc( hwnd,
msg,
mp1, mp2 ));
/* ------------- locate SWP for 1st menu ---------- */
/*
* We will use the settings of the 1st menu to help initialize
* the SWP for the second menu. We look for the proper SWP
* by scanning the array for the matching hwnd.
*/
for ( usToolBarIndex = 0;
usToolBarIndex < usItemCount;
usToolBarIndex++) {
if (pSWP[usToolBarIndex].hwnd == hwndToolBar){
break;
}
} // end of for( usToolBarIndex...
/* ------------- locate SWP for client window ---------- */
/*
* We will need to adjust the vertical height of the client
* window to make room for the second menu. We look for the
* proper SWP by scanning the array for a matching hwnd.
*/
for ( usClientIndex = 0;
usClientIndex < usItemCount;
usClientIndex++){
if (pSWP[usClientIndex].hwnd == hwndClient ){
break;
}
} // end of for ( usClientIndex...
/* --- locate SWP for vert scroll (if exists) --- */
/*
* First we will check if this window has a vert. scroll bar.
* We will need to adjust the vertical height of the scroll
* bar to make room for the second menu. We look for the
* proper SWP by scanning the array for a matching hwnd.
*/
if ( ( hwndVertScroll =
WinWindowFromID( hwnd, FID_VERTSCROLL)) != NULLHANDLE ){
for ( usVertScrollIndex = 0;
usVertScrollIndex < usItemCount;
usVertScrollIndex++){
if (pSWP[usVertScrollIndex].hwnd == hwndVertScroll ){
break;
}
} // end of for ( usClientIndex...
} // end of if (( hwndVertScroll...
/* ------ the new SWP starts after standard control SWPs ----- */
usNewMenuIndex = usItemCount ;
/* ---- get size values for 2nd menu bar -------- */
pSWP[ usNewMenuIndex ].fl = SWP_SIZE;
pSWP[ usNewMenuIndex ].cx = pSWP[usToolBarIndex].cx ; // set some
pSWP[ usNewMenuIndex ].cy = pSWP[usToolBarIndex].cy ; // defaults
pSWP[ usNewMenuIndex ].hwndInsertBehind = HWND_TOP ;
pSWP[ usNewMenuIndex ].hwnd = hwndMenuBar ;
/* -- get the menu code to make the actual size adjustments -- */
WinSendMsg( hwndMenuBar,
WM_ADJUSTWINDOWPOS,
MPFROMP( pSWP+usNewMenuIndex ),
(MPARAM) 0L );
/* ------ position menu directly below other menu ------- */
pSWP[usNewMenuIndex].x = pSWP[usToolBarIndex].x ;
pSWP[usNewMenuIndex].y = pSWP[usToolBarIndex].y -
pSWP[usNewMenuIndex].cy ;
pSWP[usNewMenuIndex].fl = pSWP[usToolBarIndex].fl ;
/* -------- adjust client window size for 2nd menu ------- */
pSWP[usClientIndex].cy -= pSWP[usNewMenuIndex].cy ;
/* -------- adjust vertical scroll size for 2nd menu ----- */
if ( hwndVertScroll != NULLHANDLE ){
pSWP[usVertScrollIndex].cy -= pSWP[usNewMenuIndex].cy ;
}
/* --- return total count of controls ( +1 for 2nd menu ) --- */
return( MRFROMSHORT( ++usItemCount ) );
}
break;
default:
return( pfnwpOldFrameProc(hwnd,msg,mp1,mp2) );
} /* end of switch () */
return( FALSE );
} /* end of NewFrameProc */
static MRESULT APIENTRY Char ( HWND Window, MESG, MPARAM1 mp1, MPARAM2 mp2 ) {
/***************************************************************************
* Find the instance data. *
***************************************************************************/
PDATA Data = PDATA ( Sys_GetWindowData ( Window ) ) ;
/***************************************************************************
* Get the message data. *
***************************************************************************/
USHORT Flags = (USHORT) SHORT1FROMMP ( mp1 ) ;
//UCHAR Repeat = (UCHAR) CHAR3FROMMP ( mp1 ) ;
//UCHAR ScanCode = (UCHAR) CHAR4FROMMP ( mp1 ) ;
//USHORT Char = (USHORT) SHORT1FROMMP ( mp2 ) ;
USHORT VKey = (USHORT) SHORT2FROMMP ( mp2 ) ;
/***************************************************************************
* Ignore keys being released, invalid characters, dead keys and *
* invalid composite characters. *
***************************************************************************/
if ( ( Flags & KC_KEYUP )
OR ( Flags & KC_INVALIDCHAR )
OR ( Flags & KC_DEADKEY )
OR ( Flags & KC_INVALIDCOMP ) )
{
Sys_BeepNote ( ) ;
return ( MRFROMSHORT ( FALSE ) ) ;
}
/***************************************************************************
* Intercept the ESC virtual key to abort margin set mode. *
***************************************************************************/
if ( Flags & KC_VIRTUALKEY ) {
switch ( VKey ) {
case VK_ESC: {
if ( Data->Capture ) {
Data->Capture = FALSE ;
Sys_ReleaseCapture ( ) ;
HPOINTER Ptr = WinQuerySysPointer ( HWND_DESKTOP, SPTR_ARROW, FALSE ) ;
WinSetPointer ( HWND_DESKTOP, Ptr ) ;
Sys_SetFocus ( Data->HadFocus ) ;
WorkSpace PS ( "HRuler::Char", 0, Window, Data->pDevice, int(Data->Metric) ) ;
PS.SetTransform ( Data->fxZoom, int(Data->TopLeft), 0 ) ;
RECTL Rectangle ;
WinQueryWindowRect ( Window, &Rectangle ) ;
PS.Transform ( CVTC_DEVICE, CVTC_DEFAULTPAGE, Rectangle ) ;
POINTL ButtonSize = { 8, 8 } ;
PS.Transform ( CVTC_DEVICE, CVTC_PAGE, 1, &ButtonSize ) ;
PS.SetMix ( FM_INVERT ) ;
PS.SetLineType ( LINETYPE_ALTERNATE ) ;
POINTL Point = { Data->Tick, Rectangle.yBottom } ;
PS.Move ( Point ) ;
Point.y = Rectangle.yTop ;
PS.DrawLine ( Point ) ;
Data->Mode = NOTMOVING ;
}
break ;
}
}
}
/***************************************************************************
* Return. *
***************************************************************************/
return ( MRFROMSHORT ( TRUE ) ) ;
}
static MRESULT APIENTRY Button1Up ( HWND Window, MESG, MPARAM1 mp1, MPARAM2 ) {
/***************************************************************************
* Find the instance data. *
***************************************************************************/
PDATA Data = PDATA ( Sys_GetWindowData ( Window ) ) ;
/***************************************************************************
* If the mouse wasn't captured, return. *
***************************************************************************/
if ( NOT Data->Capture )
return ( MRFROMSHORT ( FALSE ) ) ;
/***************************************************************************
* Get the presentation space. *
***************************************************************************/
WorkSpace PS ( "HRuler::Button1Up", 0, Window, Data->pDevice, int(Data->Metric) ) ;
PS.SetTransform ( Data->fxZoom, int(Data->TopLeft), 0 ) ;
/***************************************************************************
* Find out where the mouse touched. *
***************************************************************************/
RECTL Rectangle ;
WinQueryWindowRect ( Window, &Rectangle ) ;
POINTL Mouse = { SHORT1FROMMP(mp1), SHORT2FROMMP(mp1) } ;
PS.Transform ( CVTC_DEVICE, CVTC_DEFAULTPAGE, 1, &Mouse ) ;
PS.Transform ( CVTC_DEVICE, CVTC_DEFAULTPAGE, Rectangle ) ;
POINTL ButtonSize = { 8, 8 } ;
PS.Transform ( CVTC_DEVICE, CVTC_PAGE, 1, &ButtonSize ) ;
#ifdef DEBUG
Log ( "HRuler::Button1Up: Mouse at %i,%i (%i,%i). Rectangle %i,%i-%i,%i. ButtonSize %i.%i (8x8).",
Mouse.x, Mouse.y, SHORT1FROMMP(mp1), SHORT2FROMMP(mp1),
Rectangle.xLeft, Rectangle.yBottom, Rectangle.xRight, Rectangle.yTop,
ButtonSize.x, ButtonSize.y ) ;
#endif
/***************************************************************************
* Erase the previous hairline. *
***************************************************************************/
PS.SetMix ( FM_INVERT ) ;
PS.SetLineType ( LINETYPE_ALTERNATE ) ;
POINTL Point = { Data->Tick, Rectangle.yBottom } ;
PS.Move ( Point ) ;
Point.y = Rectangle.yTop ;
PS.DrawLine ( Point ) ;
/***************************************************************************
* Release the mouse. *
***************************************************************************/
Data->Capture = FALSE ;
Sys_ReleaseCapture ( ) ;
/***************************************************************************
* Restore the normal mouse pointer. *
***************************************************************************/
HPOINTER Ptr = WinQuerySysPointer ( HWND_DESKTOP, SPTR_ARROW, FALSE ) ;
WinSetPointer ( HWND_DESKTOP, Ptr ) ;
/***************************************************************************
* Restore the keyboard focus. *
***************************************************************************/
Sys_SetFocus ( Data->HadFocus ) ;
/***************************************************************************
* Process final location of mouse. *
***************************************************************************/
switch ( Data->Mode ) {
case MOVELEFT:
{
Data->Tick = TICK(Mouse.x) ;
if ( ( Data->Tick < 0 ) OR ( Data->Tick >= Data->RightMargin ) )
{
Sys_BeepError ( ) ;
break ;
}
Sys_SendMessage ( OWNER(Window), WM_SET_LEFTMARGIN, MPFROMLONG(Data->Tick), 0 ) ;
break ;
}
case MOVERIGHT:
{
Data->Tick = TICK(Mouse.x) ;
if ( ( Data->Tick <= Data->LeftMargin ) OR ( Data->Tick > Data->PageWidth ) )
{
Sys_BeepError ( ) ;
break ;
}
Sys_SendMessage ( OWNER(Window), WM_SET_RIGHTMARGIN, MPFROMLONG(Data->Tick), 0 ) ;
break ;
}
case MOVETAB:
{
Data->Tick = TICK(Mouse.x) ;
if ( ( Mouse.y > Rectangle.yTop )
OR ( Mouse.y < Rectangle.yBottom )
OR ( Data->Tick <= Data->LeftMargin )
OR ( Data->Tick >= Data->RightMargin ) )
{
Sys_SendMessage ( OWNER(Window), WM_CLEAR_TAB, MPFROMLONG(Data->Tabs[Data->TabIndex]), 0 ) ;
break ;
}
Sys_SendMessage ( OWNER(Window), WM_MOVE_TAB, MPFROMLONG(Data->Tabs[Data->TabIndex]), MPFROMLONG(Data->Tick) ) ;
break ;
}
case SETTAB:
{
Data->Tick = TICK(Mouse.x) ;
if ( ( Mouse.y > Rectangle.yTop )
OR ( Mouse.y < Rectangle.yBottom )
OR ( Data->Tick <= Data->LeftMargin )
OR ( Data->Tick >= Data->RightMargin ) )
{
Sys_BeepError ( ) ;
break ;
}
Sys_SendMessage ( OWNER(Window), WM_SET_TAB, MPFROMLONG(Data->Tick), 0 ) ;
break ;
}
}
/***************************************************************************
* Reset mode. *
***************************************************************************/
Data->Mode = NOTMOVING ;
/***************************************************************************
* We're done. *
***************************************************************************/
return ( MRFROMSHORT ( TRUE ) ) ;
}
MRESULT EXPENTRY WndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 )
{
// static POINTS DragStartPtrPos;
POINTL ptl;
static char Row, Col;
static BOOL HasMoved = FALSE;
static BOOL IntroSoundPlayed = FALSE;
static BOOL RealPaint = TRUE; // indicates whether the board
// has to be repainted or just copied
INT aktscan;
CHAR msgtext[256];
ULONG ulResponse;
// ERRORID errId;
switch( msg ){
case WM_CREATE:
if( !InfoData.LoadHigh() ){ // get previously saved highscores
InfoData.ResetHigh();
WinMessageBox( HWND_DESKTOP, hwndMain,
"The file scores.dat " \
"(which is in the current directory) was somehow corrupted." \
" All Highscores will be reset to Zero.",
"Error when loading Highscores",
0, MB_OK | MB_INFORMATION );
}
// allocate memory for global variables; see GLOBALS struct in tgraph.h
pg = new GLOBALS;
// initialize globals to zero
memset( pg, 0, sizeof( GLOBALS ));
// store globals pointer into client window words; see WinRegisterClass
// WinSetWindowULong( hwnd, QWL_USER, (ULONG) pg );
wcprintf("1: %x", WinGetLastError( hab ) );
DosCreateEventSem( NULL, &hevWaitAfterScan, 0, FALSE );
// Sem is created in reset state
DosCreateEventSem( NULL, &hevHiScoreWin, 0, FALSE );
DosCreateEventSem( NULL, &hevWaitAfterSound, 0, FALSE );
DosCreateEventSem( NULL, &hevWaitSoundReady, 0, TRUE );
// Sem is created in posted state
// hevWaitAfterScan and hewWaitAfterSound are used to indicate
// when the respective WM_CREATE routines are done.
// after that they are in posted state, as desired
// initialize globals with important data
pg->hab = hab;
pg->hwndClient = hwnd;
pg->hwndFrame = WinQueryWindow( hwnd, QW_PARENT );
pg->hwndTitlebar = WinWindowFromID( pg->hwndFrame, FID_TITLEBAR );
pg->hwndMenubar = WinWindowFromID( pg->hwndFrame, FID_MENU );
// create graphics and sound threads
pg->tidTSound = _beginthread( &threadsound, NULL, LEN_STACK, NULL );
pg->tidTGraph = _beginthread( &threadgraph, NULL, LEN_STACK, NULL );
DosWaitEventSem( hevWaitAfterSound, SEM_INDEFINITE_WAIT );
WinPostMsg( pg->hwndTSound, WM_SOUND_INTRO, MPFROMHWND(hwnd), 0 );
// wait for the sound's WM_CREATE
DosWaitEventSem( hevWaitAfterScan, SEM_INDEFINITE_WAIT );
// wait for the graphics' WM_CREATE
InfoData.ShipsNotFound = GBoard.GetShipNumber();
wcprintf("create: %x", WinGetLastError( hab ) );
return (MRESULT)0;
case WM_CONTROL:
break;
case WM_QUIT:
break;
case WM_CLOSE: // this message is sent before WM_QUIT
InfoData.SaveHigh( WinGetCurrentTime(hab) );
// save the highscores and provide a random seed
// get pointer to globals from window words
// pg = (PGLOBALS) WinQueryWindowULong( hwnd, QWL_USER );
// tell object windows to quit, then exit their threads
// WinSendMsg( pg->hwndTGraph, WM_DESTROY, mp1, mp2 );
WinPostMsg( pg->hwndTGraph, WM_QUIT, mp1, mp2 );
// WinSendMsg( pg->hwndTSound, WM_DESTROY, mp1, mp2 );
WinPostMsg( pg->hwndTSound, WM_QUIT, mp1, mp2 );
DosCloseEventSem( hevWaitAfterScan );
DosCloseEventSem( hevHiScoreWin );
DosCloseEventSem( hevWaitAfterSound );
DosCloseEventSem( hevWaitSoundReady );
WriteProfile( hab );
delete pg;
return (MRESULT) 0;
case WM_ERASEBACKGROUND:
wcprintf("erasebackground");
// return (MRESULT) FALSE;
return (MRESULT) TRUE;
case WM_PAINT:
///////////////////////////////////
{
RECTL rectl;
WinQueryWindowRect( pg->hwndClient, &rectl );
wcprintf("Linienrechteck: Breite: %d H”he: %d", rectl.xRight, rectl.yTop );
// test size:
GpiSetColor( hpsGlob, CLR_RED );
ptl.x = rectl.xLeft; ptl.y = rectl.yBottom;
GpiMove( hpsGlob, &ptl );
ptl.x = rectl.xRight; ptl.y = rectl.yTop;
GpiLine( hpsGlob, &ptl );
}
///////////////////////////
break;
case WM_SIZE:
wcprintf("main wnd function wm-size");
RealPaint = TRUE;
GBoard.SetPMBoardValues( SHORT1FROMMP( mp2 ), SHORT2FROMMP( mp2 ) );
WndResize( hwnd );
wcprintf("size: %x", WinGetLastError( hab ) );
break;
case WM_BEGINDRAG:
WinSetCapture( HWND_DESKTOP, hwnd ); // capture the mouse pointer
GBoard.SetfDrag( TRUE ); // indicate that mouse is being dragged
GBoard.ResetFirstDraw(); // for initialization of drag op.
fHideSquare = TRUE;
WinSendMsg( pg->hwndTGraph, WM_SHOWPOINTERPOS, MPFROMHWND(hwnd),
MPFROM2SHORT( 0, 0 ) );
// GBoard.ShowPointerPos( hwnd, 0, 0 ); // removes the square
ptl.x = SHORT1FROMMP(mp1);
ptl.y = SHORT2FROMMP(mp1);
Row = GBoard.GetBoardRow( ptl.y ); // starting point of drag
Col = GBoard.GetBoardCol( ptl.x ); // operation; static!
return (MRESULT)TRUE;
case WM_MOUSEMOVE:
if( GBoard.GetfDrag() ){ // if mouse is being dragged
WinSendMsg( pg->hwndTGraph, WM_DRAWDRAGLINE, mp1,
MPFROM2SHORT( Row, Col ) );
HasMoved = TRUE;
} else { // mouse is moved normally
if( !fHideSquare )
WinSendMsg( pg->hwndTGraph, WM_SHOWPOINTERPOS, MPFROMHWND(hwnd),
mp1 );
// GBoard.ShowPointerPos( hwnd, SHORT1FROMMP(mp1),
// SHORT2FROMMP(mp1));
}
break;
case WM_ENDDRAG:
WinSetCapture( HWND_DESKTOP, NULLHANDLE ); // release the captured
// mouse pointer
if( HasMoved ){ // mousemove has actually been moved
WinSendMsg( pg->hwndTGraph, WM_MARKDRAGLINE,
MPFROM2SHORT( Row, Col ), 0 );
HasMoved = FALSE;
}
GBoard.SetfDrag( FALSE );
GBoard.ClearDrawPoint(); // because no square is drawn right now
fHideSquare = FALSE;
WinSendMsg( pg->hwndTGraph, WM_SHOWPOINTERPOS, MPFROMHWND(hwnd),
mp1 );
// GBoard.ShowPointerPos( hwnd, SHORT1FROMMP(mp1), SHORT2FROMMP(mp1));
// draws square at the current ptr pos
break;
case WM_CHAR: // key was pressed
if( SHORT2FROMMP( mp2 ) != VK_SPACE ) break; // only space is interesting
if( GBoard.GetfDrag() ) break; // do nothing while dragging
if( !GBoard.GetfShowLines() ){ // lines not visible yet
GBoard.SetfShowLines( TRUE );
WinSendMsg( pg->hwndTGraph, WM_DISPLAYLINES, 0, 0 );
}
break;
case WM_BUTTON1CLICK:
if( !InfoData.ShipsNotFound ) break; // game is finished
ptl.x = (LONG)SHORT1FROMMP( mp1 );
ptl.y = (LONG)SHORT2FROMMP( mp1 );
Row = GBoard.GetBoardRow( ptl.y );
Col = GBoard.GetBoardCol( ptl.x );
if( !Row || !Col ) break;
fHideSquare = TRUE;
WinSendMsg( pg->hwndTGraph, WM_SHOWPOINTERPOS, MPFROMHWND(hwnd),
MPFROM2SHORT( 0, 0 ) );
// GBoard.ShowPointerPos( hwnd, 0, 0 ); // hides pointer square
if(( aktscan = GBoard.GetDiscovered( Row, Col )) != -1 ){
WinSendMsg( pg->hwndTGraph, WM_DRAWPMPLACE, MPFROMHWND(hwnd),
MPFROMSH2CH( MAKESHORT(Row, Col),
(CHAR)aktscan,(CHAR)TRUE));
// umstricken auf WinPostMsg
// toggle Place display
} else { // scan Place
DosResetEventSem( hevWaitAfterScan, &ulResponse );
// DosBeep(500, 150 );
WinPostMsg( pg->hwndTGraph, WM_GRAPH_SCAN, MPFROMHWND(hwnd),
MPFROM2SHORT( Row, Col ) );
// DosBeep( 800, 150 );
WinWaitEventSem( hevWaitAfterScan, SEM_INDEFINITE_WAIT );
// DosBeep( 1000, 150 );
// first the scanning sounds must be played (and finished)
aktscan = GBoard.Scan( Row, Col );
if( aktscan == GBoard.GetShipNumber() + 10 ){
InfoData.ShipsNotFound--;
WinPostMsg( pg->hwndTSound, WM_SOUND_FOUNDSHIP, MPFROMHWND(hwnd), 0 );
} else {
if( aktscan )
WinPostMsg( pg->hwndTSound, WM_SOUND_FOUND,
MPFROMHWND(hwnd), MPFROMLONG( aktscan ) );
else
WinPostMsg( pg->hwndTSound, WM_SOUND_FOUND0, MPFROMHWND(hwnd), 0 );
}
WinWaitEventSem( hevWaitAfterScan, SEM_INDEFINITE_WAIT );
// waits until scanning is done, and only then displays the
// field icon
// hps = WinGetPS( hwnd );
WinSendMsg( pg->hwndTGraph, WM_DRAWPMPLACE, MPFROMHWND(hwnd),
MPFROMSH2CH( MAKESHORT(Row, Col),
(CHAR)aktscan,(CHAR)TRUE));
// umstricken auf WinPostMsg
WinPostMsg( pg->hwndTGraph, WM_SHOWSTATUSLINE, 0, 0 );
// ShowStatusLine( hps, GBoard.MovesNeeded(), InfoData.ShipsNotFound,
// GBoard.GetWinWidth(), GBoard.GetWinHeight() );
// WinReleasePS( hps );
if( !InfoData.ShipsNotFound ){ // game is finished, all ships found
Score = GBoard.MovesNeeded();
if ( !InfoData.ReturnLastHigh() // still space in the hiscore table
|| Score < InfoData.ReturnLastHigh() ){ // player kicks last one out
// player enters highscore table
WinPostMsg( pg->hwndTSound, WM_SOUND_NEWHISCORE, MPFROMHWND(hwnd), 0 );
WinWaitEventSem( hevHiScoreWin, SEM_INDEFINITE_WAIT );
// waits until the NEWHISCORE sound is actually played
WinDlgBox( HWND_DESKTOP, hwnd, HighScoreDlgProc, (HMODULE)0,
IDR_HIGHSCOREDLG, NULL );
WinPostMsg( hwnd, WM_COMMAND,
MPFROMSHORT(IDM_GAMEHIGH), (MPARAM)0 );
// show highscore-table
DosResetEventSem( hevHiScoreWin, &ulResponse ); // resets the sem again
} else {
WinPostMsg( pg->hwndTSound, WM_SOUND_LOST, MPFROMHWND(hwnd), 0 );
WinWaitEventSem( hevHiScoreWin, SEM_INDEFINITE_WAIT );
// waits until the NEWHISCORE sound is actually played
sprintf( msgtext,
"You needed %d moves to find the lost ships. " \
"To enter the highscore list you need %d moves." \
" So try again!", Score, InfoData.ReturnLastHigh() - 1 );
WinMessageBox( HWND_DESKTOP, hwnd, msgtext, "Oh, Shit!", 0,
MB_OK | MB_INFORMATION | MB_HELP );
}
}
}
fHideSquare = FALSE;
WinSendMsg( pg->hwndTGraph, WM_SHOWPOINTERPOS, MPFROMHWND(hwnd),
MPFROM2SHORT( ptl.x, ptl.y ) );
// GBoard.ShowPointerPos( hwnd, ptl.x, ptl.y ); // redisplay ptr square
break;
case WM_BUTTON2CLICK:
fHideSquare = TRUE;
WinSendMsg( pg->hwndTGraph, WM_SHOWPOINTERPOS, MPFROMHWND(hwnd),
MPFROM2SHORT( 0, 0 ) );
ptl.x = (LONG)SHORT1FROMMP( mp1 );
ptl.y = (LONG)SHORT2FROMMP( mp1 );
Row = GBoard.GetBoardRow( ptl.y );
Col = GBoard.GetBoardCol( ptl.x );
WinSendMsg( pg->hwndTGraph, WM_DRAWPMMARK, MPFROMHWND(hwnd),
MPFROM2SHORT( Row, Col ) );
fHideSquare = FALSE;
WinSendMsg( pg->hwndTGraph, WM_SHOWPOINTERPOS, MPFROMHWND(hwnd),
MPFROM2SHORT( ptl.x, ptl.y ) );
break;
case WM_COMMAND:
switch( SHORT1FROMMP( mp1 ) ){
case IDM_GAMENEW:
GBoard.NewGame();
InfoData.ShipsNotFound = GBoard.GetShipNumber();
RealPaint = TRUE;
WinInvalidateRect( hwnd, NULL, TRUE );
break;
case IDM_GAMESETTINGS:
if( WinDlgBox( HWND_DESKTOP, hwndFrame,
GameSettingsDlgProc, (HMODULE)0,
IDR_GAMESETTINGSDLG, NULL ) ){
// screen must be repainted
RealPaint = TRUE;
WinInvalidateRect( hwnd, NULL, TRUE );
}
break;
case IDM_GAMEHIGH:
if( !WinDlgBox( HWND_DESKTOP, hwndFrame,
ShowHighDlgProc, (HMODULE)0,
IDR_SHOWHIGHDLG, NULL ) ){ // user requested "Clear"
if( WinMessageBox( HWND_DESKTOP, hwndMain,
"Do you really want to eradicate all those " \
"arduously achieved highscores?",
"Clear Highscores",
0, MB_OKCANCEL | MB_WARNING ) == MBID_OK )
InfoData.ResetHigh();
}
break;
case IDM_HELPINDEX: // help index
WinSendMsg( hwndHelp, HM_HELP_INDEX, 0, 0 );
break;
case IDM_HELPGENERAL: // general help
WinSendMsg( hwndHelp, HM_EXT_HELP, 0, 0 );
break;
case IDM_HELPEXTENDED: // help on help (system page)
WinSendMsg( hwndHelp, HM_DISPLAY_HELP, 0, 0 );
break;
case IDM_HELPKEYS: // keys help
WinSendMsg( hwndHelp, HM_KEYS_HELP, 0, 0 );
break;
case IDM_HELPPRODUCTINFO:
ulResponse = WinDlgBox( HWND_DESKTOP, hwndFrame,
ProdInfoDlgProc, (HMODULE)0,
IDR_PRODINFODLG, NULL );
break;
}
break;
case HM_QUERY_KEYS_HELP: // system asks which page to display
return MRFROMSHORT( PANEL_HELPKEYS );
case HM_HELPSUBITEM_NOT_FOUND:
return (MRESULT)FALSE;
case WM_USER_ACK: // graphics task finished its work
// DosBeep( 1000, 150 );
switch( (ULONG)mp1 ){
case WM_USER_PAINT:
WinQueryPointerPos( HWND_DESKTOP, &ptl );
WinMapWindowPoints( HWND_DESKTOP, hwnd, &ptl, 1);
fHideSquare = FALSE;
WinSendMsg( pg->hwndTGraph, WM_SHOWPOINTERPOS, MPFROMHWND(hwnd),
MPFROM2SHORT( ptl.x, ptl.y ) );
// GBoard.ShowPointerPos( hwnd, ptl.x, ptl.y );
// painting has finished, square can be displayed now
break;
}
break;
case WM_SOUND_ACK:
switch( (ULONG)mp1 ){
case WM_SOUND_INTRO:
break;
}
break;
default:
return (MRESULT)WinDefWindowProc( hwnd, msg, mp1, mp2 );
} // end switch( msg )
return (MRESULT)WinDefWindowProc( hwnd, msg, mp1, mp2 );
} // end MRESULT EXPENTRY WndProc()
MRESULT EXPENTRY ClientWndProc (HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
static CHAR *szButtonLabel[] = { "Smaller", "Larger" } ;
static HWND hwndFrame, hwndButton[2] ;
static INT cxClient, cyClient, cxChar, cyChar ;
FONTMETRICS fm ;
HPS hps ;
INT id ;
RECTL rcl ;
switch (msg)
{
case WM_CREATE :
hwndFrame = WinQueryWindow (hwnd, QW_PARENT) ;
hps = WinGetPS (hwnd) ;
GpiQueryFontMetrics (hps, sizeof fm, &fm) ;
cxChar = fm.lAveCharWidth ;
cyChar = fm.lMaxBaselineExt ;
WinReleasePS (hps) ;
for (id = 0 ; id < 2 ; id++)
hwndButton[id] = WinCreateWindow (
hwnd, // Parent
WC_BUTTON, // Class
szButtonLabel[id], // Text
WS_VISIBLE | // Style
BS_PUSHBUTTON,
0, 0, // Position
12 * cxChar, // Width
2 * cyChar, // Height
hwnd, // Owner
HWND_BOTTOM, // Placement
id, // ID
NULL, // Ctrl Data
NULL) ; // Pres Params
return 0 ;
case WM_SIZE :
cxClient = SHORT1FROMMP (mp2) ;
cyClient = SHORT2FROMMP (mp2) ;
for (id = 0 ; id < 2 ; id++)
WinSetWindowPos (hwndButton[id], NULLHANDLE,
cxClient / 2 + (14 * id - 13) * cxChar,
(cyClient - 2 * cyChar) / 2,
0, 0, SWP_MOVE) ;
return 0 ;
case WM_COMMAND:
WinQueryWindowRect (hwnd, &rcl) ;
WinMapWindowPoints (hwnd, HWND_DESKTOP, (PPOINTL) &rcl, 2) ;
switch (COMMANDMSG(&msg)->cmd) // Child ID
{
case 0: // "Smaller"
rcl.xLeft += cxClient / 20 ;
rcl.xRight -= cxClient / 20 ;
rcl.yBottom += cyClient / 20 ;
rcl.yTop -= cyClient / 20 ;
break ;
case 1: // "Larger"
rcl.xLeft -= cxClient / 20 ;
rcl.xRight += cxClient / 20 ;
rcl.yBottom -= cyClient / 20 ;
rcl.yTop += cyClient / 20 ;
break ;
}
WinCalcFrameRect (hwndFrame, &rcl, FALSE) ;
WinSetWindowPos (hwndFrame, NULLHANDLE,
rcl.xLeft, rcl.yBottom,
rcl.xRight - rcl.xLeft,
rcl.yTop - rcl.yBottom,
SWP_MOVE | SWP_SIZE) ;
return 0 ;
case WM_ERASEBACKGROUND:
return MRFROMSHORT (1) ;
}
return WinDefWindowProc (hwnd, msg, mp1, mp2) ;
}
static MRESULT APIENTRY Create ( HWND Window, MESG, MPARAM1 mp1, MPARAM2 ) {
/**************************************************************************
* Allocate instance data. *
**************************************************************************/
PDATA Data = PDATA ( malloc ( sizeof(DATA) ) ) ;
if ( Data == NULL ) {
Log ( "ERROR: Unable to allocate instance memory for horizontal ruler." ) ;
return ( MRFROMSHORT ( 1 ) ) ;
} /* endif */
Sys_SetWindowData ( Window, Data ) ;
/**************************************************************************
* Grab any parameters from the WM_CREATE message. *
**************************************************************************/
PHORZRULER_PARMS Parms = PHORZRULER_PARMS ( PVOIDFROMMP ( mp1 ) ) ;
Data->IniData = Parms->IniData ;
Data->MainWindow = Parms->MainWindow ;
/**************************************************************************
* Create the device context object for the window. *
**************************************************************************/
WinOpenWindowDC ( Window ) ;
Data->pDevice = new DeviceContext ( "HRuler", Window ) ;
/**************************************************************************
* Load the pointers. *
**************************************************************************/
Data->MarginPtr = WinLoadPointer ( HWND_DESKTOP, 0, ID_MARGIN ) ;
Data->TabstopPtr = WinLoadPointer ( HWND_DESKTOP, 0, ID_TABSTOP ) ;
/**************************************************************************
* Perform all other instance initializations. *
**************************************************************************/
Data->Metric = FALSE ;
Data->fxZoom = MAKEFIXED ( 1, 0 ) ;
Data->PageWidth = 9000 ;
Data->TopLeft = 9000 ;
Data->LeftMargin = 0 ;
Data->RightMargin = 9000 ;
Data->TabCount = 0 ;
memset ( Data->Tabs, 0, sizeof(Data->Tabs) ) ;
Data->Tick = 0 ;
Data->Capture = FALSE ;
Data->Mode = NOTMOVING ;
Data->SettingFont = FALSE ;
/**************************************************************************
* Success? Return no error. *
**************************************************************************/
return ( MRFROMSHORT ( 0 ) ) ;
}
static MRESULT APIENTRY SetTick ( HWND Window, MESG, MPARAM1 mp1, MPARAM2 ) {
/**************************************************************************
* Find the instance data. *
**************************************************************************/
PDATA Data = PDATA ( Sys_GetWindowData ( Window ) ) ;
/**************************************************************************
* Get the new tick-mark position from the message. *
**************************************************************************/
LONG Tick = LONGFROMMP ( mp1 ) ;
/**************************************************************************
* If only the tick-mark has changed, move it. *
**************************************************************************/
if ( Data->Tick != Tick ) {
/***********************************************************************
* Get the presentation space. *
***********************************************************************/
WorkSpace PS ( "HRuler::SetTick", 0, Window, Data->pDevice, int(Data->Metric) ) ;
PS.SetTransform ( Data->fxZoom, int(Data->TopLeft), 0 ) ;
/***********************************************************************
* Find out some background information. *
***********************************************************************/
RECTL Rectangle ;
WinQueryWindowRect ( Window, &Rectangle ) ;
PS.Transform ( CVTC_DEVICE, CVTC_DEFAULTPAGE, Rectangle ) ;
/***********************************************************************
* Erase the previous hairline. *
***********************************************************************/
if ( Data->Tick ) {
PS.SetMix ( FM_INVERT ) ;
PS.SetLineType ( LINETYPE_ALTERNATE ) ;
POINTL Point = { Data->Tick, Rectangle.yBottom } ;
PS.Move ( Point ) ;
Point.y = Rectangle.yTop ;
PS.DrawLine ( Point ) ;
} /* endif */
/***********************************************************************
* Save the current hairline position. *
***********************************************************************/
Data->Tick = Tick ;
/***********************************************************************
* Draw a hairline showing the current position. *
***********************************************************************/
if ( Data->Tick ) {
PS.SetMix ( FM_INVERT ) ;
PS.SetLineType ( LINETYPE_ALTERNATE ) ;
POINTL Point = { Data->Tick, Rectangle.yBottom } ;
PS.Move ( Point ) ;
Point.y = Rectangle.yTop ;
PS.DrawLine ( Point ) ;
} /* endif */
} /* endif */
/**************************************************************************
* We're done. *
**************************************************************************/
return ( MRFROMSHORT ( 0 ) ) ;
}
MRESULT EXPENTRY ClientWndProc ( HWND hwndWnd, ULONG ulMsg, MPARAM mpParm1, MPARAM mpParm2 )
{
switch ( ulMsg )
{
// For HELP debugging
#if 0
case HM_ERROR:
{
CHAR szTempBuffer[256];
sprintf( szTempBuffer, "Received HM_ERROR message, mp1=0X%8.8X", (ULONG)mpParm1 );
WinMessageBox ( HWND_DESKTOP, HWND_DESKTOP, szTempBuffer, "HM_ERROR", 0, MB_OK );
}
break;
case HM_EXT_HELP_UNDEFINED:
WinMessageBox ( HWND_DESKTOP, HWND_DESKTOP, "Received HM_EXT_HELP_UNDEFINED message", "HM_EXT_HELP_UNDEFINED", 0, MB_OK );
break;
case HM_HELPSUBITEM_NOT_FOUND:
WinMessageBox ( HWND_DESKTOP, HWND_DESKTOP, "Received HM_HELPSUBITEM_NOT_FOUND message", "HM_HELPSUBITEM_NOT_FOUND", 0, MB_OK );
break;
#endif
case HM_QUERY_KEYS_HELP:
return (MRESULT)IDP_KEYS_INFO;
break;
case WM_BUTTON1CLICK:
MoveCursorToPointer( hwndWnd, (*(POINTS *)&mpParm1).x, (*(POINTS *)&mpParm1).y );
break;
#if 0
case WM_BUTTON2CLICK:
{
HPS hpsClient;
POINTL ptl;
INT xC, yC;
xC = ( ( (*(POINTS *)&mpParm1).x - cxChar) / cxChar );
yC = ( ( cyClient - (*(POINTS *)&mpParm1).y ) / cyChar );
hpsClient = WinGetPS( hwndWnd );
GpiSetColor( hpsClient, CLR_PALEGRAY );
if ( xC < 10 )
GpiSetMix( hpsClient, FM_XOR );
else if ( xC < 20 )
GpiSetMix( hpsClient, FM_INVERT );
else if ( xC < 30 )
GpiSetMix( hpsClient, FM_NOTXORSRC );
else if ( xC < 40 )
GpiSetMix( hpsClient, FM_NOTMASKSRC );
else if ( xC < 50 )
GpiSetMix( hpsClient, FM_SUBTRACT );
/// GpiSetBackColor( hpsClient, CLR_PALEGRAY );
/// GpiSetBackMix( hpsClient, BM_OVERPAINT );
/// ptl.x = ( ( (*(POINTS *)&mpParm1).x - cxChar ) / cxChar ) * cxChar + cxChar;
/// ptl.y = ( ( (*(POINTS *)&mpParm1).y - cyClient ) / cyChar - 1 ) * cyChar + cyClient;
ptl.x = cxChar + ( xC * cxChar );
ptl.y = cyClient - ( ( yC + 1) * cyChar );
GpiMove( hpsClient, &ptl );
ptl.x += cxChar;
ptl.y += cyChar;
if ( yC < 5 )
GpiBox( hpsClient, DRO_FILL, &ptl, 0, 0 );
else
GpiBox( hpsClient, DRO_OUTLINE, &ptl, 0, 0 );
/// GpiSetBackColor( hpsClient, CLR_BACKGROUND );
/// GpiSetMix( hpsClient, FM_DEFAULT );
WinReleasePS( hpsClient );
}
break;
#endif
case WM_CHAR:
if ( !( CHARMSG(&ulMsg)->fs & KC_KEYUP ) )
{
if ( CHARMSG(&ulMsg)->fs & KC_CHAR )
{
ProcessCharMsg( hwndWnd, ulMsg, mpParm1, mpParm2 );
}
else if ( CHARMSG(&ulMsg)->fs & KC_VIRTUALKEY )
{
if ( !ProcessCursorMsg( hwndWnd, ulMsg, mpParm1, mpParm2 ) )
{
return WinDefWindowProc( hwndWnd, ulMsg, mpParm1, mpParm2 );
}
}
}
break;
case WM_CLOSE:
if ( QueryAbandonChanges( hwndWnd ) )
return WinDefWindowProc ( hwndWnd, ulMsg, mpParm1, mpParm2 );
break;
case WM_COMMAND:
return ProcessCommandMsg( hwndWnd, ulMsg, mpParm1, mpParm2 );
break;
case WM_CREATE:
hwndMenu = WinWindowFromID( WinQueryWindow( hwndWnd, QW_PARENT ), FID_MENU );
hwndHScroll = WinWindowFromID( WinQueryWindow( hwndWnd, QW_PARENT ), FID_HORZSCROLL );
hwndVScroll = WinWindowFromID( WinQueryWindow( hwndWnd, QW_PARENT ), FID_VERTSCROLL );
SetWindowTitle( hwndWnd );
break;
case WM_DESTROY:
ClearFile( hwndWnd );
break;
case WM_ERASEBACKGROUND:
return MRFROMSHORT ( TRUE ) ;
case WM_HELP:
ProcessHelpMessage( hwndWnd, mpParm1, mpParm2 );
break;
case WM_HSCROLL:
if ( !ProcessHScrollMsg( hwndWnd, ulMsg, mpParm1, mpParm2 ) )
return WinDefWindowProc( hwndWnd, ulMsg, mpParm1, mpParm2 );
break;
case WM_PAINT:
PaintScreen( hwndWnd );
break;
case WM_SAVEAPPLICATION:
SaveSettings( hwndWnd, habAnchor );
return WinDefWindowProc( hwndWnd, ulMsg, mpParm1, mpParm2 );
break;
case WM_SETFOCUS:
if ( SHORT1FROMMP( mpParm2 ) )
CreateCursor( hwndWnd );
else
DestroyCursor( hwndWnd );
break;
case WM_SIZE:
UpdateWindowSize( hwndWnd, SHORT1FROMMP( mpParm2), SHORT2FROMMP( mpParm2 ) );
if ( hwndWnd == WinQueryFocus( HWND_DESKTOP ) )
{
DestroyCursor( hwndWnd );
CreateCursor( hwndWnd );
}
break;
case WM_VSCROLL:
if ( !ProcessVScrollMsg( hwndWnd, ulMsg, mpParm1, mpParm2 ) )
return WinDefWindowProc( hwndWnd, ulMsg, mpParm1, mpParm2 );
break;
default:
return WinDefWindowProc( hwndWnd, ulMsg, mpParm1, mpParm2 );
break;
}
return MRFROMSHORT ( FALSE ) ;
}
MRESULT ProcessCommandMsg ( HWND hwndWnd, ULONG ulMsg, MPARAM mpParm1, MPARAM mpParm2 )
{
switch ( SHORT1FROMMP( mpParm1 ) )
{
/*
* First, the menu selections.
*/
case IDM_FILE_OPEN:
if ( QueryAbandonChanges( hwndWnd ) )
{
if ( FileOpenDialog( hwndWnd, NULL ) )
{
SetWindowTitle( hwndWnd );
UpdateScreenLimits( hwndWnd, TRUE );
}
}
break;
case IDM_FILE_SAVE:
FileSaveDialog( hwndWnd, szFileName );
SetWindowTitle( hwndWnd );
break;
case IDM_FILE_SAVE_AS:
FileSaveDialog( hwndWnd, NULL );
SetWindowTitle( hwndWnd );
break;
case IDM_FILE_CLEAR:
if ( QueryAbandonChanges( hwndWnd ) )
{
ClearFile( hwndWnd );
SetWindowTitle( hwndWnd );
UpdateScreenLimits( hwndWnd, TRUE );
}
break;
case IDM_FILE_ALLOCATE:
if ( QueryAbandonChanges( hwndWnd ) )
{
if ( FileAllocateDialog( hwndWnd ) )
{
SetWindowTitle( hwndWnd );
UpdateScreenLimits( hwndWnd, TRUE );
}
}
break;
case IDM_FILE_RESIZE:
if ( FileResizeDialog( hwndWnd ) )
{
UpdateScreenLimits( hwndWnd, TRUE );
}
break;
case IDM_FILE_EXIT:
if ( QueryAbandonChanges( hwndWnd ) )
{
ClearFile( hwndWnd );
WinPostMsg(hwndWnd, WM_QUIT, 0L, 0L);
}
break;
case IDM_EDIT_CUT:
if ( EditCut( hwndWnd ) )
{
SetWindowTitle( hwndWnd );
UpdateScreenLimits( hwndWnd, TRUE );
}
break;
case IDM_EDIT_COPY:
if ( EditCopy( hwndWnd ) )
{
SetWindowTitle( hwndWnd );
UpdateScreenLimits( hwndWnd, TRUE );
}
break;
case IDM_EDIT_PASTE:
if ( EditPaste( hwndWnd ) )
{
SetWindowTitle( hwndWnd );
UpdateScreenLimits( hwndWnd, TRUE );
}
break;
case IDM_EDIT_DELETE:
if ( EditDelete( hwndWnd ) )
{
SetWindowTitle( hwndWnd );
UpdateScreenLimits( hwndWnd, TRUE );
}
break;
case IDM_EDIT_INSERT:
if ( EditInsert( hwndWnd ) )
{
SetWindowTitle( hwndWnd );
UpdateScreenLimits( hwndWnd, TRUE );
}
break;
case IDM_SEARCH_FORWARD:
SearchForward( hwndWnd );
break;
case IDM_SEARCH_BACKWARD:
SearchBackward( hwndWnd );
break;
case IDM_SEARCH_AGAIN:
SearchAgain( hwndWnd );
break;
case IDM_REPLACE_FORWARD:
ReplaceForward( hwndWnd );
break;
case IDM_REPLACE_BACKWARD:
ReplaceBackward( hwndWnd );
break;
case IDM_REPLACE_AGAIN:
ReplaceAgain( hwndWnd );
break;
case IDM_GOTO_OFFSET:
GotoOffset( hwndWnd );
break;
case IDM_OPTIONS_FONT:
FontSelectDialog( hwndWnd );
break;
case IDM_OPTIONS_READONLY:
bReadOnly ^= TRUE;
WinSendMsg( hwndMenu, MM_SETITEMATTR,
MPFROM2SHORT( IDM_OPTIONS_READONLY, TRUE ),
MPFROM2SHORT( MIA_CHECKED, bReadOnly ? MIA_CHECKED : 0 ) );
break;
case IDM_OPTIONS_AUTORESIZE:
bAutoResize ^= TRUE;
WinSendMsg( hwndMenu, MM_SETITEMATTR,
MPFROM2SHORT( IDM_OPTIONS_AUTORESIZE, TRUE ),
MPFROM2SHORT( MIA_CHECKED, bAutoResize ? MIA_CHECKED : 0 ) );
if ( bAutoResize )
UpdateScreenLimits( hwndWnd, TRUE );
break;
case IDM_OPTIONS_REGISTER:
DisplayRegistrationPanel( hwndWnd );
break;
case IDM_DISPLAY:
DisplayModeDialog( hwndWnd );
break;
/*
* Next, the DISPLAY dialog accelerator keys
*/
case IDD_DISPLAY_OFFSET_OCTAL:
case IDD_DISPLAY_OFFSET_DECIMAL:
case IDD_DISPLAY_OFFSET_HEX:
case IDD_DISPLAY_ENTITY_OCTAL:
case IDD_DISPLAY_ENTITY_DECIMAL:
case IDD_DISPLAY_ENTITY_HEX:
case IDD_DISPLAY_1_BYTE:
case IDD_DISPLAY_2_BYTE:
case IDD_DISPLAY_4_BYTE:
DisplayModeAccelKey( hwndWnd, SHORT1FROMMP( mpParm1 ) );
break;
/*
* And the default
*/
default:
return WinDefWindowProc( hwndWnd, ulMsg, mpParm1, mpParm2 );
break;
}
return MRFROMSHORT ( FALSE ) ;
}
// ---------------------------------------------------------------------------
// Main Frame window proc
// ---------------------------------------------------------------------------
MRESULT EXPENTRY wxFrameMainWndProc( HWND hWnd,
ULONG ulMsg,
MPARAM wParam,
MPARAM lParam )
{
MRESULT rc = (MRESULT)0;
bool bProcessed = false;
wxFrame* pWnd = NULL;
pWnd = (wxFrame*) wxFindWinFromHandle((WXHWND) hWnd);
switch (ulMsg)
{
case WM_QUERYFRAMECTLCOUNT:
if(pWnd && pWnd->m_fnOldWndProc)
{
USHORT uItemCount = SHORT1FROMMR(pWnd->m_fnOldWndProc(hWnd, ulMsg, wParam, lParam));
rc = MRFROMSHORT(uItemCount);
}
break;
case WM_FORMATFRAME:
/////////////////////////////////////////////////////////////////////////////////
// Applications that subclass frame controls may find that the frame is already
// subclassed the number of frame controls is variable.
// The WM_FORMATFRAME and WM_QUERYFRAMECTLCOUNT messages must always be
// subclassed by calling the previous window procedure and modifying its result.
////////////////////////////////////////////////////////////////////////////////
{
int nItemCount;
int i;
PSWP pSWP = NULL;
RECTL vRectl;
RECTL vRstb;
RECTL vRtlb;
int nHeight = 0;
int nHeight2 = 0;
int nWidth = 0;
pSWP = (PSWP)PVOIDFROMMP(wParam);
nItemCount = SHORT1FROMMR(pWnd->m_fnOldWndProc(hWnd, ulMsg, wParam, lParam));
if(pWnd->m_frameStatusBar)
{
::WinQueryWindowRect(pWnd->m_frameStatusBar->GetHWND(), &vRstb);
pWnd->m_frameStatusBar->GetSize(NULL, &nHeight);
}
if(pWnd->m_frameToolBar)
{
::WinQueryWindowRect(pWnd->m_frameToolBar->GetHWND(), &vRtlb);
pWnd->m_frameToolBar->GetSize(&nWidth, &nHeight2);
}
::WinQueryWindowRect(pWnd->m_hFrame, &vRectl);
::WinMapWindowPoints(pWnd->m_hFrame, HWND_DESKTOP, (PPOINTL)&vRectl, 2);
::WinCalcFrameRect(pWnd->m_hFrame, &vRectl, TRUE);
::WinMapWindowPoints(HWND_DESKTOP, pWnd->m_hFrame, (PPOINTL)&vRectl, 2);
for(i = 0; i < nItemCount; i++)
{
if(pWnd->m_hWnd && pSWP[i].hwnd == pWnd->m_hWnd)
{
if (pWnd->m_frameToolBar && pWnd->m_frameToolBar->GetWindowStyleFlag() & wxTB_TOP)
{
pSWP[i].x = vRectl.xLeft;
pSWP[i].y = vRectl.yBottom + nHeight;
pSWP[i].cx = vRectl.xRight - vRectl.xLeft;
pSWP[i].cy = vRectl.yTop - vRectl.yBottom - (nHeight + nHeight2);
}
else if (pWnd->m_frameToolBar && pWnd->m_frameToolBar->GetWindowStyleFlag() & wxTB_BOTTOM)
{
pSWP[i].x = vRectl.xLeft;
pSWP[i].y = vRectl.yBottom + nHeight + nHeight2;
pSWP[i].cx = vRectl.xRight - vRectl.xLeft;
pSWP[i].cy = vRectl.yTop - vRectl.yBottom - (nHeight + nHeight2);
}
else if (pWnd->m_frameToolBar && pWnd->m_frameToolBar->GetWindowStyleFlag() & wxTB_LEFT)
{
pSWP[i].x = vRectl.xLeft + nWidth;
pSWP[i].y = vRectl.yBottom + nHeight;
pSWP[i].cx = vRectl.xRight - (vRectl.xLeft + nWidth);
pSWP[i].cy = vRectl.yTop - vRectl.yBottom - nHeight;
}
else
{
pSWP[i].x = vRectl.xLeft;
pSWP[i].y = vRectl.yBottom + nHeight;
pSWP[i].cx = vRectl.xRight - (vRectl.xLeft + nWidth);
pSWP[i].cy = vRectl.yTop - vRectl.yBottom - nHeight;
}
pSWP[i].fl = SWP_SIZE | SWP_MOVE | SWP_SHOW;
pSWP[i].hwndInsertBehind = HWND_TOP;
}
}
bProcessed = true;
rc = MRFROMSHORT(nItemCount);
}
break;
default:
if(pWnd && pWnd->m_fnOldWndProc)
rc = pWnd->m_fnOldWndProc(hWnd, ulMsg, wParam, lParam);
else
rc = ::WinDefWindowProc(hWnd, ulMsg, wParam, lParam);
}
return rc;
} // end of wxFrameMainWndProc
static MRESULT APIENTRY Button1Down ( HWND Window, MESG, MPARAM1 mp1, MPARAM2 ) {
/***************************************************************************
* Find the instance data. *
***************************************************************************/
PDATA Data = PDATA ( Sys_GetWindowData ( Window ) ) ;
/***************************************************************************
* Find out where the mouse touched. *
***************************************************************************/
RECTL Rectangle ;
WinQueryWindowRect ( Window, &Rectangle ) ;
WorkSpace PS ( "HRuler::Button1Down", 0, Window, Data->pDevice, int(Data->Metric) ) ;
PS.SetTransform ( Data->fxZoom, int(Data->TopLeft), 0 ) ;
POINTL Mouse = { SHORT1FROMMP(mp1), SHORT2FROMMP(mp1) } ;
PS.Transform ( CVTC_DEVICE, CVTC_DEFAULTPAGE, 1, &Mouse ) ;
PS.Transform ( CVTC_DEVICE, CVTC_DEFAULTPAGE, Rectangle ) ;
POINTL ButtonSize = { 8, 8 } ;
PS.Transform ( CVTC_DEVICE, CVTC_PAGE, 1, &ButtonSize ) ;
#ifdef DEBUG
Log ( "HRuler::Button1Down: Mouse at %i,%i (%i,%i). Rectangle %i,%i-%i,%i. ButtonSize %i.%i (8x8).",
Mouse.x, Mouse.y, SHORT1FROMMP(mp1), SHORT2FROMMP(mp1),
Rectangle.xLeft, Rectangle.yBottom, Rectangle.xRight, Rectangle.yTop,
ButtonSize.x, ButtonSize.y ) ;
#endif
/***************************************************************************
* If the mouse isn't touching in the button area, return. *
***************************************************************************/
if ( Mouse.y < Rectangle.yTop - ButtonSize.y ) {
Sys_BeepNote ( ) ;
return ( MRFROMSHORT ( FALSE ) ) ;
} /* endif */
/***************************************************************************
* If the mouse is beyond the margins, return. *
***************************************************************************/
if ( ( Mouse.x < Data->LeftMargin ) OR ( Mouse.x > Data->RightMargin+ButtonSize.x ) ) {
Sys_BeepNote ( ) ;
return ( MRFROMSHORT ( FALSE ) ) ;
} /* endif */
/***************************************************************************
* If mouse is touching the left margin button, set mode to MOVELEFT. *
***************************************************************************/
if ( ( Mouse.x >= Data->LeftMargin ) AND ( Mouse.x <= Data->LeftMargin+ButtonSize.x ) ) {
Data->Mode = MOVELEFT ;
Data->Ptr = Data->MarginPtr ;
} /* endif */
/***************************************************************************
* If mouse is touching the right margin button, set mode to MOVERIGHT. *
***************************************************************************/
else if ( ( Mouse.x >= Data->RightMargin-ButtonSize.x ) AND ( Mouse.x <= Data->RightMargin ) ) {
Data->Mode = MOVERIGHT ;
Data->Ptr = Data->MarginPtr ;
} /* endif */
/***************************************************************************
* Else, find which tab-stop, if any, we're touching. *
***************************************************************************/
else {
for ( int i=0; i<Data->TabCount; i++ ) {
if ( ( Mouse.x >= Data->Tabs[i] ) AND ( Mouse.x <= Data->Tabs[i]+ButtonSize.x ) ) {
Data->Mode = MOVETAB ;
Data->TabIndex = USHORT ( i ) ;
break ;
} /* endif */
} /* endfor */
if ( i >= Data->TabCount ) {
Data->Mode = SETTAB ;
} /* endif */
Data->Ptr = Data->TabstopPtr ;
} /* endif */
/***************************************************************************
* Capture the mouse. *
***************************************************************************/
Data->Capture = TRUE ;
Sys_SetCapture ( Window ) ;
/***************************************************************************
* Set the new mouse pointer. *
***************************************************************************/
WinSetPointer ( HWND_DESKTOP, Data->Ptr ) ;
/***************************************************************************
* Get the keyboard focus. *
***************************************************************************/
Data->HadFocus = WinQueryFocus ( HWND_DESKTOP ) ;
Sys_SetFocus ( Window ) ;
/***************************************************************************
* Save the current hairline position. *
***************************************************************************/
Data->Tick = TICK(Mouse.x) ;
/***************************************************************************
* Draw a hairline showing the current position. *
***************************************************************************/
PS.SetMix ( FM_INVERT ) ;
PS.SetLineType ( LINETYPE_ALTERNATE ) ;
POINTL Point = { Data->Tick, Rectangle.yBottom } ;
PS.Move ( Point ) ;
Point.y = Rectangle.yTop ;
PS.DrawLine ( Point ) ;
/***************************************************************************
* We're done. *
***************************************************************************/
return ( MRFROMSHORT ( TRUE ) ) ;
}
static MRESULT APIENTRY MouseMove ( HWND Window, MESG msg, MPARAM1 mp1, MPARAM2 mp2 ) {
/***************************************************************************
* Find the instance data. *
***************************************************************************/
PDATA Data = PDATA ( Sys_GetWindowData ( Window ) ) ;
/***************************************************************************
* If the mouse wasn't captured, return. *
***************************************************************************/
if ( NOT Data->Capture )
return ( Sys_DefWindowProc ( Window, msg, mp1, mp2 ) ) ;
/***************************************************************************
* Get the presentation space. *
***************************************************************************/
WorkSpace PS ( "HRuler::MouseMove", 0, Window, Data->pDevice, int(Data->Metric) ) ;
PS.SetTransform ( Data->fxZoom, int(Data->TopLeft), 0 ) ;
/***************************************************************************
* Find out where the mouse touched. *
***************************************************************************/
RECTL Rectangle ;
WinQueryWindowRect ( Window, &Rectangle ) ;
POINTL Mouse = { SHORT1FROMMP(mp1), SHORT2FROMMP(mp1) } ;
PS.Transform ( CVTC_DEVICE, CVTC_DEFAULTPAGE, 1, &Mouse ) ;
PS.Transform ( CVTC_DEVICE, CVTC_DEFAULTPAGE, Rectangle ) ;
POINTL ButtonSize = { 8, 8 } ;
PS.Transform ( CVTC_DEVICE, CVTC_PAGE, 1, &ButtonSize ) ;
#ifdef DEBUG
Log ( "HRuler::MouseMove: Mouse at %i,%i (%i,%i). Rectangle %i,%i-%i,%i. ButtonSize %i.%i (8x8).",
Mouse.x, Mouse.y, SHORT1FROMMP(mp1), SHORT2FROMMP(mp1),
Rectangle.xLeft, Rectangle.yBottom, Rectangle.xRight, Rectangle.yTop,
ButtonSize.x, ButtonSize.y ) ;
#endif
/***************************************************************************
* Erase the previous hairline. *
***************************************************************************/
PS.SetMix ( FM_INVERT ) ;
PS.SetLineType ( LINETYPE_ALTERNATE ) ;
POINTL Point = { Data->Tick, Rectangle.yBottom } ;
PS.Move ( Point ) ;
Point.y = Rectangle.yTop ;
PS.DrawLine ( Point ) ;
/***************************************************************************
* Save the current hairline position. *
***************************************************************************/
Data->Tick = TICK(Mouse.x) ;
/***************************************************************************
* Draw a hairline showing the current position. *
***************************************************************************/
Point.x = Data->Tick ;
Point.y = Rectangle.yBottom ;
PS.Move ( Point ) ;
Point.y = Rectangle.yTop ;
PS.DrawLine ( Point ) ;
/***************************************************************************
* We're done. *
***************************************************************************/
return ( MRFROMSHORT ( TRUE ) ) ;
}
/*
* The prototype for ico_wpDrop was replaced by the following prototype:
*/
SOM_Scope MRESULT SOMLINK ico_wpDrop(DDIcon *somSelf, HWND hwndCnr,
PDRAGINFO pdrgInfo, PDRAGITEM pdrgItem)
{
WPObject* object;
WPObject* folderObject;
BOOL success;
CHAR szObjectFilename[CCHMAXPATH]; // Buffer for wpQueryRealName()
ULONG cb = sizeof(szObjectFilename); // Size of object
CHAR szSetupString[12 + CCHMAXPATH];
PSZ pszSetupString= &szSetupString[0];
USHORT rcDrop = RC_DROP_ERROR;
/* DDIconData *somThis = DDIconGetData(somSelf); */
DDIconMethodDebug("DDIcon","ico_wpDrop");
_Pmpf(("Preforming 'wpDrop'"));
object = GetOriginalObject(OBJECT_FROM_PREC(pdrgItem->ulItemID));
success = _wpQueryRealName(somSelf, szObjectFilename, &cb, TRUE);
/*
* Assign a new icons to the dropped object using _wpSetup. If the object
* is a folder and the "usOperation" is equal to "DO_COPY", then set the
* animation icon.
*/
if (success) {
if (_somIsA(object, _WPFolder))
{
/*
* A switch is used her since this portion of the code is going
* to be expanded in order to change the default icon for the
* wpFolder class.
*/
switch (pdrgInfo->usOperation) {
case DO_COPY:
strcpy(pszSetupString, "ICONNFILE=1,");
strcat(szSetupString, szObjectFilename);
success = _wpSetup(object, szSetupString);
_Pmpf(("DO_COPY _wpSetup returns : %d",success));
if (success) {
rcDrop = RC_DROP_ITEMCOMPLETE;
}
break;
default:
strcpy(pszSetupString, "ICONFILE=");
strcat(szSetupString, szObjectFilename);
success = _wpSetup(object, szSetupString);
_Pmpf(("_wpSetup returns : %d",success));
if (success) {
rcDrop = RC_DROP_ITEMCOMPLETE;
}
break;
}
} else {
strcpy(pszSetupString, "ICONFILE=");
strcat(szSetupString, szObjectFilename);
success = _wpSetup(object, szSetupString);
_Pmpf(("_wpSetup returns : %d",success));
if (success) {
rcDrop = RC_DROP_ITEMCOMPLETE;
}
}
}
return (MRFROMSHORT(rcDrop));
}
static
MRESULT EXPENTRY helpWndProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 )
{
static CHAR szText[ 256 ] = "";
static HPS hps = NULLHANDLE;
static USHORT width = 0, height = 0;
switch( msg )
{
case WM_CREATE :
{
FONTMETRICS fm;
strcpy( szText, (( PCREATESTRUCT )mp2 )->pszText );
hps = WinGetPS( hwnd );
GpiQueryFontMetrics( hps, sizeof( fm ), &fm );
width = fm.lAveCharWidth;
height = fm.lMaxAscender + fm.lMaxDescender;
return MRFROMSHORT( FALSE );
}
case WM_DESTROY :
WinReleasePS( hps );
return MRFROMSHORT( FALSE );
case WM_SETWINDOWPARAMS :
{
PWNDPARAMS pwp;
pwp = ( PWNDPARAMS )mp1;
if( pwp->fsStatus & WPM_TEXT )
strcpy( szText, pwp->pszText );
return MRFROMSHORT( TRUE );
}
case WM_PAINT :
{
RECTL rcl;
WinBeginPaint( hwnd, hps, NULL );
WinQueryWindowRect( hwnd, &rcl );
WinDrawBorder( hps, &rcl, 1, 1, CLR_BLACK, CLR_YELLOW, DB_INTERIOR );
WinDrawText( hps, -1, szText, &rcl, CLR_BLACK, CLR_YELLOW,
DT_CENTER | DT_VCENTER );
WinEndPaint( hps );
return MRFROMSHORT( 0 );
}
case WM_QUERY_CHAR_WIDTH :
return MRFROMSHORT( width );
case WM_QUERY_CHAR_HEIGHT :
return MRFROMSHORT( height );
}
return WinDefWindowProc( hwnd, msg, mp1, mp2 );
}
static MRESULT APIENTRY Paint ( HWND Window, MESG, MPARAM1, MPARAM2 ) {
/**************************************************************************
* Find the instance data. *
**************************************************************************/
PDATA Data = PDATA ( Sys_GetWindowData ( Window ) ) ;
/**************************************************************************
* Compute the current zoom factor. *
**************************************************************************/
double Zoom = (double) FIXEDINT ( Data->fxZoom ) ;
Zoom += (double) FIXEDFRAC ( Data->fxZoom ) / 0x10000L ;
/**************************************************************************
* Get presentation space and prepare it for use. *
**************************************************************************/
RECTL ClippingRectangle ;
WorkSpace PS ( "HRuler::Paint", 0, Window, Data->pDevice, int(Data->Metric), ClippingRectangle ) ;
PS.SetTransform ( Data->fxZoom, int(Data->TopLeft), 0 ) ;
PS.Transform ( CVTC_DEVICE, CVTC_DEFAULTPAGE, ClippingRectangle ) ;
/**************************************************************************
* Clear the window and draw a border. *
**************************************************************************/
RECTL WindowRectangle ;
WinQueryWindowRect ( Window, &WindowRectangle ) ;
WindowRectangle.xRight -- ;
WindowRectangle.yTop -- ;
PS.Transform ( CVTC_DEVICE, CVTC_DEFAULTPAGE, WindowRectangle ) ;
PS.SetColor ( Data->IniData->fRulerColors[0] ? Data->IniData->RulerColors[0] : RGB_WHITE ) ;
PS.FillBox ( WindowRectangle ) ;
PS.SetColor ( RGB_BLACK ) ;
PS.DrawBox ( WindowRectangle ) ;
/**************************************************************************
* Draw the left margin. *
**************************************************************************/
if ( ClippingRectangle.xLeft <= Data->LeftMargin ) {
PS.SetColor ( Data->IniData->fRulerColors[1] ? Data->IniData->RulerColors[1] : RGB_BLUE ) ;
PS.SetFillType ( PATSYM_HALFTONE ) ;
RECTL Box = { ClippingRectangle.xLeft, ClippingRectangle.yBottom,
Data->LeftMargin, ClippingRectangle.yTop } ;
PS.FillBox ( Box ) ;
PS.SetFillType ( PATSYM_DEFAULT ) ;
PS.SetColor ( RGB_BLACK ) ;
PS.SetLineType ( LINETYPE_ALTERNATE ) ;
POINTL Point = { Data->LeftMargin, ClippingRectangle.yTop } ;
PS.Move ( Point ) ;
Point.y = ClippingRectangle.yTop ;
PS.DrawLine ( Point ) ;
PS.SetLineType ( LINETYPE_SOLID ) ;
} /* endif */
POINTL Point = { Data->LeftMargin, WindowRectangle.yTop } ;
PS.Transform ( CVTC_DEFAULTPAGE, CVTC_DEVICE, 1, &Point ) ;
Point.y -= 8 ;
PS.DrawPointer ( Data->MarginPtr, Point, DP_NORMAL ) ;
/**************************************************************************
* Draw the right margin. *
**************************************************************************/
if ( ClippingRectangle.xRight >= Data->RightMargin ) {
PS.SetColor ( Data->IniData->fRulerColors[1] ? Data->IniData->RulerColors[1] : RGB_BLUE ) ;
PS.SetFillType ( PATSYM_HALFTONE ) ;
RECTL Box = { Data->RightMargin, ClippingRectangle.yBottom,
ClippingRectangle.xRight, ClippingRectangle.yTop } ;
PS.FillBox ( Box ) ;
PS.SetFillType ( PATSYM_DEFAULT ) ;
PS.SetColor ( RGB_BLACK ) ;
PS.SetLineType ( LINETYPE_ALTERNATE ) ;
Point.x = Data->RightMargin ;
Point.y = ClippingRectangle.yBottom ;
PS.Move ( Point ) ;
Point.y = ClippingRectangle.yTop ;
PS.DrawLine ( Point ) ;
PS.SetLineType ( LINETYPE_SOLID ) ;
} /* endif */
Point.x = Data->RightMargin ;
Point.y = WindowRectangle.yTop ;
PS.Transform ( CVTC_DEFAULTPAGE, CVTC_DEVICE, 1, &Point ) ;
Point.x -= 8 ;
Point.y -= 8 ;
PS.DrawPointer ( Data->MarginPtr, Point, DP_NORMAL ) ;
/**************************************************************************
* Draw the tab-stops. *
**************************************************************************/
for ( int i=0; i<Data->TabCount; i++ ) {
Point.x = Data->Tabs[i] ;
Point.y = WindowRectangle.yTop ;
PS.Transform ( CVTC_DEFAULTPAGE, CVTC_DEVICE, 1, &Point ) ;
Point.y -= 8 ;
PS.DrawPointer ( Data->TabstopPtr, Point, DP_NORMAL ) ;
} /* endfor */
/**************************************************************************
* Draw the ruler. *
**************************************************************************/
for ( long x=WindowRectangle.xLeft; x<WindowRectangle.xRight; x++ ) {
if ( x % ( Data->Metric ? 200 : 250 ) == 0 ) {
PS.SetColor ( RGB_BLACK ) ;
Point.x = x ;
Point.y = 0 ;
PS.Move ( Point ) ;
if ( x % 1000 == 0 ) {
Point.y = LONG ( 200.0 / Zoom ) ;
PS.DrawLine ( Point ) ;
Point.x += LONG ( 50.0 / Zoom ) ;
Point.y = LONG ( 50.0 / Zoom ) ;
char Text [10] ;
sprintf ( Text, "%i", int(x/1000) ) ;
PS.SetColor ( Data->IniData->fRulerColors[1] ? Data->IniData->RulerColors[1] : RGB_BLUE ) ;
PS.Move ( Point ) ;
PS.DrawText ( Text ) ;
} else if ( x % 500 == 0 ) {
Point.y = LONG ( 150.0 / Zoom ) ;
PS.DrawLine ( Point ) ;
} else {
Point.y = LONG ( 100.0 / Zoom ) ;
PS.DrawLine ( Point ) ;
} /* endif */
} /* endif */
} /* endfor */
/**************************************************************************
* We're done. *
**************************************************************************/
return ( MRFROMSHORT ( 0 ) ) ;
}
