/*--------------------------------------------------
* Capture mouse pointer
*-------------------------------------------------*/
PMWindow& PMWindow::capture_pointer( BOOL capture )
{
if( !WinSetCapture( HWND_DESKTOP, capture ? handle() : NULLHANDLE ))
PM_THROW_GUIERROR();
return *this;
}
static MRESULT endDrag(HWND hwnd)
{
ICQFRAME *cfg = WinQueryWindowPtr(hwnd,0);
DBGTracex(cfg->timer);
if(cfg->timer)
{
if(!WinStopTimer(WinQueryAnchorBlock(hwnd), hwnd, cfg->timer))
{
DBGMessage("Error stoping timer");
icqWriteSysLog(cfg->icq,PROJECT,"Failure stopping size timer");
}
}
cfg->timer = 0;
timer(hwnd);
cfg->xPos =
cfg->yPos =
cfg->xMouse =
cfg->yMouse = 0xFFFF;
cfg->flags &= ~(ICQFRAME_FLAG_SETCY|ICQFRAME_FLAG_SETCX|ICQFRAME_FLAG_MOVEX|ICQFRAME_FLAG_MOVEY);
if(WinQueryCapture(HWND_DESKTOP) == hwnd)
WinSetCapture(HWND_DESKTOP,NULLHANDLE);
return (MRESULT) TRUE;
}
static void MouseReleased( vout_display_t *vd, unsigned button )
{
vd->sys->button_pressed &= ~(1 << button);
if( !vd->sys->button_pressed )
WinSetCapture( HWND_DESKTOP, NULLHANDLE );
vout_display_SendEventMouseReleased( vd, button );
}
BOOL lboxEndDrag(PELBOX pelb, PMSEMSG pmmsg) {
LONG rc;
if (!(pelb->fl & ELBCS_ITEMDRAGGABLE) || !pelb->is.dragging)
return FALSE;
WinSetCapture(HWND_DESKTOP, NULLHANDLE);
WinStopTimer(pelb->hab, pelb->hlbx, DRAG_TIMERID);
pelb->is.dragging = 0;
if (pelb->is.where == ELBOX_DRAGIN) {
PVOID pitemdata;
PSZ psz;
ULONG cb;
SHORT dropitem = (SHORT)pelb->lbxwprc(pelb->hlbx, LM_QUERYTOPINDEX,
MPVOID, MPVOID) +
(pelb->rcltopitem.yTop - pmmsg->y + pelb->cyitem / 2) /
pelb->cyitem;
if (dropitem != pelb->dragitem && dropitem != (pelb->dragitem + 1)) {
rc = (LONG)WinSendMsg(WinQueryWindow(pelb->hwnd, QW_OWNER),
WM_CONTROL,
MPFROM2SHORT((USHORT)pelb->id, ELBXN_DROPITEM),
MPFROM2SHORT(pelb->dragitem, dropitem));
if (rc < 0) goto cancel;
if (rc > 0) return TRUE;
// ricava dati item draggato
cb = (ULONG)pelb->lbxwprc(pelb->hlbx, LM_QUERYITEMTEXTLENGTH,
(MPARAM)pelb->dragitem, MPVOID) + 1;
if (NULL != (psz = (PSZ)malloc(cb))) {
pelb->lbxwprc(pelb->hlbx, LM_QUERYITEMTEXT,
MPFROM2SHORT(pelb->dragitem, cb), (MPARAM)psz);
pitemdata = pelb->lbxwprc(pelb->hlbx, LM_QUERYITEMHANDLE,
(MPARAM)pelb->dragitem, MPVOID);
WinEnableWindowUpdate(pelb->hlbx, FALSE);
// lo copia nella nuova posizione
if (dropitem >= pelb->citems) dropitem = LIT_END;
dropitem = (SHORT)pelb->lbxwprc(pelb->hlbx, LM_INSERTITEM,
(MPARAM)dropitem, (MPARAM)psz);
pelb->lbxwprc(pelb->hlbx, LM_SETITEMHANDLE, (MPARAM)dropitem,
(MPARAM)pitemdata);
free(psz);
// se inserzione nuovo item precede vecchio aumenta indice
if (dropitem < pelb->dragitem) ++pelb->dragitem;
else --dropitem;
// cancella item da vecchia posizione
pelb->lbxwprc(pelb->hlbx, LM_DELETEITEM,
(MPARAM)pelb->dragitem, MPVOID);
// seleziona item riposizionato
pelb->lbxwprc(pelb->hlbx, LM_SELECTITEM,
(MPARAM)dropitem, (MPARAM)TRUE);
WinEnableWindowUpdate(pelb->hlbx, TRUE);
return TRUE;
} /* endif */
} /* endif */
} /* endif */
cancel:
WinAlarm(HWND_DESKTOP, WA_ERROR);
return TRUE;
} /* endif */
BOOL lboxBeginDrag(PELBOX pelb, PMSEMSG pmmsg) {
if (pelb->fl & ELBCS_ITEMDRAGGABLE) {
// in caso di errore cancella operazione
if (pelb->is.dragging) {
pelb->is.dragging = 0;
WinSetCapture(HWND_DESKTOP, NULLHANDLE);
WinStopTimer(pelb->hab, pelb->hlbx, DRAG_TIMERID);
return FALSE;
} // end if
// trova indice item trascinato
pelb->dragitem = (SHORT)pelb->lbxwprc(pelb->hlbx, LM_QUERYTOPINDEX,
MPVOID, MPVOID) +
(pelb->rcltopitem.yTop - pmmsg->y) / pelb->cyitem;
// se il mouse Š sopra (all'esterno) al primo item o se Š sotto
// l'ultimo suona allarme e restituisce true
if (pmmsg->y >= pelb->rcltopitem.yTop || pelb->dragitem >= pelb->citems)
goto cancel;
// se tutto Š a posto sposta il cursore sull'item draggato:
pelb->lbxwprc(pelb->hlbx, WM_BUTTON1DOWN,
MPFROM2SHORT(pmmsg->x, pmmsg->y), MPVOID);
pelb->lbxwprc(pelb->hlbx, WM_BUTTON1UP,
MPFROM2SHORT(pmmsg->x, pmmsg->y), MPVOID);
// notifica owner window evento inizio drag. Se l'owner restituisce
// TRUE l'operazione di drag viene cancellata
if (WinSendMsg(WinQueryWindow(pelb->hwnd, QW_OWNER), WM_CONTROL,
MPFROM2SHORT((USHORT)pelb->id, ELBXN_DRAGITEM),
MPFROM2SHORT(pelb->dragitem, pelb->citems)))
goto cancel;
pelb->is.dragging = 1;
pelb->is.where = ELBOX_DRAGIN;
WsetSysMouPtr(SPTR_MOVE);
WinSetCapture(HWND_DESKTOP, pelb->hlbx);
WinStartTimer(pelb->hab, pelb->hlbx, DRAG_TIMERID, 70);
return TRUE;
} // end if
return FALSE;
cancel:
pelb->is.dragging = 0;
WinAlarm(HWND_DESKTOP, WA_ERROR);
return TRUE;
}
static int set_hide_mouseptr(int val, void *param)
{
hide_mouseptr = val ? 1 : 0;
if (!hide_mouseptr && !visible && !FullscreenIsNow()) { // do we have to show the ptr again?
WinSetCapture(HWND_DESKTOP, NULLHANDLE);
WinShowPointer(HWND_DESKTOP, TRUE);
visible = TRUE;
}
return 0;
}
static VOID _captureMouse(PGROPDATA pGrop, BOOL fCapture)
{
SWP swp;
POINTL pointl;
if ( fCapture )
{
WinSetCapture( pGrop->hwndDT, pGrop->hwnd );
WinQueryWindowPos( pGrop->hwnd, &swp );
pointl.x = swp.cx / 2;
pointl.y = swp.cy / 2;
WinMapWindowPoints( pGrop->hwnd, pGrop->hwndDT, &pointl, 1 );
pGrop->lSkipMouseMove++;
WinSetPointerPos( pGrop->hwndDT, pointl.x, pointl.y );
}
else
WinSetCapture( pGrop->hwndDT, NULLHANDLE );
}
static void MousePressed( vout_display_t *vd, HWND hwnd, unsigned button )
{
if( WinQueryFocus( HWND_DESKTOP ) != hwnd )
WinSetFocus( HWND_DESKTOP, hwnd );
if( !vd->sys->button_pressed )
WinSetCapture( HWND_DESKTOP, hwnd );
vd->sys->button_pressed |= 1 << button;
vout_display_SendEventMousePressed( vd, button );
}
MRESULT EXPENTRY ClientWndProc (HWND hwnd, USHORT msg,
MPARAM mp1, MPARAM mp2)
{
static HWND hwndMenuPopup ;
HPS hps ;
POINTL ptlMouse ;
switch (msg)
{
case WM_CREATE:
hwndMenuPopup = WinLoadMenu (hwnd, NULL, ID_POPUP) ;
WinSetWindowPos (hwndMenuPopup, NULL,
0, 0, 0, 0, SWP_SIZE) ;
WinSetParent (hwndMenuPopup, HWND_DESKTOP, FALSE) ;
return 0 ;
case WM_BUTTON2UP:
WinQueryPointerPos (HWND_DESKTOP, &ptlMouse) ;
ptlMouse.y += WinQuerySysValue (HWND_DESKTOP,
SV_CYMENU) ;
WinSetWindowPos (hwndMenuPopup, NULL,
(SHORT) ptlMouse.x, (SHORT) ptlMouse.y,
0, 0, SWP_MOVE) ;
WinSendMsg (hwndMenuPopup, MM_SELECTITEM,
MPFROM2SHORT (IDM_POPUP, FALSE),
MPFROMSHORT (FALSE)) ;
WinSetCapture (HWND_DESKTOP, hwndMenuPopup) ;
return 0 ;
case WM_COMMAND:
switch (COMMANDMSG(&msg)->cmd)
{
case IDM_ABOUT:
WinDlgBox (HWND_DESKTOP, hwnd, AboutDlgProc,
NULL, IDD_ABOUT, NULL) ;
return 0 ;
}
break ;
case WM_PAINT:
hps = WinBeginPaint (hwnd, NULL, NULL) ;
GpiErase (hps) ;
WinEndPaint (hps) ;
return 0 ;
}
return WinDefWindowProc (hwnd, msg, mp1, mp2) ;
}
/*-----------------------------------------------
Back us out of zoom or pan mode.
Called for a variety of reasons from the
main window function.
-----------------------------------------------*/
VOID CancelZoomOrPan (HWND hwnd)
{
if (fPan) /* Panning */
{
/* erase the cross hairs */
EraseCrossHairs(hwnd);
WinSetCapture (HWND_DESKTOP, (HWND) NULL);
WinShowPointer (HWND_DESKTOP, TRUE); /* reshow normal mouse pointer */
fPan = FALSE;
fGoodPan = FALSE;
fZoomWin = FALSE;
}
if (fZoomWin) /* Zooming */
{
/* erase the Zoom Box */
EraseZoomBox(hwnd);
WinSetCapture (HWND_DESKTOP, (HWND) NULL);
WinShowPointer (HWND_DESKTOP, TRUE); /* reshow normal mouse pointer */
fZoomWin = FALSE;
fGoodZoom = FALSE;
fPan = FALSE;
}
}
static void destroy(HWND hwnd)
{
ICQFRAME *cfg = WinQueryWindowPtr(hwnd,0);
DBGPrint("Window \"%s\" destroyed",cfg->name);
if(WinQueryCapture(HWND_DESKTOP) == hwnd)
WinSetCapture(HWND_DESKTOP,NULLHANDLE);
if(!cfg || cfg->sz != sizeof(ICQFRAME))
return;
clearSkin(cfg);
if(cfg->icon)
WinDestroyPointer(cfg->icon);
cfg->sz = 0;
free(cfg);
}
MRESULT EXPENTRY scbProcedure(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
switch(msg)
{
case WM_CREATE:
create(hwnd,PVOIDFROMMP(mp2));
return WinDefWindowProc(hwnd, msg, mp1, mp2);
case 0x041E:
selectBitmap(hwnd, BITMAP_MOUSEOVER);
return WinDefWindowProc(hwnd, msg, mp1, mp2);
case 0x041F:
selectBitmap(hwnd, BITMAP_NORMAL);
return WinDefWindowProc(hwnd, msg, mp1, mp2);
case WM_BUTTON1DOWN:
selectBitmap(hwnd, BITMAP_PRESS);
break;
case WM_BUTTON1UP:
selectBitmap(hwnd, BITMAP_MOUSEOVER);
break;
case WM_DESTROY:
destroy(hwnd); /* Limpa bitmaps */
return WinDefWindowProc(hwnd, msg, mp1, mp2);
case WM_PAINT:
paint(hwnd);
break;
case WM_WINDOWPOSCHANGED:
ajustBackground(hwnd,PVOIDFROMMP(mp1));
return WinDefWindowProc(hwnd, msg, mp1, mp2);
case WMSKN_AJUSTSIZEPOS:
sizePos(hwnd,SHORT1FROMMP(mp1),SHORT2FROMMP(mp1),SHORT1FROMMP(mp2),SHORT2FROMMP(mp2));
break;
case WMSKN_QUERYPOS:
return getpos(hwnd);
case WMSKN_QUERYSIZE:
return getsize(hwnd);
case WMSKN_AJUSTPOS:
reposic(hwnd,SHORT1FROMMP(mp1),SHORT2FROMMP(mp1));
break;
case WMSKN_SETIMAGE: /* MP1=XBITMAP, MP2=ID */
loadImage(hwnd,SHORT1FROMMP(mp2),PVOIDFROMMP(mp1));
break;
case WMSKN_SETLIMITS:
setLimits(hwnd,LONGFROMMP(mp1),LONGFROMMP(mp2));
break;
case WMSKN_SETVALUE:
setValue(hwnd,LONGFROMMP(mp1));
break;
case WMSKN_UP:
moveCursor(hwnd, -1);
break;
case WMSKN_DOWN:
moveCursor(hwnd, 1);
break;
case WMSKN_CONNECT:
doConnect(hwnd,LONGFROMMP(mp1),LONGFROMMP(mp2));
break;
case WM_BEGINDRAG:
DBGMessage("Iniciou drag&drop");
((SLIDERDATA *) WinQueryWindowPtr(hwnd,0))->drag = TRUE;
WinSetCapture(HWND_DESKTOP,hwnd);
break;
case WM_ENDDRAG:
DBGMessage("Terminou drag&drop");
((SLIDERDATA *) WinQueryWindowPtr(hwnd,0))->drag = FALSE;
WinSetCapture(HWND_DESKTOP,NULLHANDLE);
break;
case WM_MOUSEMOVE:
if(((SLIDERDATA *) WinQueryWindowPtr(hwnd,0))->drag)
mouseMove(hwnd, SHORT1FROMMP(mp1), SHORT2FROMMP(mp1));
break;
default:
return WinDefWindowProc(hwnd, msg, mp1, mp2);
}
return 0;
}
MRESULT PMfrCommands (HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2)
{
/*
These are the routnes that handle the commands issued by
the FRACTINT for PM menus.
In most cases, they call another support routine to
handle or schedule the event requested by the user.
*/
SHORT sCommand = SHORT1FROMMP(mp1);
switch (sCommand)
{
case IDM_GO:
/* fire up the subtask */
cp.fContinueCalc = TRUE ;
if (npNewParms.fNewParms)
{
CopyParmsToBase();
/* GetMemoryBitmap(); */
SetSwitchEntry (hwnd, szTitleBar,
GetFractalName(cp.iFractType) );
}
cp.sSubAction = SUB_ACT_CALC; /* we want a Calculation */
DosSemClear (&cp.ulSemTrigger) ; /* release the subthread */
sStatus = STATUS_WORKING ;
/* WinInvalidateRect (hwnd, NULL, FALSE) ; */
UpdateMenuText (hwnd, IDM_FREEZE_HALT, szHalt);
EnableMenuItem (hwnd, IDM_GO, FALSE) ;
EnableMenuItem (hwnd, IDM_FREEZE_HALT, TRUE) ;
/* WinStartTimer (hab, hwnd, ID_TIMER, 5000); */
return 0 ;
case IDM_PAN:
/* Pan selected. Pan to where the cross hairs were */
PanNewCenter(hwnd);
fGoodPan = FALSE;
return 0;
case IDM_ZIN_WIN:
/* Zoom to the Window selected. */
EraseZoomBox(hwnd);
ZoomNewWindow(hwnd, TRUE); /* zoom in */
fGoodZoom = FALSE;
return 0;
case IDM_ZOUT_WIN:
/* Zoom to the Window selected. */
EraseZoomBox(hwnd);
ZoomNewWindow(hwnd, FALSE); /* zoom out */
fGoodZoom = FALSE;
return 0;
case IDM_FREEZE_HALT:
if (sStatus == STATUS_WORKING)
{
/* schedule the subthread to find a stopping place */
cp.fContinueCalc = FALSE ;
EnableMenuItem (hwnd, IDM_FREEZE_HALT, FALSE) ;
}
if (sStatus == STATUS_READY)
{
/* we Freeze to play with parms repeatedly */
/* make a copy to play with. We will keep */
/* working with only this copy */
InitNewParms(NULL);
/* now change state */
sStatus = STATUS_FROZEN;
EnableMenuItem (hwnd, IDM_FREEZE_HALT, FALSE);
}
return 0 ;
case IDM_ABOUT:
/* send up the About box */
WinDlgBox (HWND_DESKTOP, hwnd, AboutDlgProc,
(HMODULE) 0, IDD_ABOUT, NULL) ;
return 0 ;
case IDM_NEW_FRACTAL:
/*
* send up the Select Fractal Type box.
* On OK return, schedule the new parameters.
* Handle the special cases needing files or other data
* as part of exiting the initial dialog box.
*/
if (WinDlgBox (HWND_DESKTOP, hwnd, SelFractalDlgProc,
(HMODULE) 0, IDD_SET_FRACTTYPE, NULL) )
ScheduleNewParms (hwnd);
return 0 ;
case IDM_SET_PARAMS:
/*
* send up the Set Paramters box.
* On OK return, schedule the new parameters.
*/
if (WinDlgBox (HWND_DESKTOP, hwnd, SetParametersDlgProc,
(HMODULE) 0, IDD_SET_PARAMS, NULL) )
ScheduleNewParms (hwnd);
return 0 ;
case IDM_SET_OPTIONS:
/*
* send up the Set Options box.
* On OK return, schedule the new parameters.
*/
if (WinDlgBox (HWND_DESKTOP, hwnd, SetOptionsDlgProc,
(HMODULE) 0, IDD_SET_OPTIONS, NULL) )
ScheduleNewParms (hwnd);
return 0 ;
case IDM_SET_IMAGE:
/*
* send up the Set Image box.
* On OK return, schedule the new parameters.
*/
if (WinDlgBox (HWND_DESKTOP, hwnd, SetImageDlgProc,
(HMODULE) 0, IDD_SET_IMAGE, NULL) )
ScheduleNewParms (hwnd);
return 0 ;
case IDM_SET_PALETTE:
/*
* send up the Set Palette box.
* Return is not checked because effects are immediate
*/
WinDlgBox (HWND_DESKTOP, hwnd, SetPaletteDlgProc,
(HMODULE) 0, IDD_SET_PALETTE, NULL) ;
return 0 ;
case IDM_ZIN_PICK:
case IDM_ZOUT_PICK:
/*
* Send up the Zoom Value dialog box.
* On OK return, schedule the new parameters.
*/
if ( WinDlgBox (HWND_DESKTOP, hwnd, ZoomValueDlgProc,
(HMODULE) 0, IDD_NUMBER_PICK,
MPFROMP((PVOID) &COMMANDMSG(&msg)->cmd)) )
ScheduleNewParms (hwnd);
return 0 ;
case IDM_ZIN_2:
case IDM_ZIN_5:
case IDM_ZIN_10:
/*
* Zoom in by fixed value.
* Schedule the new parameters.
*/
InitNewParms(NULL);
CalcZoomValues(&npNewParms,
(double) (sCommand), TRUE );
npNewParms.fNewParms = TRUE;
ScheduleNewParms(hwnd);
return 0;
case IDM_ZOUT_2:
case IDM_ZOUT_5:
case IDM_ZOUT_10:
/*
* Zoom out by fixed value.
* Schedule the new parameters.
*/
InitNewParms(NULL);
CalcZoomValues(&npNewParms,
(double) (sCommand - 10), FALSE );
npNewParms.fNewParms = TRUE;
ScheduleNewParms(hwnd);
return 0;
case IDM_SET_EXTENTS:
/*
* Send up the Set Extents dialog box.
* On OK return, schedule the new parameters.
*/
if ( WinDlgBox (HWND_DESKTOP, hwnd, SetExtentsDlgProc,
(HMODULE) 0, IDD_SET_EXTENTS, NULL) )
ScheduleNewParms (hwnd);
return 0;
case IDM_SET_SWAP:
/* swap Mandel for Julia or vice versa.
Handle it as a parm change */
InitNewParms(NULL);
if (fractalspecific[npNewParms.iFractType].tojulia != NOFRACTAL
&& npNewParms.param[0] == 0.0
&& npNewParms.param[1] == 0.0)
{
/* switch to corresponding Julia set */
npNewParms.iFractType =
fractalspecific[npNewParms.iFractType].tojulia;
npNewParms.param[0] = npNewParms.XCenter;
npNewParms.param[1] = npNewParms.YCenter;
npNewParms.mxXL = fractalspecific[npNewParms.iFractType].xmin;
npNewParms.mxXR = fractalspecific[npNewParms.iFractType].xmax;
npNewParms.mxYB = fractalspecific[npNewParms.iFractType].ymin;
npNewParms.mxYT = fractalspecific[npNewParms.iFractType].ymax;
}
else if (fractalspecific[npNewParms.iFractType].tomandel != NOFRACTAL)
{
/* switch to corresponding Mandel set */
npNewParms.iFractType =
fractalspecific[npNewParms.iFractType].tomandel;
npNewParms.param[0] = 0.0;
npNewParms.param[1] = 0.0;
npNewParms.mxXL = fractalspecific[npNewParms.iFractType].xmin;
npNewParms.mxXR = fractalspecific[npNewParms.iFractType].xmax;
npNewParms.mxYB = fractalspecific[npNewParms.iFractType].ymin;
npNewParms.mxYT = fractalspecific[npNewParms.iFractType].ymax;
}
npNewParms.fNewParms = TRUE;
ScheduleNewParms (hwnd);
return 0;
case IDM_SET_RESET:
/* copy the work copy of the parms back from the
set used by the calculation engine.
This resets any dicking around done with the
dialogs.
Note: this is only active during FREEZE mode.
*/
CopyParmsToNew();
return 0;
case IDM_HELP_INTRO:
/* basic Introductory Help */
SimpleHelp(hab, hwnd, szTitleBar,
(HMODULE) 0, IDT_TEXT, IDT_HELP_INTRO);
return 0;
case IDM_HELP_FRACTTYPE:
/* Fractal list Help */
SimpleHelp(hab, hwnd, szTitleBar,
(HMODULE) 0, IDT_TEXT, IDT_HELP_TYPES);
return 0;
case IDM_HELP_OPERATE:
/* Menu Help */
SimpleHelp(hab, hwnd, szTitleBar,
(HMODULE) 0, IDT_TEXT, IDT_HELP_OPERATE);
return 0;
case IDM_PRINT_FILE:
/* Send up the Print Where Dialog.
On OK return, fire up the subtask */
if ( WinDlgBox(HWND_DESKTOP, hwnd, PrintOptionsDlgProc,
(HMODULE) 0, IDD_PRINT, NULL) )
{
/* fire up the subtask */
cp.sSubAction = SUB_ACT_PRINT; /* we want a Print */
cp.fContinueCalc = TRUE;
DosSemClear (&cp.ulSemTrigger) ; /* release the subthread */
sStatus = STATUS_WORKING ;
UpdateMenuText (hwnd, IDM_FREEZE_HALT, szHalt);
EnableMenuItem (hwnd, IDM_GO, FALSE) ;
EnableMenuItem (hwnd, IDM_FREEZE_HALT, TRUE) ;
cp.fSuppressPaint = TRUE;
WinInvalidateRect(hwnd, NULL, FALSE);
}
return 0 ;
case IDM_READ_FILE:
/* Send up the Load/Save Format Dialog to find
out the format we will read.
Then send up the generic Open File dialog.
On OK return, fire up the subtask */
{
DLF dlf;
HFILE hfDummy;
PSZ pszExt;
if ( WinDlgBox(HWND_DESKTOP, hwnd, LoadSaveFmtDlgProc,
(HMODULE) 0, IDD_LOADSAVE_TYPE, szLoadWhatFmt) )
{
FileFmtExt (&pszExt);
SetupDLF (&dlf, DLG_OPENDLG, &hfDummy,
pszExt, szTitleBar,
szOpenTitle, szOpenHelp);
if (TDF_OLDOPEN == DlgFile(hwnd, &dlf) )
{
/* close the dummy file handle */
DosClose(hfDummy);
/* fire up the subtask */
cp.sSubAction = SUB_ACT_LOAD; /* we want a Load */
cp.sSubFunction = cp.sLastLoadSaveType;
_fstrcpy(cp.szFileName, dlf.szOpenFile);
cp.fContinueCalc = TRUE;
DosSemClear (&cp.ulSemTrigger) ; /* release the subthread */
sStatus = STATUS_WORKING ;
UpdateMenuText (hwnd, IDM_FREEZE_HALT, szHalt);
EnableMenuItem (hwnd, IDM_GO, FALSE) ;
EnableMenuItem (hwnd, IDM_FREEZE_HALT, TRUE) ;
cp.fSuppressPaint = TRUE;
WinInvalidateRect(hwnd, NULL, FALSE);
}
}
return 0 ;
}
case IDM_SAVE_FILE:
/* Send up the Load/Save Format Dialog to find
out the format we will be writing.
Then send up the generic Save File dialog.
On OK return, fire up the subtask */
{
DLF dlf;
HFILE hfDummy;
PSZ pszExt;
if ( WinDlgBox(HWND_DESKTOP, hwnd, LoadSaveFmtDlgProc,
(HMODULE) 0, IDD_LOADSAVE_TYPE, szSaveWhatFmt) )
{
FileFmtExt (&pszExt);
SetupDLF (&dlf, DLG_SAVEDLG, &hfDummy,
pszExt, szTitleBar,
szOpenTitle, szOpenHelp);
_fstrcpy(dlf.szOpenFile, cp.szFileName);
if (TDF_NOSAVE != DlgFile(hwnd, &dlf) )
{
/* close the dummy file handle */
DosClose(hfDummy);
/* and delete the dummy file */
DosDelete(dlf.szOpenFile, 0);
/* fire up the subtask */
cp.sSubAction = SUB_ACT_SAVE; /* we want a Save */
cp.sSubFunction = cp.sLastLoadSaveType;
_fstrcpy(cp.szFileName, dlf.szOpenFile);
cp.fContinueCalc = TRUE;
DosSemClear (&cp.ulSemTrigger) ; /* release the subthread */
sStatus = STATUS_WORKING ;
UpdateMenuText (hwnd, IDM_FREEZE_HALT, szHalt);
EnableMenuItem (hwnd, IDM_GO, FALSE) ;
EnableMenuItem (hwnd, IDM_FREEZE_HALT, TRUE) ;
cp.fSuppressPaint = TRUE;
WinInvalidateRect(hwnd, NULL, FALSE);
}
}
return 0 ;
}
case IDM_READ_COLORMAP:
/* Send up the generic Open File dialog.
On OK return, read in the file via subroutine. */
{
DLF dlf;
HFILE hfDummy;
SetupDLF (&dlf, DLG_OPENDLG, &hfDummy,
"\\*.map", szTitleBar,
szColorMapTitle, szColorMapHelp);
if (TDF_OLDOPEN == DlgFile(hwnd, &dlf) )
{
/* close the dummy file handle */
DosClose(hfDummy);
/* throw up the hour-glass */
WinSetCapture(HWND_DESKTOP, hwnd);
WinSetPointer(HWND_DESKTOP, hptrWait);
/* read it in */
LoadColorMap(dlf.szOpenFile);
/* now clean up */
WinSetPointer(HWND_DESKTOP, hptrArrow);
WinSetCapture(HWND_DESKTOP, (HWND) NULL);
}
}
return 0;
case IDM_WRITE_COLORMAP:
/* Send up the generic Save File dialog.
On OK return, write the file via subroutine */
{
DLF dlf;
HFILE hfDummy;
SetupDLF (&dlf, DLG_SAVEDLG, &hfDummy,
"\\*.map", szTitleBar,
szColorMapTitle, szColorMapHelp);
if (TDF_NOSAVE != DlgFile(hwnd, &dlf) )
{
/* close the dummy file handle */
DosClose(hfDummy);
/* throw up the hour-glass */
WinSetCapture(HWND_DESKTOP, hwnd);
WinSetPointer(HWND_DESKTOP, hptrWait);
/* write it out */
SaveColorMap(dlf.szOpenFile);
/* now clean up */
WinSetPointer(HWND_DESKTOP, hptrArrow);
WinSetCapture(HWND_DESKTOP, (HWND) NULL);
}
}
return 0;
case IDM_CLEAR_CLPB:
/* clear the current contents of the clipboard */
WinOpenClipbrd (hab);
WinEmptyClipbrd (hab);
WinCloseClipbrd (hab);
return 0;
case IDM_PASTE:
{ /* paste from the clipboard into us */
USHORT usClipBrdInfo;
if ( WinQueryClipbrdFmtInfo(hab, CF_BITMAP, &usClipBrdInfo) )
{ /* we have a bitmap to fetch */
/* draw the curtain over the display */
cp.fSuppressPaint = TRUE;
WinInvalidateRect(hwnd, NULL, FALSE);
WinUpdateWindow(hwnd);
/* throw up the hour-glass */
WinSetCapture(HWND_DESKTOP, hwnd);
WinSetPointer(HWND_DESKTOP, hptrWait);
/* fetch the bitmap */
PMfrFetchClipbrdBmp(hab);
/* now clean up */
WinSetPointer(HWND_DESKTOP, hptrArrow);
WinSetCapture(HWND_DESKTOP, (HWND) NULL);
/* and schedule redrawing the window */
SetSwitchEntry (hwnd, szTitleBar,
GetFractalName(cp.iFractType) );
cp.fSuppressPaint = FALSE;
WinInvalidateRect(hwnd, NULL, FALSE);
}
}
return 0;
case IDM_COPY_BMP:
{ /* copy to the clipboard from us */
/* throw up the hour-glass */
WinSetCapture(HWND_DESKTOP, hwnd);
WinSetPointer(HWND_DESKTOP, hptrWait);
/* write the bitmap */
PMfrWriteClipbrdBmp(hab);
/* now clean up */
WinSetPointer(HWND_DESKTOP, hptrArrow);
WinSetCapture(HWND_DESKTOP, (HWND) NULL);
}
return 0;
}
return 0;
}
MRESULT Window::stdWndProc( HWND hWnd, ULONG iMessage, MPARAM mParam1,
MPARAM mParam2, BOOL *returned )
{
switch( iMessage )
{
// case WM_FOCUSCHANGE :
case WM_SETSELECTION :
case WM_ACTIVATE :
{
if( type != Window::LISTBOX &&
type != Window::COMBOLISTBOX )
{
focus( (BOOL)mParam1 );//SHORT1FROMMP( mParam2 ) );
}
break;
}
case WM_SETFOCUS :
{
if( type != Window::LISTBOX &&
type != Window::COMBOLISTBOX )
focusSet( (BOOL)mParam2 );
break;
}
case WM_BUTTON1DOWN :
{
if( type == SCROLLBAR )
setFocus();
HWND hwnd = WinQueryFocus( HWND_DESKTOP );
if( mouseListener.getSize() != 0 )
{
mouseButtonDown = TRUE;
WinSetCapture( HWND_DESKTOP, hWnd );
WinStartTimer( Application::hab, hWndClient, 1, 50 );
Point pos( SHORT1FROMMP(mParam1), SHORT2FROMMP(mParam1) );
performMouseEvent( &pos, AMouseEvent::LEFT, AMouseEvent::DOWN );
}
if( hwnd != WinQueryFocus( HWND_DESKTOP ) ) return (MRESULT)TRUE;
break;
}
case WM_BUTTON1UP :
{
if( type == LISTBOX ||
type == COMBOLISTBOX )
{
performFocusEvent(
(int)WinSendMsg( (HWND)mParam2, LM_QUERYSELECTION, MPARAM(0), MPARAM(NULL) ) );
}
else
if( mouseListener.getSize() != 0 )
{
mouseButtonDown = FALSE;
WinStopTimer( Application::hab, hWndClient, 1 );
WinSetCapture( HWND_DESKTOP, NULLHANDLE );
Point pos( SHORT1FROMMP(mParam1), SHORT2FROMMP(mParam1) );
performMouseEvent( &pos, AMouseEvent::LEFT, AMouseEvent::RELEASE );
// return (MPARAM)TRUE;
}
break;
}
case WM_BUTTON2DOWN :
{
if( mouseListener.getSize() != 0 )
{
WinSetCapture( HWND_DESKTOP, hWnd );
WinStartTimer( Application::hab, hWndClient, 1, 50 );
Point pos( SHORT1FROMMP(mParam1), SHORT2FROMMP(mParam1) );
performMouseEvent( &pos, AMouseEvent::RIGHT, AMouseEvent::DOWN );
}
break;
}
case WM_BUTTON2UP :
{
if( mouseListener.getSize() != 0 )
{
WinStopTimer( Application::hab, hWndClient, 1 );
WinSetCapture( HWND_DESKTOP, NULLHANDLE );
Point pos( SHORT1FROMMP(mParam1), SHORT2FROMMP(mParam1) );
performMouseEvent( &pos, AMouseEvent::RIGHT, AMouseEvent::RELEASE );
}
break;
}
case WM_BUTTON1CLICK :
{
if( mouseListener.getSize() != 0 )
{
// Check if triple click
int newTick = WinGetCurrentTime( Application::hab );
if( newTick - lastTick <=
WinQuerySysValue( HWND_DESKTOP, SV_DBLCLKTIME ) )
{
Point pos( SHORT1FROMMP(mParam1), SHORT2FROMMP(mParam1) );
performMouseEvent( &pos, AMouseEvent::LEFT, AMouseEvent::TRIPLECLICK );
}
else
{
Point pos( SHORT1FROMMP(mParam1), SHORT2FROMMP(mParam1) );
performMouseEvent( &pos, AMouseEvent::LEFT, AMouseEvent::CLICK );
}
}
break;
}
case WM_BUTTON2CLICK :
{
if( mouseListener.getSize() != 0 )
{
Point pos( SHORT1FROMMP(mParam1), SHORT2FROMMP(mParam1) );
performMouseEvent( &pos, AMouseEvent::RIGHT, AMouseEvent::CLICK );
}
break;
}
case WM_BUTTON1DBLCLK :
{
if( mouseListener.getSize() != 0 )
{
Point pos( SHORT1FROMMP(mParam1), SHORT2FROMMP(mParam1) );
performMouseEvent( &pos, AMouseEvent::LEFT, AMouseEvent::DOUBLECLICK );
}
lastTick = WinGetCurrentTime( Application::hab );
break;
}
case WM_BUTTON2DBLCLK :
{
if( mouseListener.getSize() != 0 )
{
Point pos( SHORT1FROMMP(mParam1), SHORT2FROMMP(mParam1) );
performMouseEvent( &pos, AMouseEvent::RIGHT, AMouseEvent::DOUBLECLICK );
}
break;
}
case WM_MOUSEMOVE :
{
if( currentPointer != NULLHANDLE )
WinSetPointer( HWND_DESKTOP, currentPointer );
if( mouseListener.getSize() != 0 )
{
Point pos( (SHORT)SHORT1FROMMP(mParam1), (SHORT)SHORT2FROMMP(mParam1) );
performMouseEvent( &pos, 0, AMouseEvent::MOVE );
}
if( currentPointer != NULLHANDLE )
return (MPARAM)TRUE;
break;
}
case WM_TIMER :
{
if( mouseButtonDown )
{
POINTL ptl;
WinQueryPointerPos( HWND_DESKTOP, &ptl );
WinMapWindowPoints( HWND_DESKTOP, hWnd, &ptl, 1 );
if( ptl.y < 0 || ptl.y > height )
{
Point pos( ptl.x, ptl.y );
performMouseEvent( &pos, 0, AMouseEvent::MOVE );
}
}
break;
}
case WM_SIZE :
{
int oldWidth = width, oldHeight = height;
SWP swp;
WinQueryWindowPos( hWndFrame, &swp );
width = swp.cx;
height = swp.cy;
size( oldWidth, oldHeight );
break;
}
case WM_HSCROLL :
{
int pos = SHORT1FROMMP( mParam2 ), id = SHORT1FROMMP( mParam1 );
switch( SHORT2FROMMP( mParam2 ) )
{
case SB_PAGERIGHT :
{
performScrollbarEvent( id, Scrollbar::PAGERIGHT, pos );
break;
}
case SB_PAGELEFT :
{
performScrollbarEvent( id, Scrollbar::PAGELEFT, pos );
break;
}
case SB_LINERIGHT :
{
performScrollbarEvent( id, Scrollbar::LINERIGHT, pos );
break;
}
case SB_LINELEFT :
{
performScrollbarEvent( id, Scrollbar::LINELEFT, pos );
break;
}
case SB_SLIDERTRACK :
{
performScrollbarEvent( id, Scrollbar::HORZTRACK, pos );
break;
}
case SB_SLIDERPOSITION :
{
performScrollbarEvent( id, Scrollbar::HORZRELEASED, pos );
break;
}
}
break;
}
case WM_SYSCOMMAND :
{
// Check if the parent is a dialog, then chain the WM_SYSCOMMAND
if( parent->getType() == DIALOG )
WinSendMsg( ((Window *)parent)->getHWND(), WM_SYSCOMMAND, mParam1, mParam2 );
break;
}
case WM_VSCROLL :
{
int id = SHORT1FROMMP( mParam1 );
Scrollbar *scrollbar = (Scrollbar *)getControl( id );
int pos;
if( scrollbar )
pos = scrollbar->convertScrollPosToReal( SHORT1FROMMP( mParam2 ) );
else
pos = SHORT1FROMMP( mParam2 );
switch( SHORT2FROMMP( mParam2 ) )
{
case SB_PAGEDOWN :
{
performScrollbarEvent( id, Scrollbar::PAGEDOWN, pos );
break;
}
case SB_PAGEUP :
{
performScrollbarEvent( id, Scrollbar::PAGEUP, pos );
break;
}
case SB_LINEDOWN :
{
performScrollbarEvent( id, Scrollbar::LINEDOWN, pos );
break;
}
case SB_LINEUP :
{
performScrollbarEvent( id, Scrollbar::LINEUP, pos );
break;
}
case SB_SLIDERTRACK :
{
performScrollbarEvent( id, Scrollbar::VERTTRACK, pos );
break;
}
case SB_SLIDERPOSITION :
{
performScrollbarEvent( id, Scrollbar::VERTRELEASED, pos );
break;
}
}
break;
}
case WM_MOVE :
{
SWP swp;
WinQueryWindowPos( hWndFrame, &swp );
x = swp.x;
y = swp.y;
move();
break;
}
case WM_CLOSE :
{
if( close() )
break;
else
return (MPARAM)FALSE;
}
case WM_COMMAND :
{
if( SHORT1FROMMP( mParam2 ) == CMDSRC_PUSHBUTTON )
{
Window *control = (Window *)getControl( SHORT1FROMMP(mParam1));
if( control != NULL )
{
if( control->type == PUSHBUTTON )
{
control->performButtonEvent( control, control->id );
return FALSE;
}
}
else
return FALSE; // In case ESC would close the dialog
}
break;
}
case WM_CHAR :
{
if( type == LISTBOX )
{
performFocusEvent(
(int)WinSendMsg( (HWND)mParam2, LM_QUERYSELECTION, MPARAM(0), MPARAM(NULL) ) );
}
if( (SHORT1FROMMP( mParam1 ) & KC_KEYUP) ||
(SHORT1FROMMP( mParam1 ) & KC_DEADKEY) ||
(SHORT1FROMMP( mParam1 ) & KC_INVALIDCOMP) )
break;
/* if( SHORT1FROMMP( mParam1 ) & KC_COMPOSITE )
mParam1 = MPFROM2SHORT( SHORT1FROMMP( mParam1 ) & ~KC_VIRTUALKEY,
SHORT2FROMMP( mParam1 ) );*/
int modifiers = 0;
if( SHORT1FROMMP( mParam1 ) & KC_SHIFT )
modifiers |= KeyDef::SHIFT;
if( SHORT1FROMMP( mParam1 ) & KC_ALT )
modifiers |= KeyDef::kALT;
if( SHORT1FROMMP( mParam1 ) & KC_CTRL)
modifiers |= KeyDef::CTRL;
if( SHORT1FROMMP( mParam1 ) & KC_VIRTUALKEY )
{
int key = 0, vKey = SHORT2FROMMP( mParam2 );
// Maybe NumLock is on
if( SHORT1FROMMP(mParam1) & KC_CHAR &&
!(vKey == VK_ENTER || vKey == VK_NEWLINE || vKey == VK_TAB ||
vKey == VK_BACKSPACE ))
key = SHORT1FROMMP( mParam2 );
else
if( vKey == VK_UP )
key = KeyDef::UP;
else
if( vKey == VK_DOWN )
key = KeyDef::DOWN;
else
if( vKey == VK_LEFT )
key = KeyDef::LEFT;
else
if( vKey == VK_RIGHT )
key = KeyDef::RIGHT;
else
if( vKey == VK_PAGEUP )
key = KeyDef::PAGEUP;
else
if( vKey == VK_PAGEDOWN )
key = KeyDef::PAGEDOWN;
else
if( vKey == VK_INSERT )
key = KeyDef::INSERT;
else
if( vKey == VK_DELETE )
key = KeyDef::kDELETE;
else
if( vKey == VK_HOME )
key = KeyDef::HOME;
else
if( vKey == VK_END )
key = KeyDef::END;
else
if( vKey == VK_ESC )
key = KeyDef::ESCAPE;
else
if( vKey == VK_F1 )
key = KeyDef::F1;
else
if( vKey == VK_F2 )
key = KeyDef::F2;
else
if( vKey == VK_F3 )
key = KeyDef::F3;
else
if( vKey == VK_F4 )
key = KeyDef::F4;
else
if( vKey == VK_F5 )
key = KeyDef::F5;
else
if( vKey == VK_F6 )
key = KeyDef::F6;
else
if( vKey == VK_F7 )
key = KeyDef::F7;
else
if( vKey == VK_F8 )
key = KeyDef::F8;
else
if( vKey == VK_F9 )
key = KeyDef::F9;
else
if( vKey == VK_F10 )
key = KeyDef::F10;
else
if( vKey == VK_F11 )
key = KeyDef::F11;
else
if( vKey == VK_F12 )
key = KeyDef::F12;
else
if( vKey == VK_ENTER )
key = KeyDef::ENTER;
else
if( vKey == VK_NEWLINE )
key = KeyDef::RETURN;
else
if( vKey == VK_BACKSPACE )
key = KeyDef::BACKSPACE;
else
if( vKey == VK_TAB )
key = KeyDef::TAB;
else
if( vKey == VK_BACKTAB )
{
key = KeyDef::TAB;
modifiers |= KeyDef::SHIFT;
}
else
if( vKey == VK_SPACE )
key = KeyDef::SPACE;
if( parent->getType() == DIALOG )
((Dialog *)parent)->focusHotkey( key );
if( key != 0 )
if( performKeyEvent( this, modifiers, key ) ) return MPARAM(TRUE);
// Do not pass up and down key to dialog if this is a combobox (would
// move focus)
/* if( getFilterDialogArrows() &&
(vKey == VK_UP || vKey == VK_DOWN) )
return (MPARAM)TRUE;*/
}
else
{
int key = SHORT1FROMMP( mParam2 );
if( performKeyEvent( this, modifiers, key ) ) return MPARAM(TRUE);
}
break;
}
case WM_CONTROL :
{
Window *control = (Window *)getControl( SHORT1FROMMP(mParam1));
if( control != NULL )
{
if( control->type == Window::LISTBOX ||
control->type == Window::COMBOLISTBOX )
{
switch( SHORT2FROMMP(mParam1) )
{
case LN_KILLFOCUS : control->focus( FALSE ); break;
case LN_SETFOCUS : control->focus( TRUE );break;
case LN_ENTER :
control->performSelectionEvent(
(int)WinSendMsg( (HWND)mParam2, LM_QUERYSELECTION, MPARAM(0), MPARAM(NULL) ) );
break;
}
}
else
if( control->type == Window::SCROLLBAR )
{
switch( SHORT2FROMMP(mParam1) )
{
case SLN_KILLFOCUS : control->focus( FALSE ); break;
case SLN_SETFOCUS : control->setFocus(); break;
}
}
else
if( control->type == Window::RADIOBUTTON ||
control->type == Window::CHECKBOX )
{
switch( SHORT2FROMMP( mParam1) )
{
case BN_CLICKED :
case BN_DBLCLICKED :
control->performButtonEvent( control, control->id );
break;
}
}
}
break;
}
case DM_DRAGOVER:
{
PDRAGINFO pDInfo;
PDRAGITEM pDItem;
if( !acceptDropFiles )
return MRFROM2SHORT(DOR_NODROPOP, 0);
pDInfo = (PDRAGINFO)mParam1;
DrgAccessDraginfo(pDInfo);
pDItem = DrgQueryDragitemPtr(pDInfo, 0);
USHORT usOp = 0, usDrop = DOR_NEVERDROP;
/* Inspect each item to see if it is acceptable */
ULONG ulItems = DrgQueryDragitemCount (pDInfo);
for (INT i = 0; i < ulItems; i++)
{
pDItem = DrgQueryDragitemPtr(pDInfo, i);
/* The item is acceptable only if it is copyable and the */
/* operation is a copy, or it is moveable and the operation */
/* is a move, and it can render <DRM_OS2FILE, NULL> */
if (pDItem->fsSupportedOps & DO_COPYABLE)
{
usOp = DO_COPY;
/* Only check files, all types */
if (DrgVerifyRMF(pDItem, "DRM_OS2FILE", 0))
usDrop = DOR_DROP;
else
{
usDrop = DOR_NEVERDROP;
break;
}
}
else
{
/* Must be a file but not droppable in type op */
usDrop = DOR_NODROPOP;
usOp = 0;
break;
}
} /* end for all items dragged */
DrgFreeDraginfo(pDInfo);
return MRFROM2SHORT(usDrop, usOp);
}
case DM_DROP:
{
PDRAGINFO pDInfo;
PDRAGITEM pDItem;
pDInfo = (PDRAGINFO)mParam1;
DrgAccessDraginfo(pDInfo);
pDItem = DrgQueryDragitemPtr(pDInfo, 0);
ULONG ulItems = DrgQueryDragitemCount (pDInfo);
ULONG p;
char **files;
files = (char **)malloc( sizeof( char * ) * ulItems );
for (INT i=0; i < ulItems; i++)
{
CHAR DragSrcPath[CCHMAXPATH], DragSrcName[CCHMAXPATH];
pDItem = DrgQueryDragitemPtr(pDInfo, i);
DrgQueryStrName(pDItem->hstrContainerName, sizeof(DragSrcPath), (PSZ)DragSrcPath);
if (!(PSZ)DragSrcPath)
break;
if (DragSrcPath[(strlen(DragSrcPath)-1)] != '\\')
strcat((PSZ)DragSrcPath, "\\");
/* Use the dragitem source name, it's the real name */
DrgQueryStrName(pDItem->hstrSourceName, sizeof(DragSrcName),
(PSZ)DragSrcName);
if (!((PSZ)DragSrcName))
break;
strcat((PSZ)DragSrcPath, (PSZ)DragSrcName);
FILESTATUS3 fsFile;
DosError(FERR_DISABLEHARDERR);
APIRET rc = DosQueryPathInfo(DragSrcPath, FIL_STANDARD, &fsFile,
sizeof(FILESTATUS3));
DosError(FERR_ENABLEHARDERR);
if (!rc && !(fsFile.attrFile & FILE_DIRECTORY))
{
files[i] = (char *)malloc( strlen(DragSrcPath) + 1 );
strcpy( files[i], DragSrcPath );
DrgSendTransferMsg(pDItem->hwndItem, DM_ENDCONVERSATION,
MPFROMLONG(pDItem->ulItemID),
MPFROMLONG(DMFL_TARGETSUCCESSFUL));
}
else
{
DosBeep(100,10);
// EditorDisplay[BufNum]->DisplayMessage( pszDropNoFile );
}
}
filesDropped( files, ulItems );
for( i = 0; i < ulItems; i++ )
free( (void *)files[i] );
free( (void *)files );
DrgFreeDraginfo(pDInfo);
break;
}
case WM_USER + 1 :
{
return (MPARAM)execFromMainThread( (int)mParam1, (void *)mParam2 );
}
case WM_USER + 2 :
{
setFocus();
break;
}
}
*returned = FALSE;
return (MRESULT)NULL;
}
MRESULT EXPENTRY ToolBarProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) {
if (msg == WM_CREATE) {
WinSetWindowPtr(hwnd, QWL_USER, PVOIDFROMMP(mp1));
} else {
ToolBarData *td = (ToolBarData *)WinQueryWindowPtr(hwnd, QWL_USER);
ToolBarItem *items = td->pItems;
switch (msg) {
case WM_DESTROY:
free(td);
free(items);
break;
case WM_PAINT:
{
HPS hps;
RECTL rcl;
POINTL ptl;
SWP swp;
int xpos, ypos, item;
WinQueryWindowPos(hwnd, &swp);
hps = WinBeginPaint(hwnd, 0, &rcl);
/* top outside 3D border */
if (rcl.yBottom < 1) {
GpiSetColor(hps, CLR_DARKGRAY);
ptl.x = rcl.xLeft;
ptl.y = 0;
GpiMove(hps, &ptl);
ptl.x = Min(rcl.xRight, swp.cx - 2);
GpiLine(hps, &ptl);
}
/* bottom outside 3D border */
if (rcl.yTop >= swp.cy - 1 - 1) {
GpiSetColor(hps, CLR_WHITE);
ptl.x = Max(rcl.xLeft, 1);
ptl.y = swp.cy - 1;
GpiMove(hps, &ptl);
ptl.x = rcl.xRight;
GpiLine(hps, &ptl);
}
/* 3D corners */
GpiSetColor(hps, CLR_PALEGRAY);
ptl.x = 0;
ptl.y = 0;
GpiSetPel(hps, &ptl);
ptl.x = swp.cx - 1;
ptl.y = swp.cy - 1;
GpiSetPel(hps, &ptl);
/* bottom space */
if (rcl.yBottom < TYBORDER - 1) {
for (ptl.y = 1; ptl.y < TYBORDER - 2; ptl.y++) {
ptl.x = Max(rcl.xLeft, 1);
GpiMove(hps, &ptl);
ptl.x = Min(rcl.xRight, swp.cx - 1);
GpiLine(hps, &ptl);
}
}
/* top space */
if (rcl.yTop >= swp.cy - TYBORDER + 2) {
for (ptl.y = swp.cy - TYBORDER + 2; ptl.y < swp.cy - 1; ptl.y++) {
ptl.x = Max(rcl.xLeft, 1);
GpiMove(hps, &ptl);
ptl.x = Min(rcl.xRight, swp.cx - 1);
GpiLine(hps, &ptl);
}
}
/* left outside 3D border */
if (rcl.xLeft < 1) {
GpiSetColor(hps, CLR_WHITE);
ptl.y = Max(1, rcl.yBottom);
ptl.x = 0;
GpiMove(hps, &ptl);
ptl.y = rcl.yTop;
GpiLine(hps, &ptl);
}
/* right outside 3D border */
if (rcl.xRight >= swp.cx - 1) {
GpiSetColor(hps, CLR_DARKGRAY);
ptl.y = rcl.yBottom;
ptl.x = swp.cx - 1;
GpiMove(hps, &ptl);
ptl.y = Min(swp.cy - 2, rcl.yTop);
GpiLine(hps, &ptl);
}
/* left border */
if (rcl.xLeft < TXBORDER - 2) {
GpiSetColor(hps, CLR_PALEGRAY);
for (ptl.x = 1; ptl.x < TXBORDER - 2; ptl.x++) {
ptl.y = Max(1, rcl.yBottom);
GpiMove(hps, &ptl);
ptl.y = Min(swp.cy - 2, rcl.yTop);
GpiLine(hps, &ptl);
}
}
/* draw toolbar items */
xpos = TXBORDER;
ypos = TYBORDER;
for (item = 0; item < td->ulCount; item++) {
if (items[item].ulType == tiBITMAP) {
if (rcl.xRight >= xpos - 2 && rcl.xLeft <= xpos + TXICON + 1) {
GpiSetColor(hps, CLR_BLACK);
ptl.x = xpos - 2;
ptl.y = ypos - 2;
GpiMove(hps, &ptl);
ptl.x = xpos + TXICON + 1;
ptl.y = ypos + TYICON + 1;
GpiBox(hps, DRO_OUTLINE, &ptl, 0, 0);
if (item == td->ulDepressed && (items[item].ulFlags & tfDEPRESSED)) {
ptl.x = xpos + 1;
ptl.y = ypos - 1;
WinDrawBitmap(hps,
items[item].hBitmap,
0,
&ptl,
0, 0,
(items[item].ulFlags & tfDISABLED) ? DBM_INVERT: DBM_NORMAL);
GpiSetColor(hps, CLR_DARKGRAY);
ptl.x = xpos - 1;
ptl.y = ypos - 1;
GpiMove(hps, &ptl);
ptl.y = ypos + TYICON;
GpiLine(hps, &ptl);
ptl.x = xpos + TXICON;
GpiLine(hps, &ptl);
ptl.y--;
GpiMove(hps, &ptl);
ptl.x = xpos;
GpiLine(hps, &ptl);
ptl.y = ypos - 1;
GpiLine(hps, &ptl);
} else {
ptl.x = xpos;
ptl.y = ypos;
WinDrawBitmap(hps,
items[item].hBitmap,
0,
&ptl,
0, 0,
(items[item].ulFlags & tfDISABLED) ? DBM_INVERT: DBM_NORMAL);
GpiSetColor(hps, CLR_PALEGRAY);
ptl.x = xpos - 1;
ptl.y = ypos - 1;
GpiSetPel(hps, &ptl);
GpiSetColor(hps, CLR_WHITE);
ptl.y++;
GpiMove(hps, &ptl);
ptl.y = ypos + TYICON;
GpiLine(hps, &ptl);
ptl.x = xpos + TXICON - 1;
GpiLine(hps, &ptl);
GpiSetColor(hps, CLR_PALEGRAY);
ptl.x++;
GpiSetPel(hps, &ptl);
ptl.y--;
GpiSetColor(hps, CLR_DARKGRAY);
GpiMove(hps, &ptl);
ptl.y = ypos - 1;
GpiLine(hps, &ptl);
ptl.x = xpos;
GpiLine(hps, &ptl);
}
}
xpos += TXICON + 3;
} else if (items[item].ulType == tiSEPARATOR) {
if (rcl.xRight >= xpos - 1 && rcl.xLeft <= xpos + TXSEPARATOR + 1) {
GpiSetColor(hps, CLR_PALEGRAY);
ptl.x = xpos - 1;
ptl.y = ypos - 2;
GpiMove(hps, &ptl);
ptl.x = xpos + TXSEPARATOR + 1;
ptl.y = ypos + TYICON + 1;
GpiBox(hps, DRO_FILL, &ptl, 0, 0);
}
xpos += TXSEPARATOR + 3;
}
}
GpiSetColor(hps, CLR_PALEGRAY);
ptl.x = xpos - 1;
ptl.y = ypos - 2;
GpiMove(hps, &ptl);
ptl.x = swp.cx - 2;
ptl.y = swp.cy - TYBORDER + 1;
GpiBox(hps, DRO_FILL, &ptl, 0, 0);
WinEndPaint(hps);
}
break;
case WM_ADJUSTWINDOWPOS:
{
PSWP pswp = (PSWP)PVOIDFROMMP(mp1);
pswp->cy = TYBORDER + TYICON + TYBORDER;
}
break;
case WM_BUTTON1DOWN:
case WM_BUTTON1DBLCLK:
{
int item;
POINTL ptl;
RECTL rcl;
ptl.x = (LONG) SHORT1FROMMP(mp1);
ptl.y = (LONG) SHORT2FROMMP(mp1);
rcl.yBottom = TYBORDER - 1;
rcl.yTop = TYBORDER + TYICON + 1;
rcl.xLeft = TXBORDER - 1;
rcl.xRight = TXBORDER + TXICON + 1;
for (item = 0; item < td->ulCount; item++) {
if (rcl.xLeft <= ptl.x && rcl.yBottom <= ptl.y &&
rcl.xRight >= ptl.x && rcl.yTop >= ptl.y &&
td->pItems[item].ulType == tiBITMAP &&
(td->pItems[item].ulFlags & tfDISABLED) == 0)
{
td->ulDepressed = item;
td->pItems[item].ulFlags |= tfDEPRESSED;
WinInvalidateRect(hwnd, &rcl, FALSE);
WinSetCapture(HWND_DESKTOP, hwnd);
break;
}
if (td->pItems[item].ulType == tiBITMAP) {
rcl.xLeft += TXICON + 3;
rcl.xRight += TXICON + 3;
} else if (td->pItems[item].ulType == tiSEPARATOR) {
rcl.xLeft += TXSEPARATOR + 3;
rcl.xRight += TXSEPARATOR + 3;
}
}
}
break;
case WM_MOUSEMOVE:
{
STARTFUNC("ToolBarProc[WM_MOUSEMOVE]");
int item;
POINTL ptl;
RECTL rcl;
if (td->ulDepressed == -1)
break;
ptl.x = (LONG) SHORT1FROMMP(mp1);
ptl.y = (LONG) SHORT2FROMMP(mp1);
rcl.yBottom = TYBORDER - 1;
rcl.yTop = TYBORDER + TYICON + 1;
rcl.xLeft = TXBORDER - 1;
rcl.xRight = TXBORDER + TXICON + 1;
LOG << "Depressed: " << td-> ulDepressed << ENDLINE;
for (item = 0; item < td->ulCount; item++) {
LOG << "Checking item " << item << ENDLINE;
LOG << " pItem -> " << (void*)(td->pItems + item) << ENDLINE;
if (item == td->ulDepressed) {
if (rcl.xLeft <= ptl.x && rcl.yBottom <= ptl.y &&
rcl.xRight >= ptl.x && rcl.yTop >= ptl.y)
{
if ((td->pItems[item].ulFlags & tfDEPRESSED) == 0) {
td->pItems[item].ulFlags |= tfDEPRESSED;
WinInvalidateRect(hwnd, &rcl, FALSE);
}
} else {
if (td->pItems[item].ulFlags & tfDEPRESSED) {
td->pItems[item].ulFlags &= ~tfDEPRESSED;
WinInvalidateRect(hwnd, &rcl, FALSE);
}
}
break;
}
if (td->pItems[item].ulType == tiBITMAP) {
rcl.xLeft += TXICON + 3;
rcl.xRight += TXICON + 3;
} else if (td->pItems[item].ulType == tiSEPARATOR) {
rcl.xLeft += TXSEPARATOR + 3;
rcl.xRight += TXSEPARATOR + 3;
}
}
}
break;
case WM_BUTTON1UP:
{
int item;
POINTL ptl;
RECTL rcl;
if (td->ulDepressed == -1)
break;
ptl.x = (LONG) SHORT1FROMMP(mp1);
ptl.y = (LONG) SHORT2FROMMP(mp1);
rcl.yBottom = TYBORDER - 1;
rcl.yTop = TYBORDER + TYICON + 1;
rcl.xLeft = TXBORDER - 1;
rcl.xRight = TXBORDER + TXICON + 1;
for (item = 0; item < td->ulCount; item++) {
if (item == td->ulDepressed) {
WinSetCapture(HWND_DESKTOP, (HWND)0);
if (rcl.xLeft <= ptl.x && rcl.yBottom <= ptl.y &&
rcl.xRight >= ptl.x && rcl.yTop >= ptl.y &&
td->pItems[item].ulFlags & tfDEPRESSED)
{
td->pItems[item].ulFlags &= ~tfDEPRESSED;
WinInvalidateRect(hwnd, &rcl, FALSE);
// message
WinPostMsg(WinQueryWindow(hwnd, QW_OWNER), WM_COMMAND, MPFROM2SHORT(td->pItems[item].ulCommand, 0), MPFROM2SHORT(CMDSRC_OTHER, TRUE));
break;
}
}
if (td->pItems[item].ulType == tiBITMAP) {
rcl.xLeft += TXICON + 3;
rcl.xRight += TXICON + 3;
} else if (td->pItems[item].ulType == tiSEPARATOR) {
rcl.xLeft += TXSEPARATOR + 3;
rcl.xRight += TXSEPARATOR + 3;
}
}
td->ulDepressed = -1;
}
break;
}
}
return WinDefWindowProc(hwnd, msg, mp1, mp2);
}
MRESULT EXPENTRY OS2Loop::processEvent( HWND hwnd, ULONG msg,
MPARAM mp1, MPARAM mp2 )
{
OS2Factory *pFactory =
(OS2Factory*)OS2Factory::instance( getIntf() );
GenericWindow *pWin = pFactory->m_windowMap[hwnd];
// To invert Y
RECTL rcl;
WinQueryWindowRect( hwnd, &rcl );
GenericWindow &win = *pWin;
switch( msg )
{
case WM_PAINT:
{
HPS hps;
RECTL rclPaint;
hps = WinBeginPaint( hwnd, NULLHANDLE, &rclPaint );
EvtRefresh evt( getIntf(),
rclPaint.xLeft,
// Find top and invert it
( rcl.yTop - 1 ) - ( rclPaint.yTop - 1 ),
rclPaint.xRight - rclPaint.xLeft + 1,
rclPaint.yTop - rclPaint.yBottom + 1 );
win.processEvent( evt );
WinEndPaint( hps );
return 0;
}
case WM_COMMAND:
{
EvtMenu evt( getIntf(), SHORT1FROMMP( mp1 ));
win.processEvent( evt );
return 0;
}
case WM_MOUSEMOVE:
{
pFactory->changeCursor( pFactory->getCursorType());
// Compute the absolute position of the mouse
POINTL ptl;
WinQueryPointerPos( HWND_DESKTOP, &ptl );
int x = ptl.x;
int y = ( pFactory->getScreenHeight() - 1 ) - ptl.y;
EvtMotion evt( getIntf(), x, y );
win.processEvent( evt );
return MRFROMLONG( TRUE );
}
case WM_MOUSELEAVE:
{
EvtLeave evt( getIntf() );
win.processEvent( evt );
return MRFROMLONG( TRUE );
}
case WM_BUTTON1DOWN:
{
WinSetCapture( HWND_DESKTOP, hwnd );
EvtMouse evt( getIntf(), GET_X_MP( mp1 ),
GET_Y_MP( mp1 ), EvtMouse::kLeft,
EvtMouse::kDown, getMod( mp2 ) );
win.processEvent( evt );
return MRFROMLONG( TRUE );
}
case WM_BUTTON2DOWN:
{
WinSetCapture( HWND_DESKTOP, hwnd );
EvtMouse evt( getIntf(), GET_X_MP( mp1 ),
GET_Y_MP( mp1 ), EvtMouse::kRight,
EvtMouse::kDown, getMod( mp2 ) );
win.processEvent( evt );
return MRFROMLONG( TRUE );
}
case WM_BUTTON1UP:
{
WinSetCapture( HWND_DESKTOP, NULLHANDLE );
EvtMouse evt( getIntf(), GET_X_MP( mp1 ),
GET_Y_MP( mp1 ), EvtMouse::kLeft,
EvtMouse::kUp, getMod( mp2 ) );
win.processEvent( evt );
return MRFROMLONG( TRUE );
}
case WM_BUTTON2UP:
{
WinSetCapture( HWND_DESKTOP, NULLHANDLE );
EvtMouse evt( getIntf(), GET_X_MP( mp1 ),
GET_Y_MP( mp1 ), EvtMouse::kRight,
EvtMouse::kUp, getMod( mp2 ) );
win.processEvent( evt );
return MRFROMLONG( TRUE );
}
case WM_BUTTON1DBLCLK:
{
WinSetCapture( HWND_DESKTOP, NULLHANDLE );
EvtMouse evt( getIntf(), GET_X_MP( mp1 ),
GET_Y_MP( mp1 ), EvtMouse::kLeft,
EvtMouse::kDblClick, getMod( mp2 ) );
win.processEvent( evt );
return MRFROMLONG( TRUE );
}
case WM_BUTTON2DBLCLK:
{
WinSetCapture( HWND_DESKTOP, NULLHANDLE );
EvtMouse evt( getIntf(), GET_X_MP( mp1 ),
GET_Y_MP( mp1 ), EvtMouse::kRight,
EvtMouse::kDblClick, getMod( mp2 ) );
win.processEvent( evt );
return MRFROMLONG( TRUE );
}
case WM_CHAR:
{
// The key events are first processed here and not translated
// into WM_CHAR events because we need to know the status of
// the modifier keys.
USHORT fsFlags = SHORT1FROMMP( mp1 );
USHORT usCh = SHORT1FROMMP( mp2 );
USHORT usVk = SHORT2FROMMP( mp2 );
// Get VLC key code from the virtual key code
int key = ( fsFlags & KC_VIRTUALKEY ) ?
virtKeyToVlcKey[ usVk ] : 0;
if( !key )
{
// This appears to be a "normal" (ascii) key
key = tolower( usCh );
}
if( key )
{
// Get the modifier
int mod = 0;
if( fsFlags & KC_CTRL )
{
mod |= EvtInput::kModCtrl;
}
if( fsFlags & KC_SHIFT )
{
mod |= EvtInput::kModShift;
}
if( fsFlags & KC_ALT )
{
mod |= EvtInput::kModAlt;
}
// Get the state
EvtKey::ActionType_t state;
if( fsFlags & KC_KEYUP )
{
state = EvtKey::kUp;
}
else
{
state = EvtKey::kDown;
}
EvtKey evt( getIntf(), key, state, mod );
win.processEvent( evt );
}
return MRFROMLONG( TRUE );
}
default:
break;
}
return WinDefWindowProc( hwnd, msg, mp1, mp2 );
}
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()
void mouse_button(HWND hwnd, ULONG msg, MPARAM mp1)
{
if (!_mouse_enabled)
return;
switch (msg)
{
case WM_MOUSEMOVE:
_mouse_x = SHORT1FROMMP(mp1);
_mouse_y = SHORT2FROMMP(mp1);
{
SWP swp;
WinQueryWindowPos(hwnd, &swp);
//
// check whether the pointer is outside or inside the window
//
if (FullscreenIsNow())
visible=TRUE;
if (_mouse_x>=0 && _mouse_x<swp.cx &&
_mouse_y>=0 && _mouse_y<swp.cy)
{
//
// FIXME: Don't capture the mouse pointer if it is in front
// of a client dialog!
//
if (WinQueryCapture(HWND_DESKTOP)!=hwnd && hide_mouseptr && !FullscreenIsNow())
WinSetCapture(HWND_DESKTOP, hwnd);
if (visible && /*_mouse_enabled &&*/ hide_mouseptr &&
!FullscreenIsNow())
{
WinShowPointer(HWND_DESKTOP, FALSE);
visible=FALSE;
}
}
else
{
if (WinQueryCapture(HWND_DESKTOP)==hwnd && !FullscreenIsNow())
WinSetCapture(HWND_DESKTOP, NULLHANDLE);
if (!visible && !FullscreenIsNow())
{
WinShowPointer(HWND_DESKTOP, TRUE);
visible=TRUE;
}
//
// don't use 'outside'-values which appears one times
// if the mouse pointer leaves the window
//
if (_mouse_x<0) _mouse_x=0;
else
if (_mouse_x>=swp.cx)
_mouse_x=swp.cx-1;
if (_mouse_y<0) _mouse_y=0;
else
if (_mouse_y>=swp.cy)
_mouse_y=swp.cy-1;
}
}
return;
case WM_BUTTON1DOWN:
mouse_button_left(1);
return;
case WM_BUTTON1UP:
mouse_button_left(0);
return;
case WM_BUTTON2DOWN:
mouse_button_right(1);
return;
case WM_BUTTON2UP:
mouse_button_right(0);
return;
}
}
MRESULT EXPENTRY newProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
switch (msg)
{
case WM_CREATE:
{
PCREATESTRUCT pCreate=PVOIDFROMMP(mp2);
/* Initialize the slider data */
WinSetWindowUShort(hwnd, SLIDERARMWITH,20);
WinSetWindowUShort(hwnd, SLIDERARMHEIGHT,10);
/* Dimensions of slider. The slider active area is smaller than the window to
allow drawing of active state. */
WinSetWindowULong(hwnd, SLIDERCX,pCreate->cx-4);
WinSetWindowULong(hwnd, SLIDERCY,pCreate->cy-4);
WinSetWindowULong(hwnd, SLIDERX,2);
WinSetWindowULong(hwnd, SLIDERY,2);
WinSetWindowULong(hwnd, SLIDERARMPOS, 0);
WinSetWindowULong(hwnd, SLDRAGGING,FALSE);
return (MRESULT)0;
}
case WM_SIZE:
WinSetWindowULong(hwnd, SLIDERCX, SHORT1FROMMP(mp2)-4);
WinSetWindowULong(hwnd, SLIDERCY, SHORT2FROMMP(mp2)-4);
WinInvalidateRect(hwnd, NULLHANDLE,TRUE);
return (MRESULT)0;
case WM_BUTTON1DOWN:
{
SHORT x=SHORT1FROMMP( mp1);
SHORT y=SHORT2FROMMP( mp1);
LONG lPos=WinQueryWindowULong(hwnd, SLIDERARMPOS);
USHORT usWidth=WinQueryWindowUShort(hwnd, SLIDERARMWITH);
if(x<lPos+usWidth && y<WinQueryWindowUShort(hwnd, SLIDERY)+WinQueryWindowUShort(hwnd, SLIDERCY)
&& y>WinQueryWindowUShort(hwnd, SLIDERY)) {
WinSetWindowUShort(hwnd, PTRPOSINSLARM, x-lPos);
}
WinSetFocus(HWND_DESKTOP, hwnd);
break;
}
case WM_FOCUSCHANGE:
{
HPS hps;
RECTL rcl;
POINTL ptl;
if(SHORT1FROMMP(mp2)) {
hps=WinGetPS(hwnd);
WinQueryWindowRect(hwnd, &rcl);
GpiSetLineType(hps, LINETYPE_DOT);
ptl.x=rcl.xLeft;
ptl.y=rcl.yBottom;
GpiMove(hps,&ptl);
ptl.x=rcl.xRight-1;
GpiLine(hps,&ptl);
ptl.y=rcl.yTop-1;
GpiLine(hps,&ptl);
ptl.x=rcl.xLeft;
GpiLine(hps,&ptl);
ptl.y=rcl.yBottom;
GpiLine(hps,&ptl);
WinReleasePS(hps);
}
else {
WinInvalidateRect(hwnd, NULLHANDLE,TRUE);
}
break;
}
case WM_CHAR:
if(WinQueryFocus(HWND_DESKTOP)==hwnd) {
/* We have the focus */
if((SHORT1FROMMP(mp1) & (KC_VIRTUALKEY))==(KC_VIRTUALKEY)) {
LONG lPos=WinQueryWindowULong(hwnd, SLIDERARMPOS);
USHORT usWidth=WinQueryWindowUShort(hwnd, SLIDERARMWITH);
ULONG ulCx=WinQueryWindowULong(hwnd, SLIDERCX);
#if 0
FILE* file;
file=fopen("d:\\md.log","a");
fprintf(file,"0x%x 0x%x \n",SHORT1FROMMP(mp1),SHORT2FROMMP(mp1) );
fclose(file);
#endif
/*(KC_KEYUP|KC_PREVDOWN|KC_VIRTUALKEY)*/
switch(SHORT2FROMMP(mp2))
{
case VK_RIGHT:
if(SHORT1FROMMP(mp1) & (KC_KEYUP|KC_PREVDOWN)) {
lPos+=2;
if(lPos>ulCx-usWidth)
lPos=ulCx-usWidth;
else {
WinPostMsg( hwnd,
SLM_SETSLIDERINFO,
MPFROM2SHORT(SMA_SLIDERARMPOSITION, SMA_RANGEVALUE),
MPFROMLONG( (LONG) lPos ));
if(SHORT1FROMMP(mp1) & KC_LONEKEY)
/* Post SLN_CHANGE notification */
WinPostMsg( WinQueryWindow(hwnd, QW_PARENT),WM_CONTROL,
MPFROM2SHORT(WinQueryWindowUShort(hwnd, QWS_ID), SLN_CHANGE),
MPFROMLONG(lPos));
else
/* Post SLN_SLIDERTRACK notification */
WinPostMsg(WinQueryWindow(hwnd, QW_PARENT),WM_CONTROL,
MPFROM2SHORT(WinQueryWindowUShort(hwnd, QWS_ID), SLN_SLIDERTRACK),
MPFROMLONG(lPos));
}
WinSetWindowULong(hwnd, SLIDERARMPOS, lPos);
}
return (MRESULT)TRUE;
case VK_LEFT:
if(SHORT1FROMMP(mp1) & (KC_KEYUP|KC_PREVDOWN)) {
lPos-=2;
if(lPos<0) {
lPos=0;
}
else {
WinPostMsg( hwnd,
SLM_SETSLIDERINFO,
MPFROM2SHORT(SMA_SLIDERARMPOSITION, SMA_RANGEVALUE),
MPFROMLONG( (LONG) lPos ));
/* Post SLN_CHANGE notification */
WinPostMsg(WinQueryWindow(hwnd, QW_PARENT), WM_CONTROL,
MPFROM2SHORT(WinQueryWindowUShort(hwnd, QWS_ID), SLN_CHANGE),
MPFROMLONG(WinQueryWindowULong(hwnd, SLIDERARMPOS)));
}
WinSetWindowULong(hwnd, SLIDERARMPOS, lPos);
}
return (MRESULT)TRUE;
default:
break;
}
}
}
break;
case WM_BUTTON1MOTIONSTART:
{
SHORT x=SHORT1FROMMP( mp1);
SHORT y=SHORT2FROMMP( mp1);
LONG lPos=WinQueryWindowULong(hwnd, SLIDERARMPOS);
USHORT usWidth=WinQueryWindowUShort(hwnd, SLIDERARMWITH);
if(x<lPos+usWidth && y<WinQueryWindowUShort(hwnd, SLIDERY)+WinQueryWindowUShort(hwnd, SLIDERCY)
&& y>WinQueryWindowUShort(hwnd, SLIDERY)) {
WinSetWindowULong(hwnd, SLDRAGGING, TRUE);
WinSetCapture(HWND_DESKTOP, hwnd);
}
break;
}
case WM_BUTTON1MOTIONEND:
if(WinQueryWindowULong(hwnd, SLDRAGGING)) {
WinSetWindowULong(hwnd, SLDRAGGING,FALSE);
WinSetCapture(HWND_DESKTOP, NULLHANDLE);
/* Post SLN_CHANGE notification */
WinPostMsg(WinQueryWindow(hwnd, QW_PARENT),WM_CONTROL, MPFROM2SHORT(WinQueryWindowUShort(hwnd, QWS_ID), SLN_CHANGE),
MPFROMLONG(WinQueryWindowULong(hwnd, SLIDERARMPOS)));
}
break;
case SLM_SETSLIDERINFO:
switch(SHORT1FROMMP(mp1))
{
case SMA_SLIDERARMPOSITION:
/* SMA_RANGEVALUE only for now !! */
if(SHORT2FROMMP(mp1)==SMA_RANGEVALUE) {
WinSetWindowULong(hwnd, SLIDERARMPOS, LONGFROMMP(mp2));
WinInvalidateRect(hwnd, NULLHANDLE,TRUE);
return (MRESULT)0;
}
break;
default:
break;
}
break;
case WM_MOUSEMOVE:
if(WinQueryWindowULong(hwnd, SLDRAGGING)) {
HPS hps;
RECTL rcl, rcl2, rcl3;
LONG lTemp;
SHORT x=SHORT1FROMMP(mp1);
LONG lPos=WinQueryWindowULong(hwnd, SLIDERARMPOS);
USHORT usWidth=WinQueryWindowUShort(hwnd, SLIDERARMWITH);
lTemp=lPos;
rcl.xLeft=WinQueryWindowULong(hwnd, SLIDERX);
rcl.yBottom=WinQueryWindowULong(hwnd, SLIDERY);
rcl.xRight=rcl.xLeft+WinQueryWindowULong(hwnd, SLIDERCX);
rcl.yTop=rcl.yBottom+WinQueryWindowULong(hwnd, SLIDERCY);
rcl2=rcl3=rcl;
rcl.xLeft=x-WinQueryWindowUShort(hwnd, PTRPOSINSLARM);
if(rcl.xLeft<rcl2.xLeft)/* Make sure we stop at the left border */
rcl.xLeft=rcl2.xLeft;
rcl.xRight=rcl.xLeft+usWidth;
if(rcl.xRight>rcl2.xRight)
{/* Make sure we stop at the right border */
rcl.xRight=rcl2.xRight;
rcl.xLeft=rcl.xRight-usWidth;
}
lPos=rcl.xLeft-WinQueryWindowULong(hwnd, SLIDERX);/* Save position zero based */
WinSetWindowULong(hwnd, SLIDERARMPOS, lPos);
if(lPos!=lTemp) {
BOOL rc;
hps=WinGetPS(hwnd);
/* Paint Background not necessary here */
/* Shaft */
/* Left part */
rcl3.xRight=rcl.xLeft;
rc=FALSE;
if(USERSLIDER) {
OWNERITEM oi={0};
oi.hwnd=hwnd;
oi.hps=hps;
oi.fsState=SLS_OWNERDRAW;/* More to come */
oi.rclItem=rcl3;
oi.idItem=SDA_SLIDERSHAFT;
rc=(BOOL)WinSendMsg(WinQueryWindow(hwnd, QW_PARENT), WM_DRAWITEM, MPFROMSHORT(WinQueryWindowUShort(hwnd, QWS_ID)),
MPFROMP(&oi) );
}
if(!rc)
WinFillRect(hps, &rcl3, CLR_GREEN);
/* Right part */
rcl3.xRight=rcl2.xRight;
rcl3.xLeft=rcl.xRight;
rc=FALSE;
if(USERSLIDER) {
OWNERITEM oi={0};
oi.hwnd=hwnd;
oi.hps=hps;
oi.fsState=SLS_OWNERDRAW;/* More to come */
oi.rclItem=rcl3;
oi.idItem=SDA_SLIDERSHAFT;
rc=(BOOL)WinSendMsg(WinQueryWindow(hwnd, QW_PARENT), WM_DRAWITEM, MPFROMSHORT(WinQueryWindowUShort(hwnd, QWS_ID)),
MPFROMP(&oi) );
}
if(!rc)
WinFillRect(hps, &rcl3, CLR_WHITE);
/* Paint Slider */
rc=FALSE;
if(USERSLIDER) {
OWNERITEM oi={0};
oi.hwnd=hwnd;
oi.hps=hps;
oi.fsState=SLS_OWNERDRAW;/* More to come */
oi.rclItem=rcl;
oi.idItem=SDA_SLIDERARM;
rc=(BOOL)WinSendMsg(WinQueryWindow(hwnd, QW_PARENT), WM_DRAWITEM, MPFROMSHORT(WinQueryWindowUShort(hwnd, QWS_ID)),
MPFROMP(&oi) );
}
if(!rc)
{
WinFillRect(hps,&rcl, CLR_BLUE);
WinDrawBorder(hps, &rcl, 2, 2, 0, 0 ,0x0400);
}
WinReleasePS(hps);
/* Post SLN_SLIDERTRACK notification */
WinPostMsg(WinQueryWindow(hwnd, QW_PARENT),WM_CONTROL, MPFROM2SHORT(WinQueryWindowUShort(hwnd, QWS_ID), SLN_SLIDERTRACK),
MPFROMLONG(lPos));
}
}
break;
case WM_PAINT:
{
HPS hps, hps2;
RECTL rcl, rcl2, rcl3;
POINTL ptl;
LONG lPos=WinQueryWindowULong(hwnd, SLIDERARMPOS);
USHORT usWidth=WinQueryWindowUShort(hwnd, SLIDERARMWITH);
BOOL rc;
WinQueryWindowRect(hwnd, &rcl);
/* Shaft */
rcl2.xLeft=WinQueryWindowULong(hwnd, SLIDERX);
rcl2.yBottom=WinQueryWindowULong(hwnd, SLIDERY);
rcl2.xRight=rcl2.xLeft+WinQueryWindowULong(hwnd, SLIDERCX)-1;
rcl2.yTop=rcl2.yBottom+WinQueryWindowULong(hwnd, SLIDERCY)-1;
/* Background */
hps2=WinGetPS(hwnd);
GpiExcludeClipRectangle(hps2,&rcl2);
WinFillRect(hps2, &rcl, CLR_PALEGRAY);
WinReleasePS(hps2);
rcl2.yTop+=1;
rcl2.xRight+=1;
hps=WinBeginPaint(hwnd, NULLHANDLE, NULLHANDLE);
/* Focus */
if(WinQueryFocus(HWND_DESKTOP)==hwnd) {
GpiSetLineType(hps, LINETYPE_DOT);
ptl.x=rcl.xLeft;
ptl.y=rcl.yBottom;
GpiMove(hps,&ptl);
ptl.x=rcl.xRight-1;
GpiLine(hps,&ptl);
ptl.y=rcl.yTop-1;
GpiLine(hps,&ptl);
ptl.x=rcl.xLeft;
GpiLine(hps,&ptl);
ptl.y=rcl.yBottom;
GpiLine(hps,&ptl);
}
rcl3=rcl=rcl2;
/* Arm pos */
rcl2.xLeft+=lPos;
/* Arm size */
rcl2.xRight=rcl2.xLeft+usWidth;
/* Shaft */
/* Left part */
rcl3.xRight=rcl2.xLeft;
rc=FALSE;
if(USERSLIDER) {
OWNERITEM oi={0};
oi.hwnd=hwnd;
oi.hps=hps;
oi.fsState=SLS_OWNERDRAW;/* More to come */
oi.rclItem=rcl3;
oi.idItem=SDA_SLIDERSHAFT;
rc=(BOOL)WinSendMsg(WinQueryWindow(hwnd, QW_PARENT), WM_DRAWITEM, MPFROMSHORT(WinQueryWindowUShort(hwnd, QWS_ID)),
MPFROMP(&oi) );
}
if(!rc)
WinFillRect(hps, &rcl3, CLR_GREEN);
/* Right part */
rcl3.xRight=rcl.xRight;
rcl3.xLeft=rcl2.xRight;
rc=FALSE;
if(USERSLIDER) {
OWNERITEM oi={0};
oi.hwnd=hwnd;
oi.hps=hps;
oi.fsState=SLS_OWNERDRAW;/* More to come */
oi.rclItem=rcl3;
oi.idItem=SDA_SLIDERSHAFT;
rc=(BOOL)WinSendMsg(WinQueryWindow(hwnd, QW_PARENT), WM_DRAWITEM, MPFROMSHORT(WinQueryWindowUShort(hwnd, QWS_ID)),
MPFROMP(&oi) );
}
if(!rc)
WinFillRect(hps, &rcl3, CLR_WHITE);
rc=FALSE;
if(USERSLIDER) {
OWNERITEM oi={0};
oi.hwnd=hwnd;
oi.hps=hps;
oi.fsState=SLS_OWNERDRAW;/* More to come */
oi.rclItem=rcl2;
oi.idItem=SDA_SLIDERARM;
rc=(BOOL)WinSendMsg(WinQueryWindow(hwnd, QW_PARENT), WM_DRAWITEM, MPFROMSHORT(WinQueryWindowUShort(hwnd, QWS_ID)),
MPFROMP(&oi) );
}
if(!rc)
{
WinFillRect(hps,&rcl2, CLR_BLUE);
WinDrawBorder(hps, &rcl2, 2, 2, 0, 0 ,0x0400);
}
WinEndPaint(hps);
return (MRESULT)0;
}
break;
default:
break;
}
return WinDefWindowProc(hwnd, msg, mp1, mp2);
}
MRESULT EXPENTRY ClientWndProc (HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
static BITMAPINFOHEADER2 bmp ;
static BOOL fButton1Down, fButton2Down ;
static HBITMAP hbm ;
static HDC hdcMemory ;
static HPS hpsMemory ;
static POINTL ptlPointerPos, aptl [3] ;
HPS hpsWindow ;
LONG cxFullScrn, cyFullScrn ;
SIZEL sizl ;
switch (msg)
{
case WM_CREATE:
cxFullScrn = WinQuerySysValue (HWND_DESKTOP, SV_CXFULLSCREEN) ;
cyFullScrn = WinQuerySysValue (HWND_DESKTOP, SV_CYFULLSCREEN) ;
// Create Memory DC and PS
hdcMemory = DevOpenDC (hab, OD_MEMORY, "*", 0L, NULL, 0) ;
sizl.cx = 0 ;
sizl.cy = 0 ;
hpsMemory = GpiCreatePS (hab, hdcMemory, &sizl,
PU_PELS | GPIF_DEFAULT |
GPIT_MICRO | GPIA_ASSOC) ;
// Create monochrome bitmap, return 1 if cannot
bmp.cbFix = sizeof (BITMAPINFOHEADER2) ;
bmp.cx = cxFullScrn ;
bmp.cy = cyFullScrn ;
bmp.cPlanes = 1 ;
bmp.cBitCount = 1 ;
hbm = GpiCreateBitmap (hpsMemory, &bmp, 0L, 0L, NULL) ;
if (hbm == 0)
{
GpiDestroyPS (hpsMemory) ;
DevCloseDC (hdcMemory) ;
return MRFROMSHORT (1) ;
}
// Set bitmap in memory PS and clear it
GpiSetBitmap (hpsMemory, hbm) ;
aptl[1].x = cxFullScrn ;
aptl[1].y = cyFullScrn ;
GpiBitBlt (hpsMemory, 0, 2L, aptl, ROP_ZERO, BBO_OR) ;
return 0 ;
case WM_BUTTON1DOWN:
if (!fButton2Down)
WinSetCapture (HWND_DESKTOP, hwnd) ;
ptlPointerPos.x = MOUSEMSG(&msg)->x ;
ptlPointerPos.y = MOUSEMSG(&msg)->y ;
fButton1Down = TRUE ;
break ; // do default processing
case WM_BUTTON1UP:
if (!fButton2Down)
WinSetCapture (HWND_DESKTOP, NULLHANDLE) ;
fButton1Down = FALSE ;
return 0 ;
case WM_BUTTON2DOWN:
if (!fButton1Down)
WinSetCapture (HWND_DESKTOP, hwnd) ;
ptlPointerPos.x = MOUSEMSG(&msg)->x ;
ptlPointerPos.y = MOUSEMSG(&msg)->y ;
fButton2Down = TRUE ;
break ; // do default processing
case WM_BUTTON2UP:
if (!fButton1Down)
WinSetCapture (HWND_DESKTOP, NULLHANDLE) ;
fButton2Down = FALSE ;
return 0 ;
case WM_MOUSEMOVE:
if (!fButton1Down && !fButton2Down)
break ;
hpsWindow = WinGetPS (hwnd) ;
GpiSetColor (hpsMemory, fButton1Down ? CLR_TRUE : CLR_FALSE) ;
GpiSetColor (hpsWindow,
fButton1Down ? CLR_NEUTRAL : CLR_BACKGROUND) ;
GpiMove (hpsMemory, &ptlPointerPos) ;
GpiMove (hpsWindow, &ptlPointerPos) ;
ptlPointerPos.x = MOUSEMSG(&msg)->x ;
ptlPointerPos.y = MOUSEMSG(&msg)->y ;
GpiLine (hpsMemory, &ptlPointerPos) ;
GpiLine (hpsWindow, &ptlPointerPos) ;
WinReleasePS (hpsWindow) ;
break ; // do default processing
case WM_PAINT:
hpsWindow = WinBeginPaint (hwnd, NULLHANDLE, (PRECTL) aptl) ;
aptl[2] = aptl[0] ;
GpiBitBlt (hpsWindow, hpsMemory, 3L, aptl, ROP_SRCCOPY,
BBO_OR) ;
WinEndPaint (hpsWindow) ;
return 0 ;
case WM_DESTROY:
GpiDestroyPS (hpsMemory) ;
DevCloseDC (hdcMemory) ;
GpiDeleteBitmap (hbm) ;
return 0 ;
}
return WinDefWindowProc (hwnd, msg, mp1, mp2) ;
}
static MRESULT beginDrag(HWND hwnd, POINTS *p)
{
ICQFRAME *cfg = WinQueryWindowPtr(hwnd,0);
RECTL rcl;
POINTL ptl = { p->x, p->y };
CHKPoint();
DBGTrace(p->x);
DBGTrace(p->y);
cfg->xPos =
cfg->yPos = 0xFFFF;
WinMapWindowPoints(hwnd, HWND_DESKTOP, &ptl, 1);
WinQueryWindowRect(hwnd, &rcl);
rcl.xRight -= rcl.xLeft;
rcl.yTop -= rcl.yBottom;
DBGTrace(rcl.xRight);
DBGTrace(rcl.yTop);
if(p->y > (rcl.yTop - TOP_MARGIN) && (p->x < (rcl.xRight - RIGHT_MARGIN)) && (p->x > LEFT_MARGIN) )
{
DBGMessage("Drag window");
cfg->yPos = ptl.y;
cfg->xPos = ptl.x;
cfg->flags |= ICQFRAME_FLAG_MOVEX|ICQFRAME_FLAG_MOVEY;
}
else
{
if(p->x < LEFT_MARGIN)
{
cfg->xPos = ptl.x;
cfg->flags |= ICQFRAME_FLAG_SETCX|ICQFRAME_FLAG_MOVEX;
CHKPoint();
}
if(p->x > (rcl.xRight - RIGHT_MARGIN))
{
CHKPoint();
cfg->xPos = ptl.x;
cfg->flags |= ICQFRAME_FLAG_SETCX;
}
if(p->y < BOTTOM_MARGIN)
{
CHKPoint();
cfg->yPos = ptl.y;
cfg->flags |= ICQFRAME_FLAG_SETCY|ICQFRAME_FLAG_MOVEY;
}
if(p->y > (rcl.yTop - TOP_MARGIN))
{
CHKPoint();
cfg->yPos = ptl.y;
cfg->flags |= ICQFRAME_FLAG_SETCY;
}
}
DBGTracex(cfg->xPos);
DBGTracex(cfg->yPos);
if(cfg->xPos != 0xFFFF || cfg->yPos != 0xFFFF)
{
DBGTrace(cfg->xPos)
DBGTrace(cfg->yPos);
WinSetCapture(HWND_DESKTOP, hwnd);
cfg->timer = WinStartTimer(WinQueryAnchorBlock(hwnd), hwnd, 1, 50);
DBGTracex(cfg->timer);
if(!cfg->timer)
{
DBGMessage("Error starting timer");
icqWriteSysLog(cfg->icq,PROJECT,"Failure starting size timer");
}
}
return (MRESULT) TRUE;
}
/*----------------------------------------------------------------------*/
MRESULT EXPENTRY DMLBSubclassListboxProc( HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2)
/*----------------------------------------------------------------------*/
/* This window procedure is used to subclass a standard PM listbox */
/* control. This procedure will intercept certain mouse events on the */
/* listbox to implement direct-manipulation functions. */
/*----------------------------------------------------------------------*/
{
SHORT Item; /* Listbox item number */
DMLBData *InstData; /* This instance-specific data (per listbox) */
/* The lisbox window pointer is to our instance data. */
InstData = WinQueryWindowPtr(hwnd, QWL_USER);
switch (msg) {
/* Since this is just a subclass setup after the listbox window */
/* is created, we never get a WM_CREATE message here. */
case WM_DESTROY:
/* The listbox window is being destroyed. Cleanup any */
/* resources we have allocated in this subclass. */
if (InstData->DragMIcon != NULLHANDLE) {
WinDestroyPointer(InstData->DragMIcon);
WinDestroyPointer(InstData->DragCIcon);
WinDestroyPointer(InstData->NorthIcon);
WinDestroyPointer(InstData->SouthIcon);
WinDestroyPointer(InstData->DragNoDrp);
WinDestroyPointer(InstData->DeletIcon);
InstData->DragMIcon = NULLHANDLE;
}
/* Cleanup other resources */
if (InstData->Dragging) {
WinStopTimer(WinQueryAnchorBlock(hwnd),hwnd,DRAG_TIMERID);
}
/* Release instance data */
free(InstData);
WinSetWindowPtr(hwnd, 0L, NULL);
break;
case WM_TIMER:
/* We get timer messages during dragging to implement */
/* auto-scrolling of listbox when pointer is placed */
/* north or south of the listbox while dragging. */
if (!InstData->Dragging) /* Ignore if not dragging */
break;
if (SHORT1FROMMP(mp1)==DRAG_TIMERID) {
switch (InstData->PrevLocation) { // Last known location of the pointer
case POINT_INSIDE:
case POINT_OUTSIDE:
/* Do nothing */
break;
case POINT_NORTH:
/* Scroll up one item */
Item = (SHORT)WinSendMsg(InstData->TargetHwnd, LM_QUERYTOPINDEX, 0L, 0L);
if ((Item != LIT_NONE) && (Item != 0))
WinPostMsg(InstData->TargetHwnd, LM_SETTOPINDEX, MPFROMSHORT(Item-1), 0L);
break;
case POINT_SOUTH:
/* Scroll down one item */
Item = (SHORT)WinSendMsg(InstData->TargetHwnd, LM_QUERYTOPINDEX, 0L, 0L);
if (Item != LIT_NONE)
WinPostMsg(InstData->TargetHwnd, LM_SETTOPINDEX, MPFROMSHORT(Item+1), 0L);
break;
} /* switch on PrevLocation */
return 0;
}
break;
case WM_CONTEXTMENU: {
SHORT CursorIndx, Max;
/* User requested context menu... notify our owner. */
/* First find out what item the pointer is over. */
Max = (SHORT)WinSendMsg( hwnd, LM_QUERYITEMCOUNT, 0L, 0L );
CursorIndx = DMLBLocateListboxItem(hwnd, hwnd, SHORT2FROMMP(mp1), LLI_UNDER);
if ((Max == 0) || (CursorIndx+1 > Max))
CursorIndx = LIT_NONE;
/* Tell our owner about it */
return WinSendMsg(WinQueryWindow(hwnd, QW_OWNER), WM_CONTROL,
MPFROM2SHORT(WinQueryWindowUShort(hwnd, QWS_ID), LN_DMLB_CONTEXT),
MPFROMSHORT(CursorIndx));
}
case WM_MOUSEMOVE:
/* Monitor the position of the mouse relative to the listbox */
/* so we can set the pointer icon correctly and note the */
/* position for use during WM_TIMER processing. */
if (!InstData->Dragging) /* Ignore if not dragging */
break;
DMLBCheckTargetLocation(hwnd, InstData, SHORT1FROMMP(mp1), SHORT2FROMMP(mp1));
/* Set pointer icon appropriate for location */
if (InstData->DragMIcon == NULLHANDLE) {
// Load all the pointers (one time only)
InstData->DragMIcon= WinLoadPointer(HWND_DESKTOP, InstData->ResHMod, ID_DMLB_DRAGMOVE);
InstData->DragCIcon= WinLoadPointer(HWND_DESKTOP, InstData->ResHMod, ID_DMLB_DRAGCOPY);
InstData->DragNoDrp= WinLoadPointer(HWND_DESKTOP, InstData->ResHMod, ID_DMLB_DRAGNONE);
InstData->NorthIcon= WinLoadPointer(HWND_DESKTOP, InstData->ResHMod, ID_DMLB_DRGNORTH);
InstData->SouthIcon= WinLoadPointer(HWND_DESKTOP, InstData->ResHMod, ID_DMLB_DRGSOUTH);
InstData->DeletIcon= WinLoadPointer(HWND_DESKTOP, InstData->ResHMod, ID_DMLB_DRGDEL);
}
switch (InstData->PrevLocation) {
case POINT_INSIDE:
switch (InstData->TargetDropMode) {
case DROPMODE_MOVE:
WinSetPointer(HWND_DESKTOP, InstData->DragMIcon); // Use MOVE pointer
break;
case DROPMODE_COPY:
WinSetPointer(HWND_DESKTOP, InstData->DragCIcon); // Use COPY pointer
break;
case DROPMODE_DELETE:
WinSetPointer(HWND_DESKTOP, InstData->DeletIcon); // Use DELETE pointer
break;
}
break;
case POINT_OUTSIDE:
WinSetPointer(HWND_DESKTOP, InstData->DragNoDrp); // No-drop pointer
break;
case POINT_NORTH:
WinSetPointer(HWND_DESKTOP, InstData->NorthIcon); // Scroll-up pointer
break;
case POINT_SOUTH:
WinSetPointer(HWND_DESKTOP, InstData->SouthIcon); // Scroll-down poineter
break;
}
return (MRESULT)TRUE; /* Note we processed the message */
case WM_BEGINDRAG:
{
SHORT Max;
SHORT i, CursorIndx, hit;
/* User started dragging with the pointer on our window */
Max = (SHORT)WinSendMsg( hwnd, LM_QUERYITEMCOUNT, 0L, 0L );
/* If we are currently dragging, cancel it (should not happen) */
if ( InstData->Dragging ) {
InstData->Dragging = FALSE;
WinSetCapture( HWND_DESKTOP, NULLHANDLE );
return (MRESULT)FALSE;
}
/* Get index of item under the mouse pointer and check */
/* for reasonable numeric bounds. */
CursorIndx = DMLBLocateListboxItem(hwnd, hwnd, SHORT2FROMMP(mp1), LLI_UNDER);
if ((Max == 0) || (CursorIndx+1 > Max)) {
DosBeep( 440L, 50L ); // Don't allow drag if not on a listbox item
return (MRESULT)FALSE;
}
/* Since we currently support dragging only a single item, */
/* de-select all items and just select the one under the */
/* pointer. To support multiple-drag we would probably */
/* need to notify the owner so they could set the selection*/
/* status of all items to be dragged (which may or may not */
/* include the item under the pointer). */
WinSendMsg(hwnd, LM_SELECTITEM, MPFROMSHORT(LIT_NONE), MPVOID);
WinSendMsg(hwnd, LM_SELECTITEM, MPFROMSHORT(CursorIndx), MPFROMSHORT(TRUE));
/* Note we are now dragging and capture the pointer. */
InstData->Dragging = TRUE;
WinSetCapture( HWND_DESKTOP, hwnd );
InstData->PrevLocation = POINT_INSIDE;
WinStartTimer(WinQueryAnchorBlock(hwnd),hwnd,DRAG_TIMERID, WinQuerySysValue(HWND_DESKTOP, SV_SCROLLRATE));
return (MRESULT)TRUE;
break;
}
case WM_ENDDRAG:
{
SHORT DropIndx, CurrIndx;
SHORT SourceMax, TargetMax; /* Num of items in source/target listbox */
char *CopyText; /* Text to be copied/moved */
USHORT CopyTextLen; /* Length of text */
void *CopyHand; /* Handle of item to be copied/moved */
BOOL SameList = FALSE; /* Source and target are same listbox */
if (!InstData->Dragging) /* Ignore if we are not dragging */
return (MRESULT)FALSE;
/* Clear dragging indicators and release pointer */
InstData->Dragging = FALSE;
WinSetCapture( HWND_DESKTOP, NULLHANDLE );
WinStopTimer(WinQueryAnchorBlock(hwnd),hwnd,DRAG_TIMERID);
/* See if what is under the pointer will accept the drop */
DMLBCheckTargetLocation(hwnd, InstData, SHORT1FROMMP(mp1), SHORT2FROMMP(mp1));
if (InstData->PrevLocation != POINT_INSIDE)
return (MRESULT)TRUE; /* Ignore drop outside a good listbox */
if (hwnd == InstData->TargetHwnd) // Source and target are same listbox
SameList = TRUE;
SourceMax = (SHORT)WinSendMsg(hwnd, LM_QUERYITEMCOUNT, 0L, 0L ) -1;
TargetMax = (SHORT)WinSendMsg(InstData->TargetHwnd, LM_QUERYITEMCOUNT, 0L, 0L ) -1;
/* Get drop point and original selected point */
DropIndx = DMLBLocateListboxItem(InstData->TargetHwnd, hwnd, SHORT2FROMMP(mp1), LLI_INSERTPOINT);
CurrIndx = (SHORT)WinSendMsg(hwnd, LM_QUERYSELECTION, MPFROMSHORT(LIT_FIRST), 0L);
/* Prevent move onto same item as source, in same listbox */
/* being careful of DropIndx > SourceMax when drop after last item. */
if ((InstData->TargetDropMode==DROPMODE_MOVE) &&
(SameList) &&
((min(DropIndx,SourceMax) == CurrIndx) || (DropIndx == CurrIndx+1))) {
DosBeep( 700L, 50L ); /* Don't drop before or after original */
return (MRESULT)TRUE;
}
/* Make a copy of original to insert */
CopyTextLen = (SHORT)WinSendMsg(hwnd,LM_QUERYITEMTEXTLENGTH,MPFROMSHORT(CurrIndx), 0L) + 1;
CopyText = malloc(CopyTextLen);
WinSendMsg(hwnd, LM_QUERYITEMTEXT, MPFROM2SHORT(CurrIndx, CopyTextLen), MPFROMP(CopyText));
CopyHand = WinSendMsg(hwnd, LM_QUERYITEMHANDLE, MPFROMSHORT(CurrIndx), 0L);
/* Insert before insertion point, or at end of list */
if (DropIndx > TargetMax)
DropIndx = LIT_END;
/* Disable update during insert/delete for smoother visual and */
/* prevent ownerdraw from occuring before new handles are set. */
WinEnableWindowUpdate(hwnd, FALSE);
WinEnableWindowUpdate(InstData->TargetHwnd, FALSE);
/* Insert into target list */
if (InstData->TargetDropMode != DROPMODE_DELETE) {
DropIndx = (SHORT)WinSendMsg(InstData->TargetHwnd, LM_INSERTITEM, MPFROMSHORT(DropIndx), MPFROMP(CopyText));
WinSendMsg(InstData->TargetHwnd, LM_SETITEMHANDLE, MPFROMSHORT(DropIndx), MPFROMP(CopyHand));
}
free(CopyText);
/* Tell owner of originating listbox what we are doing. We must notify */
/* the owner before we delete items because they may keep dynamic data */
/* in the item handles that has to be freed. The item in question is */
/* the currently selected item in the listbox. */
switch (InstData->TargetDropMode) {
case DROPMODE_MOVE:
if (!SameList)
WinSendMsg(WinQueryWindow(hwnd, QW_OWNER), WM_CONTROL,
MPFROM2SHORT(WinQueryWindowUShort(hwnd, QWS_ID), LN_DMLB_DELETE_MOVE),
MPFROMHWND(InstData->TargetHwnd));
break;
case DROPMODE_DELETE:
WinSendMsg(WinQueryWindow(hwnd, QW_OWNER), WM_CONTROL,
MPFROM2SHORT(WinQueryWindowUShort(hwnd, QWS_ID), LN_DMLB_DELETE),
MPFROMHWND(InstData->TargetHwnd));
break;
}
/* If this is a move, delete original. If it is in the same */
/* listbox as target, get new index since it may have */
/* changed due to inserted copy. */
if ((InstData->TargetDropMode == DROPMODE_MOVE) || (InstData->TargetDropMode == DROPMODE_DELETE)) {
CurrIndx = (SHORT)WinSendMsg(hwnd, LM_QUERYSELECTION, MPFROMSHORT(LIT_FIRST), 0L);
WinSendMsg(hwnd, LM_DELETEITEM, MPFROMSHORT(CurrIndx), 0L);
}
/* Select the newly inserted item. If the old copy was */
/* above it in the same list, then the item number has changed by 1 */
if ((DropIndx > CurrIndx) && (SameList) && (InstData->TargetDropMode==DROPMODE_MOVE))
DropIndx--;
if (InstData->TargetDropMode != DROPMODE_DELETE) {
WinSendMsg(InstData->TargetHwnd, LM_SELECTITEM, MPFROMSHORT(LIT_NONE), MPFROMSHORT(FALSE));
WinSendMsg(InstData->TargetHwnd, LM_SELECTITEM, MPFROMSHORT(DropIndx), MPFROMSHORT(TRUE));
}
WinEnableWindowUpdate(hwnd, TRUE);
WinEnableWindowUpdate(InstData->TargetHwnd, TRUE);
/* Notify target of inserted items if necessary */
switch (InstData->TargetDropMode) {
case DROPMODE_MOVE:
if (SameList)
WinSendMsg(WinQueryWindow(InstData->TargetHwnd, QW_OWNER), WM_CONTROL,
MPFROM2SHORT(WinQueryWindowUShort(InstData->TargetHwnd, QWS_ID), LN_DMLB_REORDERED),
MPFROMHWND(hwnd));
else
WinSendMsg(WinQueryWindow(InstData->TargetHwnd, QW_OWNER), WM_CONTROL,
MPFROM2SHORT(WinQueryWindowUShort(InstData->TargetHwnd, QWS_ID), LN_DMLB_INSERT_MOVE),
MPFROMHWND(hwnd));
break;
case DROPMODE_COPY:
WinSendMsg(WinQueryWindow(InstData->TargetHwnd, QW_OWNER), WM_CONTROL,
MPFROM2SHORT(WinQueryWindowUShort(InstData->TargetHwnd, QWS_ID), LN_DMLB_INSERT_COPY),
MPFROMHWND(hwnd));
break;
}
return (MRESULT)TRUE;
}
}
/* Call previous window procedure to process this message */
return ( (*(InstData->OldProcAddr)) ( hwnd, msg, mp1, mp2 ) );
}
MRESULT EXPENTRY stlrTitleBarProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) {
PSTLRFRAME p;
/* -------------------------------------------------------------------
window creation :
store the handle of the owner window, the initial titlebar size,
convert the title substituting \r\n with 1 space, update the titlebar
font
------------------------------------------------------------------- */
if (msg == WM_CREATE) {
// if this is a global exception window, if the window ID is not
// FID_TITLEBAR or if the owner window is not a frame, go to the
// default system titlebar procedure
if (!pd.ppib
|| (((PCREATESTRUCT)mp2)->id != FID_TITLEBAR)
|| !_isFrameWindow(((PCREATESTRUCT)mp2)->hwndOwner))
goto defaultTitlebarProcedure;
// get the frame data
p = (PSTLRFRAME)WinQueryWindowPtr(((PCREATESTRUCT)mp2)->hwndOwner,
g.cd.frame.cbData);
// /*-*/ dbgPrintf5("*** pd.ppib:%08x, id: %04x, isOwnerFrame: %d, p: %08x\n",
// pd.ppib, ((PCREATESTRUCT)mp2)->id,
// _isFrameWindow(((PCREATESTRUCT)mp2)->hwndOwner), p);
// if the frame window is a win32frame initialize the frame data now
if (!p
|| ((p == FL_WIN32FRAME)
&& (NULL
== (p = _initWin32Frame(((PCREATESTRUCT)mp2)->hwndOwner)))))
goto defaultTitlebarProcedure;
// memorizza handle frame window
WinSetWindowPtr(hwnd, g.cd.tbar.cbData, p);
p->hTBar = hwnd;
if (((PCREATESTRUCT)mp2)->pszText)
p->cchTxt = psznconvcpy(p->achTxt, ((PCREATESTRUCT)mp2)->pszText, 260);
p->wrclTitle.x = ((PCREATESTRUCT)mp2)->x;
p->wrclTitle.y = ((PCREATESTRUCT)mp2)->y;
p->wrclTitle.cx = ((PCREATESTRUCT)mp2)->cx;
p->wrclTitle.cy = ((PCREATESTRUCT)mp2)->cy;
// cambia font secondo preferenze
if (o.tb.on && !(o.gen.disabled || pd.we.tbar))
_setPPFont(hwnd, o.tb.achFont);
/* -------------------------------------------------------------------
hiliting/unhiliting of the titlebar :
store the handle of the owner window, the initial titlebar size,
convert the title substituting \r\n with 1 space, update the titlebar
font
------------------------------------------------------------------- */
} else if (msg == TBM_SETHILITE) {
if (_getFrameData(hwnd, p)) {
p->is.tbhilited = (BOOL)mp1;
if (!o.gen.disabled && o.tb.on && !pd.we.tbar) {
if (o.tb.ovrPP
|| (p->is.tbhilited && !p->is.tbactpp)
|| !(p->is.tbhilited || p->is.tbictpp)) {
if (WinIsWindowShowing(hwnd)) {
p->hps = WinGetPS(hwnd);
DrawTitlebar(p);
WinReleasePS(p->hps);
} /* endif */
return (MRESULT)TRUE;
// Š solo apparentemente ridondante, in realt… Š necessario quando
// non Š ovrPP ed Š presente solo PP att. o inatt.
} else if (!(p->is.tbactpp && p->is.tbictpp)) {
repaintWindow(hwnd);
} /* endif */
} /* endif */
} /* endif */
/* -------------------------------------------------------------------
titlebar font/color changed
- if the font changed repaint the window
- if any color changed reset the presparm presence flag
------------------------------------------------------------------- */
} else if (msg == WM_PRESPARAMCHANGED) {
if (!pd.we.tbar && _getFrameData(hwnd, p)) {
ULONG ul;
switch ((LONG)mp1) {
case PP_FONTNAMESIZE:
p->cyfont = 0;
if (o.gen.disabled) break;
if (WinIsWindowShowing(hwnd)) repaintWindow(hwnd);
return (MRESULT)FALSE;
case PP_ACTIVETEXTBGNDCOLOR:
case PP_ACTIVETEXTBGNDCOLORINDEX:
case PP_ACTIVECOLOR:
case PP_ACTIVECOLORINDEX:
p->is.tbactpp = _getPPColor(hwnd, (ULONG)mp1, &ul) != 0;
break;
case PP_INACTIVETEXTBGNDCOLOR:
case PP_INACTIVETEXTBGNDCOLORINDEX:
case PP_INACTIVECOLOR:
case PP_INACTIVECOLORINDEX:
p->is.tbictpp = _getPPColor(hwnd, (ULONG)mp1, &ul) != 0;
break;
} /* endswitch */
} /* endif */
/* -------------------------------------------------------------------
the titlebar text changed. If this is a Win-OS/2 window set the
window words to 0 so that the enhancements are skipped, otherwise
store the new text.
------------------------------------------------------------------- */
} else if (msg == WM_SETWINDOWPARAMS) {
if (!pd.we.tbar && _getFrameData(hwnd, p)) {
// unsubclass winOS2 windows titlebars
if (p->is.winos2) {
_resetDefaultProc(hwnd);
// WinSetWindowULong(hwnd, g.cd.tbar.cbData, 0);
} else {
if ((PWNDPARAMS)mp1 &&
(((PWNDPARAMS)mp1)->fsStatus & WPM_TEXT) &&
((PWNDPARAMS)mp1)->pszText) {
p->cchTxt = psznconvcpy(p->achTxt, ((PWNDPARAMS)mp1)->pszText, 260);
p->cyfont = 0;
} /* endif */
} /* endif */
} /* endif */
/* -------------------------------------------------------------------
titlebar size/position changed : store new size and position
------------------------------------------------------------------- */
} else if (msg == WM_WINDOWPOSCHANGED) {
if ((((PSWP)mp1)->fl & (SWP_SIZE | SWP_MOVE))
&& _getFrameData(hwnd, p)) {
p->wrclTitle.x = ((PSWP)mp1)->x;
p->wrclTitle.y = ((PSWP)mp1)->y;
p->wrclTitle.cx = ((PSWP)mp1)->cx;
p->wrclTitle.cy = ((PSWP)mp1)->cy;
} /* endif */
// **************************************************************************
// these messages are processed only if Styler/2 is not disabled:
} else if (!o.gen.disabled) {
/* -------------------------------------------------------------------
check if this is the roll-the-window mouse event :
------------------------------------------------------------------- */
if ((msg == o.roll.moumsg) && (SHORT2FROMMP(mp2) == o.roll.moukbd)) {
if (!pd.we.wroll
&& o.roll.mou
&& _getFrameData(hwnd, p)
&& !p->is.win32
&& (o.roll.on || p->is.RLon)) {
toggleRollCmd(p->hwnd, p);
return (MRESULT)TRUE;
} /* endif */
/* -------------------------------------------------------------------
check if this is the hide-titlebar mouse event :
------------------------------------------------------------------- */
} else if ((msg == o.tbh.moumsg) && (SHORT2FROMMP(mp2) == o.tbh.moukbd)) {
if (!pd.we.tbarhide
&& o.tbh.mou
&& _getFrameData(hwnd, p)
&& !p->is.win32
// opzione titlehide attiva e non dialogo o disattivazione titlehide
&& ((o.tbh.on && !(p->is.dialog && o.tbh.noDlg)) || p->is.titleHide)) {
toggleTitleBarHidingCmd(p->hwnd, p);
return (MRESULT)TRUE;
} /* endif */
/* -------------------------------------------------------------------
check if this is the change-Zorder mouse event :
------------------------------------------------------------------- */
} else if ((msg == o.sizpos.ZordMoumsg)
&& (SHORT2FROMMP(mp2) == o.sizpos.ZordMoukbd)) {
if (!pd.we.sizemove
&& o.sizpos.Zmove
&& _getFrameData(hwnd, p)) {
_stlrMsgPost(p->hwnd, STLR_ZORDACTIV, SW2_SFMOVETOBOTTOM);
return (MRESULT)TRUE;
} /* endif */
/* -------------------------------------------------------------------
check if this is the snap-to-screen-edge mouse event :
------------------------------------------------------------------- */
} else if ((msg == o.sizpos.snapMoumsg)
&& (SHORT2FROMMP(mp2) == o.sizpos.snapMoukbd)) {
if (!pd.we.sizemove
&& o.sizpos.snap
&& _getFrameData(hwnd, p)) {
// get the rectangle of the window and of its parent
RECTL r, rParent;
WinQueryWindowRect(p->hwnd, &r);
WinQueryWindowRect(_winParent(p->hwnd), &rParent);
// click on the left side of the titlebar
if (MOUSEX(mp1) < (p->wrclTitle.cx / 3)) {
r.xLeft = -p->ptBrd.x;
// click on the right side of the titlebar
} else if (MOUSEX(mp1) > (p->wrclTitle.cx * 2 / 3)) {
r.xLeft = rParent.xRight - r.xRight + p->ptBrd.x;
// click on the (horizontal) middle of the titlebar
} else {
r.xLeft = (rParent.xRight - r.xRight) / 2;
} /* endif */
// click on the bottom of the titlebar
if (MOUSEY(mp1) < (g.sys.cyTbar / 3)) {
r.yBottom = -p->ptBrd.y;
// click on the top of the titlebar
} else if (MOUSEY(mp1) > (g.sys.cyTbar * 2 / 3)) {
r.yBottom = rParent.yTop - r.yTop + p->ptBrd.y;
// click on the (vertical) middle of the titlebar
} else {
r.yBottom = (rParent.yTop - r.yTop) / 2;
} /* endif */
WinSetWindowPos(p->hwnd, 0, r.xLeft, r.yBottom, 0, 0,
SWP_MOVE | SWP_NOADJUST);
} /* endif */
/* -------------------------------------------------------------------
enhanced window painting
------------------------------------------------------------------- */
} else if (msg == WM_PAINT) {
if (!pd.we.tbar
&& o.tb.on
&& _getFrameData(hwnd, p)
&& (o.tb.ovrPP || (p->is.tbhilited && !p->is.tbactpp)
|| !(p->is.tbhilited || p->is.tbictpp))) {
p->hps = WinBeginPaint(hwnd, NULLHANDLE, NULL);
DrawTitlebar(p);
WinEndPaint(p->hps);
return (MRESULT)FALSE;
} /* endif */
/* -------------------------------------------------------------------
override the default window tracking :
------------------------------------------------------------------- */
} else if ((msg == WM_BUTTON1DOWN) || (msg == WM_BUTTON2DOWN)) {
if (_getFrameData(hwnd, p)) {
// override window motion by titlebar drag :
// store the current mouse position (mp1)
// the window motion will start only when the mouse will move
g.tbdrag.mpPos = mp1;
// if the window is not already moving store which mouse button
// has to be released to stop the titlebar drag
if (!g.tbdrag.hwnd) g.tbdrag.msg = ++msg;
// store the handle of the titlebar (mouse motion events are not
// processed when this is NULLHANDLE)
g.tbdrag.hwnd = hwnd;
// cattura i msg successivi del mouse
WinSetCapture(HWND_DESKTOP, hwnd);
return (MRESULT)TRUE;
} /* endif */
/* -------------------------------------------------------------------
terminate window motion through titlebar drag events :
------------------------------------------------------------------- */
} else if ((msg == WM_BUTTON1UP) || (msg == WM_BUTTON2UP)) {
if ((g.tbdrag.hwnd == hwnd)
&& (g.tbdrag.msg == msg)
&& _getFrameData(hwnd, p)) {
HWND hwndParent;
WinSetCapture(HWND_DESKTOP, NULLHANDLE);
g.tbdrag.msg = 0;
g.tbdrag.hwnd = NULLHANDLE;
// if the Ctrl key is not pressed and the window is not yet active
// end the window is a size-move feature exception or the event
// is not related to the Z-order motion feature or the snap-to-
// parent-edge feature activate the window bringing it to the top
if (!(SHORT2FROMMP(mp2) & KC_CTRL)
&& (g.hwnd.active != p->hwnd)
&& (pd.we.sizemove
|| (!(o.sizpos.Zmove
&& (msg == (o.sizpos.ZordMoumsg - 0x3a1))
&& (SHORT2FROMMP(mp2) == o.sizpos.ZordMoukbd))
&& (!(o.sizpos.snap
&& (msg == (o.sizpos.snapMoumsg - 0x3a1))
&& (SHORT2FROMMP(mp2) == o.sizpos.snapMoukbd))))))
WinSetWindowPos(p->hwnd, HWND_TOP, 0, 0, 0, 0,
SWP_ACTIVATE | SWP_ZORDER);
} /* endif */
/* -------------------------------------------------------------------
open the system menu on the titlebar :
------------------------------------------------------------------- */
} else if (msg == WM_CONTEXTMENU) {
if (!pd.we.tbar
&& o.tb.menu
&& _getFrameData(hwnd, p)) {
// if this is the titlebar of a WPS folder simulate a context
// menu event on the client window
if (p->is.folder) {
p->hClient = WinWindowFromID(p->hwnd, FID_CLIENT);
WinPostMsg(p->hClient, WM_CONTEXTMENU,
(MPARAM)0x7fff7fff, MPVOID);
// otherwise get the handle of the system menu and bring it to
// the top via WinPopupMenu()
} else if (p->hSMenu) {
POINTL ptl;
WinQueryPointerPos(g.hwnd.desktop, &ptl);
g.cd.menu.pfnwp(p->hSMenu, MM_QUERYITEM,
(MPARAM)SC_SYSMENU, MPFROMP(&p->mi));
g.hwnd.sysMenu = p->mi.hwndSubMenu;
WinPopupMenu(g.hwnd.desktop, p->hSMenu, g.hwnd.sysMenu,
ptl.x, ptl.y, 0, PU_HCONSTRAIN | PU_VCONSTRAIN |
PU_NONE | PU_KEYBOARD | PU_MOUSEBUTTON1);
} /* endif */
} /* endif */
return (MRESULT)TRUE;
/* -------------------------------------------------------------------
trap WM_MOUSEMOVE to implement various features :
- do not move maximized windows
------------------------------------------------------------------- */
} else if (msg == WM_MOUSEMOVE) {
// if mouse button 1 or 2 were pressed and then the mouse position
// changed
if ((g.tbdrag.hwnd == hwnd)
&& (g.tbdrag.mpPos != mp1)
&& _getFrameData(hwnd, p)) {
WinSetCapture(HWND_DESKTOP, NULLHANDLE);
g.tbdrag.hwnd = NULLHANDLE;
g.tbdrag.msg = 0;
// if this is a maximized window and the don't-move-max-window
// feature is set ignore the event
if (o.maxwin.nomove
&& p->is.max
&& !(pd.we.maxwin || p->is.shield || p->is.ovrdnomovemax))
return (MRESULT)TRUE;
WinSendMsg(p->hwnd, WM_TRACKFRAME, (MPARAM)TF_MOVE, g.tbdrag.mpPos);
// ???????????????????????????????
// this is needed because the next WM_BUTTONxUP is captured by
// the WM_TRACKFRAME processing
// if (!(SHORT2FROMMP(mp2) & KC_CTRL))
// WinSetWindowPos(p->hwnd, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE | SWP_ZORDER);
return (MRESULT)TRUE;
} else if (g.is.onctrl != OCTLTBAR) {
g.is.onctrl = OCTLTBAR;
// ??????????????? this should be redundant
// _resetHideMouTimer();
} /* endif */
} /* endif */
// -------------------------------------------------------------------
} /* endif */
defaultTitlebarProcedure:
return g.cd.tbar.pfnwp(hwnd, msg, mp1, mp2);
}
