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;
}
int main (void)
{
static char szClientClass [] = "Beeper1" ;
static ULONG flFrameFlags = FCF_TITLEBAR | FCF_SYSMENU |
FCF_SIZEBORDER | FCF_MINMAX |
FCF_SHELLPOSITION | FCF_TASKLIST ;
HAB hab ;
HMQ hmq ;
HWND hwndFrame, hwndClient ;
QMSG qmsg ;
hab = WinInitialize (0) ;
hmq = WinCreateMsgQueue (hab, 0) ;
WinRegisterClass (hab, szClientClass, ClientWndProc, 0L, 0) ;
hwndFrame = WinCreateStdWindow (HWND_DESKTOP, WS_VISIBLE,
&flFrameFlags, szClientClass, NULL,
0L, 0, 0, &hwndClient) ;
WinStartTimer (hab, hwndClient, ID_TIMER, 1000) ;
while (WinGetMsg (hab, &qmsg, NULLHANDLE, 0, 0))
WinDispatchMsg (hab, &qmsg) ;
WinStopTimer (hab, hwndClient, ID_TIMER) ;
WinDestroyWindow (hwndFrame) ;
WinDestroyMsgQueue (hmq) ;
WinTerminate (hab) ;
return 0 ;
}
MRESULT EXPENTRY fnAutoHiderDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
switch (msg)
{
case WM_INITDLG:
// Initializing the dialog window:
// Start a timer, which will fire after 10 secs of inactivity, so we can
// hide this dialog window, if the user doesn't press the keyboard
// for 10 secs!
ulAutoHiderTimerID = WinStartTimer(WinQueryAnchorBlock(hwnd),
hwnd,
AUTOHIDER_TIMER_ID,
10000); // 10 secs
break;
case WM_MOUSEMOVE:
case WM_CHAR:
// A key has been pressed, or the mouse was moved, restart timer!
WinStopTimer(WinQueryAnchorBlock(hwnd),
hwnd,
ulAutoHiderTimerID);
ulAutoHiderTimerID = WinStartTimer(WinQueryAnchorBlock(hwnd),
hwnd,
AUTOHIDER_TIMER_ID,
10000); // 10 secs
break;
case WM_TIMER:
if ((SHORT)mp1==AUTOHIDER_TIMER_ID)
{
// Ooops, it's our timer, telling that the user has not pressed any keys
// for a long time!
// It's time to dismiss this dialog!
WinDismissDlg(hwnd, PB_CANCEL);
}
break;
case WM_DESTROY:
WinStopTimer(WinQueryAnchorBlock(hwnd),
hwnd,
ulAutoHiderTimerID);
break;
default:
break;
}
return WinDefDlgProc(hwnd, msg, mp1, mp2);
}
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 */
MRESULT _System DrvMountDrivesDlg( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
if (msg == WM_TIMER && mp1 == (MP)CAM_LVMTMR) {
HEV hev = WinQueryWindowULong( hwnd, QWL_USER);
if (!WinWaitEventSem( hev, 0))
WinSendMsg( hwnd, WM_COMMAND, (MP)CAM_LVMTMR, 0);
return (0);
}
if (msg == WM_COMMAND || msg == WM_SYSCOMMAND) {
ULONG ulChk;
if (!WinStopTimer( 0, hwnd, CAM_LVMTMR))
printf( "DrvMountDrivesDlg - WinStopTimer\n");
ulChk = (ULONG)WinSendDlgItemMsg( hwnd, IDC_AUTOMOUNT,
BM_QUERYCHECK, 0, 0);
DrvSetUseLvm( WinQueryWindow( hwnd, QW_OWNER), ulChk);
WindowClosed( WinQueryWindowUShort( hwnd, QWS_ID));
WinDismissDlg( hwnd, (mp1 == (MP)CAM_LVMTMR));
return (0);
}
if (msg == WM_INITDLG) {
HEV hev = (HEV)mp2;
WinSetWindowULong( hwnd, QWL_USER, hev);
LoadDlgStrings( hwnd, nlsMountDlg);
WinSendDlgItemMsg( hwnd, IDC_AUTOMOUNT, BM_SETCHECK,
(MP)(CAMDRV_IS_NOLVM ? 0 : 1), 0);
ShowDialog( hwnd, 0);
if (!WinWaitEventSem( hev, 0)) {
WindowClosed( WinQueryWindowUShort( hwnd, QWS_ID));
WinDismissDlg( hwnd, TRUE);
}
else
if (!WinStartTimer( 0, hwnd, CAM_LVMTMR, 250))
printf( "DrvMountDrivesDlg - WinStartTimer\n");
return (0);
}
if (msg == WM_FOCUSCHANGE) {
if (SHORT1FROMMP(mp2) && !WinIsWindowEnabled( hwnd)) {
WinPostMsg( WinQueryWindow( hwnd, QW_OWNER),
CAMMSG_FOCUSCHANGE, 0, 0);
return (0);
}
}
return (WinDefDlgProc( hwnd, msg, mp1, mp2));
}
void DisableReloadButton(HWND hwnd)
{
HAB hab = WinQueryAnchorBlock(hwnd);
if (!use_smarttoolbar) return;
WinPostMsg(hwndToolbar,TOOLBAR_USERM_SHOWITEM,MPFROMLONG(TOOLBAR_RELOAD),MPFROMLONG(FALSE));
WinPostMsg(hwndToolbar,TOOLBAR_USERM_UPDATE,0,0);
WinStopTimer(hab,hwnd,ID_TIMER);
}
/****************************************************************************
* TogglePause *
* - Toggles pause status for game *
* Easiest method is to simply disable/enable the timer. *
* - If bCheck is TRUE, returns the current bPaused value, else toggles *
****************************************************************************/
BOOL TogglePause(INT iOption)
{
static BOOL bSPause, bSuspended = FALSE;
static BOOL bPaused = TRUE; /* Game pause toggle */
if (iOption == CHECK)
return(bPaused);
else if (iOption == SUSPEND_ON) {
if (bSuspended) return(TRUE);
bSuspended = TRUE;
bSPause = bPaused;
if (bPaused)
return(TRUE);
}
else if (iOption == SUSPEND_OFF) {
if (!bSuspended) return(FALSE);
bSuspended = FALSE;
if (bSPause)
return(TRUE);
else
bPaused = TRUE;
}
else if (iOption == FORCE_PAUSE)
if (bPaused) return(TRUE);
else bPaused = FALSE;
else if (iOption == FORCE_UNPAUSE)
if (!bPaused) return(FALSE);
else bPaused = TRUE;
if (bSuspended)
CheckMenuItem(hwndMenu, IDM_PAUSE, bSPause);
else
CheckMenuItem(hwndMenu, IDM_PAUSE, !bPaused);
if (bPaused = !bPaused) {
WinStopTimer(hab, hwndClient, ID_TIMER);
/* Show the pointer if it is currently hidden */
ShowMouse(TRUE);
return(TRUE);
}
else {
WinStartTimer(hab, hwndClient, ID_TIMER, iTickLen);
/* Hide the pointer if mouse controls are enabled */
ShowMouse(FALSE);
return(FALSE);
}
}
/*
SaverWindowProc
This is the window procedure of the screen-size window that is
created when the saver starts.
There should be no reason to alter the code.
Note that we do not process WM_PAINT messages. They are forwarded to
the default window procedure, which just validates the window area
and does no drawing. All drawing to the window should be done in
the drawing-thread. Therefore, if you want to blank the screen before
drawing on it for instance, issue a WinFillRect call at the beginning
of your drawing-thread.
*/
MRESULT EXPENTRY SaverWindowProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
switch(msg){
case WM_CREATE:
/* reset the "stop" flag */
stop_draw_thread = FALSE;
/* store window handle */
hwndSaver = hwnd;
/* get presentation space */
hps = WinGetPS(hwnd);
/* start the drawing-thread */
/*
$$$$$ note $$$$$
Some compilers use another parameter ordering for
_beginthread. The _beginthread call below works with EMX,
ICC and BCC. Check your compiler docs for other compilers.
*/
#if defined(__BORLANDC__)
/* for Borland C++ */
tidDraw = _beginthread(draw_thread, STACKSIZE, NULL);
#elif defined(__EMX__) || defined(__IBMC__)
/* for EMX and ICC */
tidDraw = _beginthread(draw_thread, NULL, STACKSIZE, NULL);
#endif
/* create thread to control priority of drawing thread */
if(low_priority){
stop_priority_thread = FALSE;
DosCreateThread(&tidPriority, (PFNTHREAD)priority_thread, 0, 2L, 1000);
}
/* create timer that moves the saver window to top regularly */
WinStartTimer(hab, hwndSaver, IDT_ZORDERTIMER, ZORDERTIMERSTEP);
return (MRESULT)FALSE;
case WM_TIMER:
if(SHORT1FROMMP(mp1) == IDT_ZORDERTIMER){
/* move saver window to top */
WinSetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0, SWP_ZORDER);
return (MRESULT)0;
}
break;
case WM_DESTROY:
/* release the presentation space */
WinReleasePS(hps);
/* stop the z-order timer */
WinStopTimer(hab, hwndSaver, IDT_ZORDERTIMER);
break;
case WM_PAINT:
/* just validate the update area. all drawing is done */
/* in the drawing-thread. */
return WinDefWindowProc(hwnd, msg, mp1, mp2);
}
return WinDefWindowProc(hwnd, msg, mp1, mp2);
}
int main(void)
{
static ULONG flFrameFlags = FCF_TITLEBAR |
FCF_SYSMENU |
FCF_SIZEBORDER |
FCF_MINMAX |
FCF_MENU |
FCF_SHELLPOSITION |
FCF_ACCELTABLE |
FCF_TASKLIST;
hab = WinInitialize(0L);
hmq = WinCreateMsgQueue (hab,0L);
WinRegisterClass (hab, (PSZ) szProgName, (PFNWP) ClientWndProc, CS_SIZEREDRAW|CS_CLIPCHILDREN,0L);
hwndMain = WinCreateStdWindow(HWND_DESKTOP, WS_VISIBLE, &flFrameFlags,
szClientClass, "Drift Warpspeed", WS_VISIBLE,
0L,ID_RESOURCE,
(PHWND) &hwndClient);
// generate gonio tables
generate_tables();
idTimer = WinStartTimer(hab,hwndClient,ID_TIMER,31);
while (WinGetMsg(hab,&qmsg,NULLHANDLE,0,0))
{
WinDispatchMsg(hab,&qmsg);
}
save_hiscores();
if (saveonexit)
save_settings();
free_all();
free_demo();
WinStopTimer(hab,hwndClient,idTimer);
//WinDestroyWindow(hwndMain);
WinDestroyMsgQueue(hmq);
WinTerminate(hab);
return (0);
}
/*
SaverWindowProc
This is the window procedure of the screen-size window that is
created when the saver starts.
There should be no reason to alter the code.
Note that we do not process WM_PAINT messages. They are forwarded to
the default window procedure, which just validates the window area
and does no drawing. All drawing to the window should be done in
the drawing-thread. Therefore, if you want to blank the screen before
drawing on it for instance, issue a WinFillRect call at the beginning
of your drawing-thread.
*/
MRESULT EXPENTRY SaverWindowProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
static SIZEL pagesize={0, 0};
switch(msg){
case WM_CREATE:
// reset the "stop" flag
stop_draw_thread = FALSE;
// store window handle
hwndSaver = hwnd;
// get hdc and create normal presentation space
hdc = WinOpenWindowDC (hwnd);
hps = GpiCreatePS (hab, hdc, &pagesize, GPIA_ASSOC|PU_PELS|GPIT_NORMAL);
// start the drawing-thread
tidDraw = _beginthread(draw_thread, NULL, STACKSIZE, NULL);
// create thread to control priority of drawing thread
if(low_priority){
stop_priority_thread = FALSE;
DosCreateThread(&tidPriority, (PFNTHREAD)priority_thread, 0, 2L, 1000);
}
// create timer that moves the saver window to top regularly
WinStartTimer(hab, hwndSaver, IDT_ZORDERTIMER, ZORDERTIMERSTEP);
return (MRESULT)FALSE;
case WM_TIMER:
if(SHORT1FROMMP(mp1) == IDT_ZORDERTIMER){
// move saver window to top
WinSetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0, SWP_ZORDER);
return (MRESULT)0;
}
break;
case WM_DESTROY:
// destroy the presentation space
GpiDestroyPS(hps);
// stop the z-order timer
WinStopTimer(hab, hwndSaver, IDT_ZORDERTIMER);
break;
case WM_PAINT:
// just validate the update area. all drawing is done
// in the drawing-thread.
return WinDefWindowProc(hwnd, msg, mp1, mp2);
}
return WinDefWindowProc(hwnd, msg, mp1, mp2);
}
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;
}
ATimeHandler //V6
&ATimeHandler :: stopHandlingEventsFor( IWindow *window ) //V6
{ //V6
/*--------------------------- Stop the Timer -----------------------------| V6
| The Presentation Manager stop timer routine is called to stop the | V6
| outstanding timer which is identified by, | V6
| the anchor block handle of the current thread, | V6
| the handle of the window passed in, and | V6
| the ID stored in timerId. | V6
|------------------------------------------------------------------------*/ //V6
WinStopTimer( IThread::current().anchorBlock(), //V6
window->handle(), timerId); //V6
/*-------------------------- Stop the Handler ----------------------------| V6
| Stop the handler by explicitly calling the overridden function. Its | V6
| returned value is used to determine the success of this routine. | V6
|------------------------------------------------------------------------*/ //V6
Inherited::stopHandlingEventsFor(window); //V6
return (*this); //V6
} /* end ATimeHandler :: stopHandlingEventsFor(...) */ //V6
int main (void)
{
static CHAR szClientClass[] = "Clock" ;
static ULONG flFrameFlags = FCF_TITLEBAR | FCF_SYSMENU |
FCF_SIZEBORDER | FCF_MINMAX |
FCF_SHELLPOSITION | FCF_TASKLIST ;
HAB hab ;
HMQ hmq ;
HWND hwndFrame, hwndClient ;
QMSG qmsg ;
hab = WinInitialize (0) ;
hmq = WinCreateMsgQueue (hab, 0) ;
WinRegisterClass (hab, szClientClass, ClientWndProc, CS_SIZEREDRAW, 0) ;
hwndFrame = WinCreateStdWindow (HWND_DESKTOP, WS_VISIBLE,
&flFrameFlags, szClientClass, NULL,
0L, 0, 0, &hwndClient) ;
if (WinStartTimer (hab, hwndClient, ID_TIMER, 1000))
{
while (WinGetMsg (hab, &qmsg, NULLHANDLE, 0, 0))
WinDispatchMsg (hab, &qmsg) ;
WinStopTimer (hab, hwndClient, ID_TIMER) ;
}
else
WinMessageBox (HWND_DESKTOP, hwndClient,
"Too many clocks or timers",
szClientClass, 0, MB_OK | MB_WARNING) ;
WinDestroyWindow (hwndFrame) ;
WinDestroyMsgQueue (hmq) ;
WinTerminate (hab) ;
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;
}
/*************************************************************************
*
* Name : WinProc(hwnd, msg, mp1, mp2)
*
* Description: Processes the messages sent to the main client
* window. This routine processes the basic
* messages all client windows should process.
*
* Concepts : This procedure provides service routines for the general
* PM events (messages) that PM sends to the window, as well
* as the user initiated events (messages) that are generated
* when the user selects the action bar and pulldown menu
* controls or the corresponding keyboard accelerators.
*
* The switch statement shown below distributes the window
* messages to the respective message service routines, which
* are set apart by the case statements. The window
* procedures must provide an appropriate service routine for
* its end user initiated messages, as well as the general PM
* messages (like the WM_CLOSE message). If a message is sent
* to this procedure for which there is no programmed case
* clause (i.e., no service routine), the message is defaulted
* function WinDefWindowProc, where it is disposed of by PM.
*
* Time-consuming tasks are posted to the object window where
* they can be performed without the 1/10 second turnaround
* time imposed on the client window. When the object window
* is busy, the client window is usually disabled. The object
* window then posts an acknowledgement
* back to the client when the lengthy task is completed.
*
* Cases under the big switch appear in alphabetical order.
*
* API's : WinLoadString
* WinMessageBox
* WinQueryWindowULong
* WinSendMsg
* WinPostMsg
* WinIsWindowEnabled
* WinSetPointer
* WinQuerySysPointer
* WinBeginPaint
* WinQueryWindowRect
* WinFillRect
* WinEndPaint
* WinInvalidateRect
* WinSetWindowText
* GpiDrawChain
* GpiConvert
* GpiSetDefaultViewMatrix
* GpiAssociate
* GpiDestroyPS
* GpiDeleteBitmap
* GpiDeleteMetafile
*
* Parameters : HWND window handle
* ULONG message
* MPARAM message parameter 1
* MPARAM message parameter 2
*
* Result : MRESULT message result
*
*************************************************************************/
MRESULT EXPENTRY WinProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
BOOL bOK;
PMAIN_PARM pmp;
HPS hps;
RECTL rectl;
PSZ psz;
CHAR szWork[ LEN_WORKSTRING ];
SHORT sStep;
ULONG ulWork;
SHORT sNewPos;
ULONG rc;
switch(msg)
{
case WM_CLOSE:
/* obtain the main parameter pointer from window words */
pmp = (PMAIN_PARM) WinQueryWindowULong( hwnd, QWL_USER );
#ifdef OSA_AWARE
/* Do OSA termination */
TerminateOSA(hwnd);
#endif
if( pmp->fBusy )
{
/* OK to close when object window is busy? */
WinLoadString( pmp->hab, (HMODULE)NULLHANDLE,
ERRMSG_CLOSE_QUESTION, LEN_WORKSTRING, szWork );
ulWork = WinMessageBox( HWND_DESKTOP,
pmp->hwndFrame,
szWork,
pmp->pszTitle,
(USHORT)0,
MB_YESNOCANCEL | MB_MOVEABLE |
MB_CUANOTIFICATION | MB_APPLMODAL);
if( ulWork == MBID_YES )
{
/* close down the application in spite of being busy */
pmp->fCancel = TRUE;
/* disable client during exit */
WinSendMsg( hwnd, WM_USER_DISABLE_CLIENT, (MPARAM)0 , (MPARAM)0 );
/* start a watchdog timer to ensure a timely death */
WinStartTimer( pmp->hab, hwnd, ID_DEATH_TIMER, LEN_DEATH_TIMER );
/* Tell object window to close, quit, and post me a WM_QUIT */
WinPostMsg( pmp->hwndObject, WM_USER_CLOSE, (MPARAM)hwnd, (MPARAM)0 );
}
}
else
{
/* not busy, so initiate closure by telling object window to close */
WinPostMsg( pmp->hwndObject, WM_USER_CLOSE, (MPARAM)hwnd, (MPARAM)0 );
}
return (MRESULT)NULL;
case WM_COMMAND:
/* do menu activities; see menu.c */
return Menu( hwnd, msg, mp1, mp2 );
case WM_CREATE:
/*
* Do one-time, startup processing in PRTCREAT.C.
* This function allocates the pmp, a pointer to the program's
* main parameters. See the declaration of this block of
* parameters in PRTSAMP.H, the MAIN_PARM structure.
*
* The Create() function allocates this structure and
* begins to initialize it. Throughout all the code, the pmp->
* pointer is usually obtainable with a call to WinQueryWindowULong.
* Window word space for this pointer was reserved on the call
* to WinRegisterClass.
*
* Create() allocates, initializes, and stores the pmp pointer
* in the client window words. It then starts thread 2 of the
* application on which the object window operates. The pmp
* pointer is passed to thread 2 with _beginthread in PRTCREAT.C.
* The pmp is passed to the object window on the call to
* WinCreateWindow in PRTOBJ.C. Finally, the object window stores
* the pmp in its window words under the WM_CREATE case of the
* ObjectWinProc in PRTOBJ.C.
*
*/
Create( hwnd );
#ifdef OSA_AWARE
/* Do OSA Initialization */
InitOSA(hwnd);
#endif
#ifdef OSA_AWARE
/* Generate a Apple Event - Open Application to myself (Workaround) */
rc = GenerateOSAEvent(hwnd, msg, MPFROMSHORT(IDM_AEOPENAPP), mp2);
#endif
return (MRESULT)NULL;
case WM_HSCROLL:
pmp = (PMAIN_PARM) WinQueryWindowULong( hwnd, QWL_USER );
/* Compute some fraction of scroll bar range for a unit of scrolling. */
sStep = pmp->sHScrollRange / 50;
switch( SHORT2FROMMP( mp2 ))
{
case SB_LINELEFT:
pmp->sHScrollPos -= sStep;
break;
case SB_PAGELEFT:
pmp->sHScrollPos -= pmp->sizelClient.cx;
break;
case SB_LINERIGHT:
pmp->sHScrollPos += sStep;
break;
case SB_PAGERIGHT:
pmp->sHScrollPos += pmp->sizelClient.cx;
break;
case SB_SLIDERPOSITION:
case SB_SLIDERTRACK:
pmp->sHScrollPos = SHORT1FROMMP( mp2 );
break;
}
/* Don't allow step assignments to exceed limits of zero to range. */
pmp->sHScrollPos = max( (SHORT)0,
min( pmp->sHScrollPos, pmp->sHScrollRange ));
if( pmp->sHScrollPos != SHORT1FROMMR(WinSendMsg( pmp->hwndHScroll,
SBM_QUERYPOS, (MPARAM)0, (MPARAM)0 )))
{
/*
* New scroll bar thumbbutton position is different than current.
* Set a new X translation value to effect the scroll.
* Current scale setting affects the X element of the matrix.
*/
pmp->matlfDefView.lM31 = OFFSET_XY_TWIPS - (LONG)(pmp->floatScale *
(float)( pmp->sHScrollPos));
bOK = GpiSetDefaultViewMatrix( pmp->hpsClient,
9,
&pmp->matlfDefView,
TRANSFORM_REPLACE );
pmassert( pmp->hab, bOK );
CalibrateHorizontalScrollBar( pmp );
WinInvalidateRect( hwnd, NULL, FALSE );
}
return (MRESULT) 0;
case WM_MOUSEMOVE:
/* display which pointer? -- could query pmp->fBusy or... */
if( WinIsWindowEnabled( hwnd ))
{
/* not disabled; display regular pointer */
WinSetPointer( HWND_DESKTOP,
WinQuerySysPointer( HWND_DESKTOP, SPTR_ARROW, FALSE ));
}
else
{
/* disabled; display hourglass because I'm busy */
WinSetPointer( HWND_DESKTOP,
WinQuerySysPointer( HWND_DESKTOP, SPTR_WAIT, FALSE ));
}
return (MRESULT) 1;
case WM_NACK_BITMAP_NOT_SUPPORTED:
/*
* Object window does not support this format of bitmap -
* show a message box.
*/
pmp = (PMAIN_PARM) WinQueryWindowULong( hwnd, QWL_USER );
WinSendMsg( hwnd, WM_USER_ENABLE_CLIENT, (MPARAM)0, (MPARAM)0 );
bOK = WinLoadString( pmp->hab, (HMODULE)0,
ERRMSG_BITMAP_NOT_SUPPORTED, LEN_WORKSTRING, szWork );
pmassert( pmp->hab, bOK );
WinMessageBox( HWND_DESKTOP,
pmp->hwndFrame,
szWork,
pmp->pszTitle,
(USHORT)0,
MB_OK | MB_MOVEABLE | MB_CUACRITICAL | MB_APPLMODAL);
pmp->ulNextMode = MODE_UNKNOWN;
pmp->szNextFilename[0] = 0;
WinPostMsg( hwnd, WM_USER_NEW_MODE, (MPARAM)0, (MPARAM)0 );
return (MRESULT) 0;
case WM_NACK_BITMAP_ERROR:
/*
* Object window had error loading the bitmap file -
* show a message box
*/
pmp = (PMAIN_PARM) WinQueryWindowULong( hwnd, QWL_USER );
WinSendMsg( hwnd, WM_USER_ENABLE_CLIENT, (MPARAM)0, (MPARAM)0 );
bOK = WinLoadString( pmp->hab,
(HMODULE)NULLHANDLE,
ERRMSG_BAD_BITMAP,
LEN_WORKSTRING,
szWork );
pmassert( pmp->hab, bOK );
WinMessageBox( HWND_DESKTOP,
pmp->hwndFrame,
szWork,
pmp->pszTitle,
(USHORT)0,
MB_OK | MB_MOVEABLE | MB_CUAWARNING | MB_APPLMODAL);
pmp->ulNextMode = MODE_UNKNOWN;
pmp->szNextFilename[0] = 0;
WinPostMsg( hwnd, WM_USER_NEW_MODE, (MPARAM)0, (MPARAM)0 );
return (MRESULT) 0;
case WM_NACK_FILE_READING_ERROR:
/*
* Object window had a problem with reading the disk -
* show a message box.
*/
pmp = (PMAIN_PARM) WinQueryWindowULong( hwnd, QWL_USER );
WinSendMsg( hwnd, WM_USER_ENABLE_CLIENT, (MPARAM)0, (MPARAM)0 );
bOK = WinLoadString( pmp->hab, (HMODULE)NULLHANDLE,
ERRMSG_READ_ERROR, LEN_WORKSTRING, szWork );
pmassert( pmp->hab, bOK );
WinMessageBox( HWND_DESKTOP,
pmp->hwndFrame,
szWork,
pmp->pszTitle,
(USHORT)0,
MB_OK | MB_MOVEABLE | MB_CUACRITICAL | MB_APPLMODAL);
pmp->ulNextMode = MODE_UNKNOWN;
pmp->szNextFilename[0] = 0;
WinPostMsg( hwnd, WM_USER_NEW_MODE, (MPARAM)0, (MPARAM)0 );
return (MRESULT) 0;
case WM_PAINT:
pmp = (PMAIN_PARM) WinQueryWindowULong( hwnd, QWL_USER );
/* do not rely on client window rectangle being correct */
WinQueryUpdateRect( hwnd, &rectl );
WinQueryWindowRect( hwnd, &rectl );
/* current mode of the program affects window painting */
switch( pmp->ulMode )
{
case MODE_UNKNOWN:
WinSendMsg( hwnd, WM_USER_DISABLE_CLIENT, (MPARAM)0, (MPARAM)0 );
WinPostMsg( pmp->hwndObject, WM_USER_PAINT_DEFAULT_SCREEN,
(MPARAM)hwnd, (MPARAM)0 );
/* must call default window proc for window validation */
break;
case MODE_TEXT:
if( pmp->fBusy )
{
/*
* Object window is busy with the client PS drawing into
* retained segments. Use a cached micro PS to merely
* fill the client window with a background wash.
*
* Proper painting of the text will occur in due time
* because the WM_USER_ACK case below will
* invalidate the client window and force a paint.
* The object window won't be busy then.
*/
hps = WinBeginPaint( hwnd, (HPS) 0, &rectl );
pmassert( pmp->hab, hps );
bOK = WinFillRect( hps, &rectl, SYSCLR_WINDOW );
pmassert( pmp->hab, bOK );
WinEndPaint( hps );
}
else
{
/* PS not busy. Use GpiDrawChain to repaint the text */
hps = WinBeginPaint( hwnd, (HPS)pmp->hpsClient, &rectl );
pmassert( pmp->hab, hps );
bOK = WinFillRect( pmp->hpsClient, &rectl, SYSCLR_WINDOW );
pmassert( pmp->hab, bOK );
/*
* GpiDrawChain re-plays the GpiCharString orders that were
* retain in the WM_USER_PAGINATE case in prtobj.c
*/
bOK = GpiDrawChain( pmp->hpsClient );
pmassert( pmp->hab, bOK );
bOK = WinEndPaint( pmp->hpsClient );
pmassert( pmp->hab, bOK );
}
return (MRESULT) 0;
case MODE_BITMAP:
if( pmp->hbm )
{
WinSendMsg( hwnd, WM_USER_DISABLE_CLIENT, (MPARAM)0, (MPARAM)0 );
WinPostMsg( pmp->hwndObject, WM_USER_PAINT_BITMAP,
(MPARAM)hwnd, (MPARAM)0 );
}
/* must call default window proc for window validation */
break;
case MODE_METAFILE:
hps = WinBeginPaint( hwnd, (HPS) 0, &rectl );
pmassert( pmp->hab, hps );
WinFillRect( hps, &rectl, SYSCLR_WINDOW );
if( pmp->hmf )
{
WinSendMsg( hwnd, WM_USER_DISABLE_CLIENT, (MPARAM)0, (MPARAM)0 );
WinPostMsg( pmp->hwndObject, WM_USER_PAINT_METAFILE,
(MPARAM)hwnd, (MPARAM)0 );
}
WinEndPaint( hps );
return (MRESULT) 0;
default:
pmassert( pmp->hab, NULL == "bad case in WM_PAINT" );
}
break;
#ifdef OSA_AWARE
case WM_SEMANTICEVENT:
/* Handle Apple Event Manager Semantic Event */
WinMessageBox( HWND_DESKTOP,
HWND_DESKTOP,
"WM_SEMANTIC_EVENT was received",
"WinProc",
(USHORT)0,
MB_OK | MB_NOICON);
/* Call ProcessSemanticEvent to process the Apple Event */
ProcessSemanticEvent( hwnd, msg, mp1, mp2 );
return (MRESULT) 0;
#endif
case WM_SIZE:
/* Do size process if frame is not minimized */
pmp = (PMAIN_PARM) WinQueryWindowULong( hwnd, QWL_USER );
/*
* If the object window is busy drawing, the GPI calls here can fail
* because the PS is busy. Check for this situation and delay
* the sizing operation by a few milliseconds.
*/
if( pmp->fBusy )
{
WinStartTimer( pmp->hab, hwnd, ID_SIZE_TIMER, LEN_SIZE_TIMER );
return (MRESULT) 0;
}
ulWork = WinQueryWindowULong( pmp->hwndFrame, QWL_STYLE );
if( !( ulWork & WS_MINIMIZED ))
{
/* Frame is not minimized. Get window size in pels. */
WinQueryWindowRect( hwnd, &rectl );
/* how many twips will fit into the client window now? */
bOK = GpiConvert( pmp->hpsClient, CVTC_DEVICE,
CVTC_WORLD, 2L, (PPOINTL)&rectl );
pmassert( pmp->hab, bOK );
/* compute client size in twips, store in pmp */
pmp->sizelClient.cx = rectl.xRight - rectl.xLeft;
pmp->sizelClient.cy = rectl.yTop - rectl.yBottom;
/* Try to keep the current position still in view by calculating */
/* the difference between size required and client window. */
/* The scroll position is then either 0 or the minimum of the */
/* difference and the old scroll position */
sNewPos = (LONG)FixedInchesToTwips(pmp->form.fxxWidth) +
(((float)(2 * OFFSET_XY_TWIPS)) / pmp->floatScale) -
pmp->sizelClient.cx;
pmp->sHScrollPos = min( max( 0, sNewPos), pmp->sHScrollPos);
sNewPos = (LONG)FixedInchesToTwips(pmp->form.fxyHeight) +
(((float)(2 * OFFSET_XY_TWIPS)) / pmp->floatScale) -
pmp->sizelClient.cy;
pmp->sVScrollPos = min( max( 0, sNewPos), pmp->sVScrollPos);
/* recalibrate the scroll bars */
CalibrateHorizontalScrollBar( pmp );
CalibrateVerticalScrollBar( pmp );
/*
* Modify def-view matrix translation to home the displayed page.
* This depends on the current scaling value.
*/
pmp->matlfDefView.lM31 = OFFSET_XY_TWIPS - (LONG)(pmp->floatScale *
(float)( pmp->sHScrollPos));
pmp->matlfDefView.lM32 = OFFSET_XY_TWIPS + (LONG)(pmp->floatScale *
(float)( pmp->sVScrollPos - pmp->sVScrollRange ));
bOK = GpiSetDefaultViewMatrix( pmp->hpsClient, 9,
&pmp->matlfDefView, TRANSFORM_REPLACE );
pmassert( pmp->hab, bOK );
/* force a paint */
WinInvalidateRect( hwnd, NULL, FALSE );
}
return (MRESULT) 0;
case WM_TIMER:
pmp = (PMAIN_PARM) WinQueryWindowULong( hwnd, QWL_USER );
switch( (ULONG) mp1 )
{
case ID_DEATH_TIMER:
/* object window never posted a quit in allotted time.
WinPostMsg( hwnd, WM_QUIT, 0, 0 );
break;
case ID_SIZE_TIMER:
/* object window was busy with the PS before; try sizing now */
bOK = WinStopTimer( pmp->hab, hwnd, ID_SIZE_TIMER );
pmassert( pmp->hab, bOK );
WinSendMsg( hwnd, WM_SIZE, 0, 0 );
break;
}
return (MRESULT) 0;
case WM_USER_ACK:
/*
* Object window is done processing lengthy task.
* mp1 contains the WM_USER msg originally posted to the object window
* mp2 may contain a result code, depending on mp1
*/
pmp = (PMAIN_PARM) WinQueryWindowULong( hwnd, QWL_USER );
/* reenable the client window */
WinSendMsg( hwnd, WM_USER_ENABLE_CLIENT, (MPARAM)0, (MPARAM)0 );
switch( (ULONG)mp1 )
{
case WM_USER_LOAD_BITMAP:
case WM_USER_LOAD_METAFILE:
case WM_USER_LOAD_TEXT:
/*
* Do size processing so that document will
* "home" in the client window.
*/
WinSendMsg( hwnd, WM_SIZE, (MPARAM)0, (MPARAM)0 );
break;
case WM_USER_PAGINATE:
switch( (ULONG)mp2 )
{
case PAGINATE_EOF:
case PAGINATE_EOF_PART_PAGE:
/* seek top of file */
fseek( pmp->f, 0, SEEK_SET );
}
WinInvalidateRect( hwnd, NULL, FALSE );
break;
}
return (MRESULT) 0;
case WM_USER_DISABLE_CLIENT:
/*
* usually disable before posting a task to the object window
* this message may be sent; disable menu action bar as well
*/
pmp = (PMAIN_PARM) WinQueryWindowULong( hwnd, QWL_USER );
pmp->fBusy = TRUE;
WinEnableWindow( pmp->hwndClient, FALSE );
WinEnableWindow( pmp->hwndMenubar, FALSE );
WinEnableControl( pmp->hwndFrame, FID_HORZSCROLL, FALSE );
WinEnableControl( pmp->hwndFrame, FID_VERTSCROLL, FALSE );
WinEnableMenuItem( pmp->hwndMenubar, IDM_PAGEDOWN, FALSE );
WinEnableMenuItem( pmp->hwndMenubar, IDM_VIEWFULL, FALSE );
WinEnableMenuItem( pmp->hwndMenubar, IDM_VIEWHALF, FALSE );
return (MRESULT)0;
case WM_USER_ENABLE_CLIENT:
/*
* usually enable upon receipt of object window ack/nack
* this message may be sent; enable menu actions if text mode
*/
pmp = (PMAIN_PARM) WinQueryWindowULong( hwnd, QWL_USER );
pmp->fBusy = FALSE;
WinEnableWindow( pmp->hwndClient, TRUE );
WinEnableWindow( pmp->hwndMenubar, TRUE );
WinEnableControl( pmp->hwndFrame, FID_HORZSCROLL, TRUE );
WinEnableControl( pmp->hwndFrame, FID_VERTSCROLL, TRUE );
WinEnableMenuItem( pmp->hwndMenubar, IDM_VIEWFULL, TRUE );
WinEnableMenuItem( pmp->hwndMenubar, IDM_VIEWHALF, TRUE );
if( pmp->ulMode == MODE_TEXT )
{
WinEnableMenuItem( pmp->hwndMenubar, IDM_PAGEDOWN, TRUE );
}
return (MRESULT) 0;
case WM_USER_NEW_MODE:
/*
* The program now has a new file, file type, or printer, or
* printer form, orientation, resolution, etc. The receipt
* and processing of this message works to reset the program:
* Old file, bitmap, or metafile handles are closed, and
* new ones get opened. The titlebar shows the new filename.
* This case works very much like a program reset.
*/
pmp = (PMAIN_PARM) WinQueryWindowULong( hwnd, QWL_USER );
/* close processing on current file */
switch( pmp->ulMode )
{
case MODE_BITMAP:
/* destroy previous memory dc, ps, and hbm */
if( pmp->hpsMemory )
{
GpiAssociate( pmp->hpsMemory, (HDC)0 );
GpiDestroyPS( pmp->hpsMemory );
pmp->hpsMemory = (HPS) 0;
}
if( pmp->hdcMemory )
{
DevCloseDC( pmp->hdcMemory );
pmp->hdcMemory = (HDC) 0;
}
if( pmp->hbm )
{
GpiDeleteBitmap( pmp->hbm );
pmp->hbm = (HBITMAP) 0;
}
break;
case MODE_METAFILE:
/* destroy old metafile handle */
if( pmp->hmf )
{
GpiDeleteMetaFile( pmp->hmf );
pmp->hmf = (HMF) 0;
}
break;
case MODE_TEXT:
fclose( pmp->f );
pmp->f = (FILE *) 0;
/* turn off options for text mode */
WinEnableMenuItem( pmp->hwndMenubar, IDM_PAGEDOWN, FALSE );
WinEnableMenuItem( pmp->hwndMenubar, IDM_SETFONT, FALSE );
break;
}
/* turn off options for all modes */
WinEnableMenuItem( pmp->hwndMenubar, IDM_VIEWHALF, FALSE );
WinEnableMenuItem( pmp->hwndMenubar, IDM_VIEWFULL, FALSE );
WinEnableControl( pmp->hwndFrame, FID_HORZSCROLL, FALSE );
WinEnableControl( pmp->hwndFrame, FID_VERTSCROLL, FALSE );
/* copy over current values with the next values */
pmp->ulMode = pmp->ulNextMode;
strcpy( pmp->szFilename, pmp->szNextFilename );
/* enable the print menu option if mode is known and there
is a printer set up. */
WinEnableMenuItem( pmp->hwndMenubar, IDM_PRINT,
(pmp->ulMode != MODE_UNKNOWN && pmp->hpsPrinterInfo ) );
/* update title bar text and show filename in use */
if( *pmp->szFilename )
{
/* parse full-qualified filename to just get filename and extension */
psz = strrchr( pmp->szFilename, '\\' );
if (psz && *psz)
{
++psz;
}
else
{
psz = pmp->szFilename;
}
sprintf( szWork, "%s - %s", pmp->pszTitle, psz );
}
else
{
strcpy( szWork, pmp->pszTitle );
}
WinSetWindowText( pmp->hwndTitlebar, szWork );
/* enable options for all modes */
WinEnableMenuItem( pmp->hwndMenubar, IDM_VIEWHALF, TRUE );
WinEnableMenuItem( pmp->hwndMenubar, IDM_VIEWFULL, TRUE );
WinEnableControl( pmp->hwndFrame, FID_HORZSCROLL, TRUE );
WinEnableControl( pmp->hwndFrame, FID_VERTSCROLL, TRUE );
/* process this new mode */
switch( pmp->ulMode )
{
case MODE_BITMAP:
/* load the bitmap into memory so it is compatible with the screen */
WinSendMsg( hwnd, WM_USER_DISABLE_CLIENT, 0, 0 );
WinPostMsg( pmp->hwndObject, WM_USER_LOAD_BITMAP,
(MPARAM)hwnd, (MPARAM)FLAGS_SCREEN );
break;
case MODE_METAFILE:
/* make object window read metafile */
WinSendMsg( hwnd, WM_USER_DISABLE_CLIENT, 0, 0 );
WinPostMsg( pmp->hwndObject, WM_USER_LOAD_METAFILE, (MPARAM)hwnd, 0 );
break;
case MODE_TEXT:
/* turn on options for text mode */
WinEnableMenuItem( pmp->hwndMenubar, IDM_PAGEDOWN, TRUE );
WinEnableMenuItem( pmp->hwndMenubar, IDM_SETFONT, TRUE );
/* reset view matrix that was last in effect for viewing text pages; */
/* this gets lost after viewing a metafile */
bOK = GpiSetDefaultViewMatrix( pmp->hpsClient, 9,
&pmp->matlfDefView, TRANSFORM_REPLACE );
pmassert( pmp->hab, bOK );
/* disable until text loaded */
WinSendMsg( hwnd, WM_USER_DISABLE_CLIENT, 0, 0 );
/* tell object window to load the text file */
bOK = WinPostMsg( pmp->hwndObject, WM_USER_LOAD_TEXT, (MPARAM)hwnd, 0 );
pmassert( pmp->hab, bOK );
break;
case MODE_UNKNOWN:
/* size screen to get correct scrollbars */
WinPostMsg( pmp->hwndClient, WM_SIZE, 0, 0 );
break;
}
return (MRESULT) 0;
case WM_VSCROLL:
pmp = (PMAIN_PARM) WinQueryWindowULong( hwnd, QWL_USER );
/* Compute some fraction of scroll bar range for a unit of scrolling. */
sStep = pmp->sVScrollRange / 50;
switch( SHORT2FROMMP( mp2 ))
{
case SB_LINEUP:
pmp->sVScrollPos -= sStep;
break;
case SB_PAGEUP:
pmp->sVScrollPos -= pmp->sizelClient.cy;
break;
case SB_LINEDOWN:
pmp->sVScrollPos += sStep;
break;
case SB_PAGEDOWN:
pmp->sVScrollPos += pmp->sizelClient.cy;
break;
case SB_SLIDERPOSITION:
case SB_SLIDERTRACK:
sNewPos = SHORT1FROMMP( mp2 );
pmp->sVScrollPos = sNewPos;
break;
}
/* Don't allow step assignments to exceed limits of zero to range. */
pmp->sVScrollPos = max( (SHORT)0,
min( pmp->sVScrollPos, pmp->sVScrollRange ));
if( pmp->sVScrollPos != SHORT1FROMMR(WinSendMsg( pmp->hwndVScroll,
SBM_QUERYPOS, (MPARAM)0, (MPARAM)0 )))
{
/*
* New scroll bar thumbbutton position is different than current.
* Set a new Y translation value to effect the scroll.
* Current scale setting affects the Y element of the matrix.
*/
pmp->matlfDefView.lM32 = OFFSET_XY_TWIPS + (LONG)(pmp->floatScale *
(float)( pmp->sVScrollPos - pmp->sVScrollRange ));
pmp->matlfDefView.lM32 = (LONG)(pmp->floatScale *
(float)( OFFSET_XY_TWIPS +
pmp->sVScrollPos -
pmp->sVScrollRange ));
bOK = GpiSetDefaultViewMatrix( pmp->hpsClient,
9,
&pmp->matlfDefView,
TRANSFORM_REPLACE );
pmassert( pmp->hab, bOK );
CalibrateVerticalScrollBar( pmp );
WinInvalidateRect( hwnd, NULL, FALSE );
}
return (MRESULT) 0;
}
return WinDefWindowProc( hwnd, msg, mp1, mp2 );
} /* End of WinProc */
MRESULT EXPENTRY fnSaverWindowProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
SWP swpDlg, swpParent;
HWND hwndDlg;
int rc;
switch( msg )
{
case WM_SUBCLASS_INIT:
case WM_CREATE: {
RECTL rclRect;
// Any initialization of the window and variables should come here.
// the timer for the moving text
ulAnimationTimerID = WinStartTimer(WinQueryAnchorBlock(hwnd), hwnd, ANIMATION_TIMER_ID, 20);
// setup the initial coordinates for the scrolling text
WinQueryWindowRect(hwnd, &rclRect);
textX = rclRect.xRight;
textY = rclRect.yTop/2;
// Hide mouse pointer, if we're in real screen-saving mode!
if (!bOnlyPreviewMode) WinShowPointer(HWND_DESKTOP, FALSE);
// Initialize WMCHAR record
internal_InitWMCHARRecord();
break; }
case WM_CHAR:
if (!bOnlyPreviewMode) internal_SaveWMCHAREventToRecord(mp1, mp2);
break;
case WM_ASKPASSWORD:
{
// Get parameters
char *pchPwdBuff = (char *) mp1;
int iPwdBuffSize = (int) mp2;
// Show mouse pointer, if we're screensaving.
if (!bOnlyPreviewMode)
WinShowPointer(HWND_DESKTOP, TRUE);
hwndDlg = WinLoadDlg(hwnd, hwnd,
fnAutoHiderDlgProc,
hmodOurDLLHandle,
DLG_PASSWORDPROTECTION,
NULL);
if (!hwndDlg)
{
// Could not load dialog window resources!
if (!bOnlyPreviewMode)
WinShowPointer(HWND_DESKTOP, FALSE);
return (MRESULT) SSMODULE_ERROR_INTERNALERROR;
}
// Ok, dialog window loaded!
// Now set its texts (NLS)
internal_SetPageFont(hwndDlg);
internal_SetPwdProtWindowText(hwndDlg);
// Resize the window so text will fit!
internal_ArrangePwdProtWindowControls(hwndDlg);
// Initialize control(s)!
WinSendDlgItemMsg(hwndDlg, EF_PASSWORD,
EM_SETTEXTLIMIT,
(MPARAM) (iPwdBuffSize-1),
(MPARAM) 0);
WinSetDlgItemText(hwndDlg, EF_PASSWORD, "");
// Center dialog in screen
if (WinQueryWindowPos(hwndDlg, &swpDlg))
if (WinQueryWindowPos(hwnd, &swpParent))
{
// Center dialog box within the screen
int ix, iy;
ix = swpParent.x + (swpParent.cx - swpDlg.cx)/2;
iy = swpParent.y + (swpParent.cy - swpDlg.cy)/2;
WinSetWindowPos(hwndDlg, HWND_TOP, ix, iy, 0, 0,
SWP_MOVE);
}
WinSetWindowPos(hwndDlg, HWND_TOP, 0, 0, 0, 0,
SWP_SHOW | SWP_ACTIVATE | SWP_ZORDER);
// Re-send WM_CHAR messages if needed
if (bFirstKeyGoesToPwdWindow) internal_ReplayWMCHARRecord();
// Process the dialog!
rc = WinProcessDlg(hwndDlg);
if (rc!=PB_OK)
{
// The user pressed cancel!
rc = SSMODULE_ERROR_USERPRESSEDCANCEL;
} else
{
// The user pressed OK!
// Get the entered password
WinQueryDlgItemText(hwndDlg, EF_PASSWORD,
iPwdBuffSize,
pchPwdBuff);
rc = SSMODULE_NOERROR;
}
// Destroy window
WinDestroyWindow(hwndDlg);
// Hide mouse pointer again, if we're screensaving.
if (!bOnlyPreviewMode)
WinShowPointer(HWND_DESKTOP, FALSE);
return (MRESULT) rc;
}
case WM_SHOWWRONGPASSWORD:
// Show mouse pointer, if we're screensaving.
if (!bOnlyPreviewMode)
WinShowPointer(HWND_DESKTOP, TRUE);
hwndDlg = WinLoadDlg(hwnd, hwnd,
fnAutoHiderDlgProc,
hmodOurDLLHandle,
DLG_WRONGPASSWORD,
NULL);
if (!hwndDlg)
{
// Could not load dialog window resources!
if (!bOnlyPreviewMode)
WinShowPointer(HWND_DESKTOP, FALSE);
return (MRESULT) SSMODULE_ERROR_INTERNALERROR;
}
// Ok, dialog window loaded!
// Now set its texts (NLS)
internal_SetPageFont(hwndDlg);
internal_SetWrongPwdWindowText(hwndDlg);
// Resize the window so text will fit!
internal_ArrangeWrongPwdWindowControls(hwndDlg);
// Center dialog in screen
if (WinQueryWindowPos(hwndDlg, &swpDlg))
if (WinQueryWindowPos(hwnd, &swpParent))
{
// Center dialog box within the screen
int ix, iy;
ix = swpParent.x + (swpParent.cx - swpDlg.cx)/2;
iy = swpParent.y + (swpParent.cy - swpDlg.cy)/2;
WinSetWindowPos(hwndDlg, HWND_TOP, ix, iy, 0, 0,
SWP_MOVE);
}
WinSetWindowPos(hwndDlg, HWND_TOP, 0, 0, 0, 0,
SWP_SHOW | SWP_ACTIVATE | SWP_ZORDER);
// Process the dialog!
rc = WinProcessDlg(hwndDlg);
// Destroy window
WinDestroyWindow(hwndDlg);
// Hide mouse pointer again, if we're screensaving.
if (!bOnlyPreviewMode)
WinShowPointer(HWND_DESKTOP, FALSE);
return (MRESULT) SSMODULE_NOERROR;
case WM_SUBCLASS_UNINIT:
case WM_DESTROY:
// All kinds of cleanup (the opposite of everything done in WM_CREATE)
// should come here.
WinStopTimer(WinQueryAnchorBlock(hwnd), hwnd, ulAnimationTimerID);
// Restore mouse pointer, if we're in real screen-saving mode!
if (!bOnlyPreviewMode)
WinShowPointer(HWND_DESKTOP, TRUE);
break;
case WM_ADJUSTWINDOWPOS:
if (!bOnlyPreviewMode)
{
SWP *pSWP;
// The following is required so that this window will be on
// top of the xCenter window, evenif that is set to be always on top!
// Real screensaving, here we should stay on top!
// Set WS_TOPMOST flag again!
WinSetWindowBits(hwnd, QWL_STYLE, WS_TOPMOST, WS_TOPMOST);
pSWP = (SWP *) mp1;
pSWP->hwndInsertBehind = HWND_TOP;
pSWP->fl |= SWP_ZORDER;
}
break;
case WM_PAINT: {
HPS hpsBeginPaint;
RECTL rclRect, blank, rclWindow;
FONTMETRICS fm;
int len;
#ifdef DEBUG_LOGGING
AddLog("WM_PAINT\n");
#endif
hpsBeginPaint = WinBeginPaint(hwnd, NULLHANDLE, &rclRect);
WinQueryWindowRect(hwnd, &rclRect);
WinQueryWindowRect(hwnd, &rclWindow);
WinSetWindowFontMy(hwnd, "10.Courier");
GpiQueryFontMetrics(hpsBeginPaint, sizeof(fm), &fm);
rclRect.xLeft = textX;
rclRect.yTop = textY;
len = strlen(CfgDlgInit.pchText);
rclRect.xRight = rclRect.xLeft + fm./*lAveCharWidth*/lMaxCharInc * len+5;
rclRect.yBottom = rclRect.yTop - fm.lMaxBaselineExt;
WinDrawText(hpsBeginPaint, len ,CfgDlgInit.pchText, &rclRect, CLR_WHITE, CLR_BLACK, DT_ERASERECT | DT_LEFT | DT_VCENTER);
/* paint the black around the text*/
blank.xLeft = 0; blank.yBottom = 0; blank.xRight = rclRect.xLeft; blank.yTop = rclWindow.yTop; WinFillRect(hpsBeginPaint, &blank, CLR_BLACK);
blank.xLeft = rclRect.xLeft-2; blank.yBottom = rclRect.yTop; blank.xRight = rclWindow.xRight; blank.yTop = rclWindow.yTop; WinFillRect(hpsBeginPaint, &blank, CLR_BLACK);
blank.xLeft = rclRect.xRight; blank.yBottom = 0; blank.xRight = rclWindow.xRight; blank.yTop = rclRect.yTop; WinFillRect(hpsBeginPaint, &blank, CLR_BLACK);
blank.xLeft = rclRect.xLeft-2; blank.yBottom = 0; blank.xRight = rclRect.xRight+2; blank.yTop = rclRect.yBottom; WinFillRect(hpsBeginPaint, &blank, CLR_BLACK);
if (rclRect.xRight <= -10) {
WinQueryWindowRect(hwnd, &rclRect);
textX = rclRect.xRight;
textY = rclRect.yTop/2;
}
WinEndPaint(hpsBeginPaint);
#ifdef DEBUG_LOGGING
AddLog("WM_PAINT done\n");
#endif
return (MRESULT) FALSE;
}
case WM_TIMER:
if (((SHORT)mp1)==ANIMATION_TIMER_ID)
{
// Timer, so make new image position
textX -= 2;
WinInvalidateRect(hwnd, NULL, FALSE);
}
break;
default:
break;
}
return WinDefWindowProc( hwnd, msg, mp1, mp2 );
}
MRESULT EXPENTRY fnwpMain(HWND hwndFrame, ULONG msg, MPARAM mp1, MPARAM mp2)
{
PSZ szData;
PDDESTRUCT pddeStruct;
ULONG mem;
CHAR szBuffer[200];
switch (msg)
{
// all answers to the WinDDEInitate call arrive here
case WM_DDE_INITIATEACK:
{
PDDEINIT pddeInit;
PSZ szInApp, szInTopic;
static BOOL bNetscapeAnswered = FALSE;
pddeInit = (PDDEINIT)mp2;
szInApp = pddeInit->pszAppName;
szInTopic = pddeInit->pszTopic;
G_hServerWnd = (HWND)mp1;
ShowMessage("WM_DDE_INITIATEACK (resp to WinDDEInitiate)");
ShowMessage(" application: \"%s\"",
pddeInit->pszAppName);
ShowMessage(" topic: \"%s\"",
pddeInit->pszTopic);
// RDP 2000-07-07 07:24:18
// There was no check on which application responded.
// This made NETSCDDE fail when another DDE-aware application,
// like EPM, was running.
// Now the handle from mp1 is only assigned if the application
// responding is Netscape.
// If the app is not Netscape then the handle is nullified.
// I don't know if assigning 0 to the handle is correct but
// is seems to solve the problem.
// V0.9.19 (2002-03-28) [umoeller]
// Opera fix: use stricmp instead of strcmp
if (!stricmp(pddeInit->pszAppName,
G_szDDENetscape)) // V0.9.16 (2001-10-02) [umoeller]
{
// ShowMessage("!! Netscape answered.");
G_hServerWnd = (HWND)mp1;
bNetscapeAnswered = TRUE;
}
else
{
// ShowMessage("!! Other application aswered.");
G_hServerWnd = (HWND)0;
}
}
break;
// all answers to DDE requests arrive here
case WM_DDE_DATA:
{
ShowMessage("!! Received data from Netscape: ");
pddeStruct = (PDDESTRUCT) mp2;
DosGetSharedMem(pddeStruct, PAG_READ | PAG_WRITE);
szData = (BYTE *) (pddeStruct + (pddeStruct->offabData));
ShowMessage(szData);
}
break;
// menu item processing (in debug mode, otherwise these
// WM_COMMAND msgs have been posted automatically)
case WM_COMMAND:
switch (SHORT1FROMMP(mp1))
{
// start DDE conversation: this was posted
// by "main" before the PM loop was entered
// (even if we're in debug mode)
case IDM_INITIATE:
// WinPostMsg(G_hwndListbox, LM_DELETEALL, 0, 0);
ShowMessage("IDM_INITIATE:");
ShowMessage("Topic: \"%s\"", G_szOpenURLTopic);
G_context.cb = sizeof(CONVCONTEXT);
G_context.fsContext = 0;
WinDdeInitiate(hwndFrame, G_szDDENetscape,
G_szOpenURLTopic, &G_context);
if (!G_optDebug)
// if we're not in debug mode, post subsequent
// menu commands automatically
WinPostMsg(hwndFrame, WM_COMMAND, MPFROM2SHORT(IDM_CHAIN2, 0), 0);
break;
// "Open URL": request data from server
case IDM_OPENURL:
{
ShowMessage("IDM_OPENURL");
ShowMessage(" URL: \"%s\"", G_szURL);
strlcpy(szBuffer, G_szURL, sizeof(szBuffer));
strlcat(szBuffer, ",,0xFFFFFFFF,0x0", sizeof(szBuffer));
DDERequest(hwndFrame, szBuffer);
}
break;
// "Open URL in new window": request data from server,
// but with different parameters
case IDM_OPENURLNEW:
{
ShowMessage("IDM_OPENURLNEW");
ShowMessage(" URL: \"%s\"", G_szURL);
strlcpy(szBuffer, G_szURL, sizeof(szBuffer));
strlcat(szBuffer, ",,0x0,0x0", sizeof(szBuffer));
DDERequest(hwndFrame, szBuffer);
}
break;
/*
* IDM_CHAIN2:
* this is posted after DDE_INITIATE was
* successful
*/
case IDM_CHAIN2:
{
if (G_optNewWindow)
WinPostMsg(G_hwndDebug, WM_COMMAND, MPFROM2SHORT(IDM_OPENURLNEW, 0), 0);
else
WinPostMsg(G_hwndDebug, WM_COMMAND, MPFROM2SHORT(IDM_OPENURL, 0), 0);
WinPostMsg(G_hwndDebug, WM_COMMAND, MPFROM2SHORT(IDM_CHAIN3, 0), 0);
}
break;
/*
* IDM_CHAIN3:
* this is posted to close the whole thing; we just need
* another msg before going for IDM_CLOSE, or some DDE
* msgs might get lost
*/
case IDM_CHAIN3:
WinPostMsg(G_hwndDebug, WM_COMMAND, MPFROM2SHORT(IDM_CLOSE, 0), 0);
break;
case IDM_FULLSEQUENCE:
WinPostMsg(G_hwndDebug, WM_COMMAND, MPFROM2SHORT(IDM_INITIATE, 0), 0);
WinPostMsg(G_hwndDebug, WM_COMMAND, MPFROM2SHORT(IDM_CHAIN2, 0), 0);
break;
/*
* IDM_CLOSE:
* this is posted to close the whole thing
*/
case IDM_CLOSE:
WinDdePostMsg(G_hServerWnd,
hwndFrame,
WM_DDE_TERMINATE,
NULL,
DDEPM_RETRY);
ShowMessage("DDE connection closed.");
if (!G_optDebug)
WinPostMsg(hwndFrame, WM_COMMAND, MPFROM2SHORT(IDM_DELAYEXIT, 0), 0);
break;
/*
* IDM_DELAYEXIT:
* this is posted after IDM_CLOSE; we will now
* check for whether the DDE conversation with
* Netscape was successful and, if not, start
* a new instance of Netscape according to the
* command line parameters
*/
case IDM_DELAYEXIT:
{
if ( (!G_NetscapeFound)
&& (G_optExecute)
)
{
CHAR szStart[256];
GetNLSString(szStart, sizeof(szStart), ID_NDSI_STARTNETSCAPE);
// confirm start netscape
if ( (!G_optConfirmStart)
// get rid of this hideously ugly dialog
|| (WinMessageBox(HWND_DESKTOP,
HWND_DESKTOP,
szStart,
(PSZ)NETSCDDE_TITLE,
0,
MB_YESNO | MB_MOVEABLE)
== MBID_YES)
/* WinCenteredDlgBox(HWND_DESKTOP,
G_hwndDebug,
WinDefDlgProc,
G_hmodNLS,
ID_NDD_QUERYSTART,
NULL)
== DID_OK) */
)
{
UCHAR achObjBuf[256] = "";
CHAR szArgs[CCHMAXPATH];
HWND hwndNotify = HWND_DESKTOP;
PROGDETAILS pd;
HAPP happ;
// destroy "Contacting", create "Starting Netscape"
// window
WinDestroyWindow(G_hwndContacting);
G_hwndContacting = NULLHANDLE;
if (!G_optQuiet)
{
G_hwndContacting = WinLoadDlg(HWND_DESKTOP, G_hwndDebug,
WinDefDlgProc,
G_hmodNLS, ID_NDD_STARTING,
0);
WinShowWindow(G_hwndContacting, TRUE);
}
strlcpy(szArgs, G_szNetscapeParams, sizeof(szArgs));
strlcat(szArgs, " ", sizeof(szArgs));
strlcat(szArgs, G_szURL, sizeof(szArgs));
// now start app
memset(&pd, 0, sizeof(pd));
pd.Length = sizeof(pd);
pd.progt.progc = PROG_DEFAULT;
pd.progt.fbVisible = SHE_VISIBLE;
pd.pszExecutable = G_szNetscapeApp;
pd.pszParameters = szArgs;
pd.pszStartupDir = G_szStartupDir;
if (!(happ = WinStartApp(NULLHANDLE,
&pd,
szArgs,
NULL,
SAF_INSTALLEDCMDLINE)))
{
DisplayError("WinStartApp failed for app \"%s\", params \"%s\", startup dir \"%s\"",
G_szNetscapeApp,
szArgs,
G_szStartupDir);
}
}
}
// keep "Contacting" / "Starting" window visible for two seconds
G_idTimer = WinStartTimer(G_hab, hwndFrame, 1, 2000);
break;
}
// User closes the window
case IDM_EXIT:
WinPostMsg(hwndFrame, WM_CLOSE, 0, 0);
break;
}
break;
case WM_TIMER:
// after two seconds, close status window
WinStopTimer(G_hab, hwndFrame, G_idTimer);
WinPostMsg(hwndFrame, WM_CLOSE, 0, 0);
break;
// Send the message to the usual WC_FRAME WndProc
default:
return G_SysWndProc(hwndFrame, msg, mp1, mp2);
}
return FALSE;
}
/****************************************************************************
Main Message Cue Dialog Procedure
*****************************************************************************/
MRESULT EXPENTRY MainDlgProc (HWND hWnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
BOOL Handled = TRUE;
MRESULT mReturn = 0;
ULONG ulScrWidth, ulScrHeight;
RECTL Rectl;
POINTL Pointl;
HINI hini;
ULONG temp;
switch (msg)
{
/* Called on startup */
case WM_INITDLG:
ulScrWidth = WinQuerySysValue (HWND_DESKTOP, SV_CXSCREEN);
ulScrHeight = WinQuerySysValue (HWND_DESKTOP, SV_CYSCREEN);
UPDATE_HOURS = TRUE;
UPDATE_DATE = TRUE;
DTSWITCH = FALSE;
hini = HINI_USERPROFILE;
Pointl.x = Pointl.y = 10;
if(PrfQueryProfileSize(hini,pAppname,pKeyname,(PULONG)&temp) &&temp)
{
if(temp == sizeof(POINTL)) PrfQueryProfileData(hini, pAppname,
pKeyname, &Pointl, (PULONG)&temp);
}
WinQueryWindowRect (hWnd, &Rectl);
/*
WinSetWindowPos (hWnd, HWND_TOP, Pointl.x,
Pointl.y, 0, 0, SWP_SHOW | SWP_MOVE | SWP_ACTIVATE);
*/
WinSetWindowPos (hWnd, HWND_TOP, (ulScrWidth-Rectl.xRight)/2,
(ulScrHeight-Rectl.yTop) - 10, 0, 0, SWP_SHOW | SWP_MOVE | SWP_ACTIVATE);
/* A neat little trick to float the window on top... */
WinFocusChange(HWND_DESKTOP,HWND_TOP,0);
timerID = WinStartTimer(hab, hWnd, 1, 1000L);
break;
case WM_TIMER:
if(SHORT1FROMMP(mp1) == timerID)
{
while(DosGetDateTime( &(datetime[DTSWITCH?1:0]) ));
UPDATE_HOURS = ( (datetime[DTSWITCH?1:0].minutes != datetime[DTSWITCH?0:1].minutes)
|| (datetime[DTSWITCH?1:0].hours != datetime[DTSWITCH?0:1].hours ) );
UPDATE_DATE |= ( (datetime[DTSWITCH?1:0].day != datetime[DTSWITCH?0:1].day )
|| (datetime[DTSWITCH?1:0].weekday != datetime[DTSWITCH?0:1].weekday)
|| (datetime[DTSWITCH?1:0].month != datetime[DTSWITCH?0:1].month )
|| (datetime[DTSWITCH?1:0].year != datetime[DTSWITCH?0:1].year ) );
ClockSetDateString( &(datetime[DTSWITCH?1:0]));
DTSWITCH = !DTSWITCH;
if(UPDATE_HOURS)
{
WinSetDlgItemText (hWnd, IDD_TIME, szHours);
if(UPDATE_DATE)
{
WinSetWindowText(hWndFrame,(PSZ)szTitle);
UPDATE_DATE = FALSE;
}
UPDATE_HOURS = FALSE;
}
WinSetDlgItemText (hWnd, IDD_SEC, szSecs);
}
Handled = FALSE;
break;
case WM_SYSCOMMAND:
case WM_COMMAND:
switch (LOUSHORT(mp1))
{
case SC_CLOSE:
hini = HINI_USERPROFILE;
WinStopTimer(hab, hWnd, timerID);
Pointl.x = Pointl.y = 0;
WinMapWindowPoints(hWnd, HWND_DESKTOP, &Pointl, 1);
temp = sizeof(POINTL);
PrfWriteProfileData(hini, pAppname, pKeyname, &Pointl, temp);
WinPostMsg(hWnd, WM_QUIT, 0L, 0L);
break;
default:
Handled = (msg == WM_COMMAND);
break;
}
break; // forget this break and you are in dead trouble !!!
default:
Handled = FALSE;
break;
}
if (!Handled) mReturn = WinDefDlgProc (hWnd, msg, mp1, mp2);
return (mReturn);
}
//----------------------------------------------------------------------------
// NPP_SetWindow:
//----------------------------------------------------------------------------
NPError NP_LOADDS
NPP_SetWindow(NPP instance, NPWindow* window)
{
if (instance == 0 )
return NPERR_INVALID_INSTANCE_ERROR;
PluginInstance* This = (PluginInstance*) instance->pdata;
//
// *Developers*: Before setting fWindow to point to the
// new window, you may wish to compare the new window
// info to the previous window (if any) to note window
// size changes, etc.
//
if((window->window != 0 ) && (This->hWnd == 0 ))
{
This->fWindow = window;
This->hWnd = (HWND)This->fWindow->window;
// subclass the window
This->lpfnOldWndProc = WinSubclassWindow(This->hWnd, SubClassFunc);
AssociateInstance(This->hWnd, This);
// create a PS
if (! This->hps)
{
HDC hdc = WinQueryWindowDC(This->hWnd);
if (! hdc)
hdc = WinOpenWindowDC(This->hWnd);
SIZEL siz = { 0, 0 };
This->hps = GpiCreatePS(WinQueryAnchorBlock(This->hWnd), hdc, &siz,
PU_PELS | GPIT_MICRO | GPIA_ASSOC);
}
}
else {
// if window handle changed
if(This->hWnd != (HWND)window->window) {
// remember the new window
This->fWindow = window;
// Remove the subclass for the old client window
WinSubclassWindow(This->hWnd, This->lpfnOldWndProc);
// remember the new window handle
This->hWnd = (HWND)This->fWindow->window;
if(This->hWnd != 0 ) {
// subclass the new one
This->lpfnOldWndProc = WinSubclassWindow(This->hWnd,
SubClassFunc);
AssociateInstance(This->hWnd, This);
}
// stop old timer and start a new timer
WinStopTimer(WinQueryAnchorBlock(This->hWnd), This->hWnd, kTimerId);
WinStartTimer(WinQueryAnchorBlock(This->hWnd), This->hWnd,
kTimerId, kTimerFrequency);
// destroy old PS and create new PS
if (! This->hps)
GpiDestroyPS(This->hps);
HDC hdc = WinQueryWindowDC(This->hWnd);
if (! hdc)
hdc = WinOpenWindowDC(This->hWnd);
SIZEL siz = { 0, 0 };
This->hps = GpiCreatePS(WinQueryAnchorBlock(This->hWnd), hdc, &siz,
PU_TWIPS | GPIT_MICRO | GPIA_ASSOC);
}
}
return NPERR_NO_ERROR;
}
//-----------------------------------------------------------------------------
// NPP_Destroy:
//-----------------------------------------------------------------------------
NPError NP_LOADDS
NPP_Destroy(NPP instance, NPSavedData** save)
{
if (instance == 0 )
return NPERR_INVALID_INSTANCE_ERROR;
PluginInstance* This = (PluginInstance*) instance->pdata;
//
// *Developers*: If desired, call NP_MemAlloc to create a
// NPSavedDate structure containing any state information
// that you want restored if this plugin instance is later
// recreated.
//
if (This != 0 )
{
// stop the timer
if (This->fTimer)
{
WinStopTimer(WinQueryAnchorBlock(This->hWnd), This->hWnd, kTimerId);
This->fTimer = FALSE;
}
// destroy old PS and create new PS
if (! This->hps)
GpiDestroyPS(This->hps);
// delete clock
delete This->pClock;
// Remove the subclass for the client window
if(This->hWnd)
{
WinSubclassWindow(This->hWnd, This->lpfnOldWndProc);
}
// make some saved instance data if necessary
if(This->pSavedInstanceData == 0 ) {
// make a struct header for the data
This->pSavedInstanceData =
(NPSavedData*)NPN_MemAlloc(sizeof (struct _NPSavedData));
// fill in the struct
if(This->pSavedInstanceData != 0 ) {
This->pSavedInstanceData->len = 0;
This->pSavedInstanceData->buf = 0 ;
// replace the def below and references to it with your data
#define SIDATA "aSavedInstanceDataBlock"
// the data
This->pSavedInstanceData->buf = NPN_MemAlloc(sizeof SIDATA);
if(This->pSavedInstanceData->buf != 0 ) {
strcpy((char*)This->pSavedInstanceData->buf, SIDATA);
This->pSavedInstanceData->len = sizeof SIDATA;
}
}
}
// save some instance data
*save = This->pSavedInstanceData;
NPN_MemFree(instance->pdata);
instance->pdata = 0 ;
}
return NPERR_NO_ERROR;
}
MRESULT EXPENTRY AirTrafficControlDlg (HWND hwnd, ULONG msg,
MPARAM mp1, MPARAM mp2)
{
PINST pinst;
pinst = (PINST) WinQueryWindowPtr(hwnd,QWL_USER);
switch (msg)
{
case WM_INITDLG:
{
/*
* INITIALIZE APPLICATION
*/
CNRINFO ccinfo; // Container info structure
// Initialize instance data
pinst = (PINST) calloc (1, sizeof *pinst);
WinSetWindowPtr(hwnd,QWL_USER,pinst);
pinst->hwndCnr = WinWindowFromID (hwnd, IDCNR_SAMPLE);
pinst->hab = WinQueryAnchorBlock (hwnd);
pinst->hwndAircraftMenu = // Load aircraft menu
WinLoadMenu( HWND_OBJECT, 0, IDMENU_AIRCRAFT);
pinst->hwndContainerMenu = // Load container menu
WinLoadMenu( HWND_OBJECT, 0, IDMENU_CONTAINER);
pinst->CurrentView = IDMVIEW_RADAR;
// Set container info to request owner background painting
memset (&ccinfo, 0, sizeof ccinfo);
ccinfo.cb = sizeof ccinfo;
ccinfo.flWindowAttr = CA_OWNERPAINTBACKGROUND;
WinSendMsg (pinst->hwndCnr, CM_SETCNRINFO, &ccinfo,
MPFROMLONG(CMA_FLWINDOWATTR));
// Subclass container window to provide background painting
pfnwpCnr = WinSubclassWindow (pinst->hwndCnr,
CnrSubclassWndProc);
assert (pfnwpCnr);
// Insert the columns into the container
InsertContainerColumns (pinst);
// Insert the initial records into the container
InsertContainerRecords (pinst);
// Start a timer to control aircraft
WinStartTimer (pinst->hab, hwnd,
IDTIMER_ADJUSTAIRCRAFT, AIRCRAFT_ADJUST_FREQUENCY);
// The container is ready for viewing
WinShowWindow (pinst->hwndCnr, TRUE);
SetUpControllerHandoffValueSet (hwnd);
return 0;
}
case WM_TIMER:
/*
* DO TIME-RELATED AIRCRAFT HANDLING
*/
if (SHORT1FROMMP (mp1) == IDTIMER_ADJUSTAIRCRAFT)
{
PAPPCNRREC pacrTraverse;
// Loop through all container records
for (pacrTraverse = FIRST_CNR_ITEM (pinst->hwndCnr);
pacrTraverse;
pacrTraverse = NEXT_CNR_ITEM(pinst->hwndCnr,pacrTraverse))
{
BOOL fInvalid = FALSE;
if (pinst->CurrentView == IDMVIEW_RADAR)
{
/* Erase the record from previous location. */
WinSendMsg (pinst->hwndCnr, CM_ERASERECORD,
MPFROMP(pacrTraverse), NULL);
}
// Maneuver the aircraft
if (ManeuverAircraft (pacrTraverse))
{
// Update aircraft text if necessary
SetRecordText (pacrTraverse);
fInvalid = TRUE;
}
if (fInvalid || pinst->CurrentView == IDMVIEW_RADAR)
/* Paint the record in its new position */
WinSendMsg (pinst->hwndCnr, CM_INVALIDATERECORD,
MPFROMP(&pacrTraverse),
MPFROMSHORT(1));
}
}
else
if (SHORT1FROMMP (mp1) == IDTIMER_DISPLAYTIMEDMSG)
{
WinStopTimer (pinst->hab, hwnd,
IDTIMER_DISPLAYTIMEDMSG);
WinSetDlgItemText (hwnd, IDST_STATUSMESSAGES, "");
}
return 0;
case WM_CONTROL:
if (SHORT1FROMMP (mp1) == IDCNR_SAMPLE)
switch (SHORT2FROMMP (mp1))
{
case CN_CONTEXTMENU:
{
/*
* MENU HANDLING
*/
POINTL ptlMouse;
HWND hwndMenu;
WinQueryMsgPos (pinst->hab, &ptlMouse);
// Save pointer to record mouse is over, if any
pinst->pacrSelected = (PAPPCNRREC) mp2;
hwndMenu = pinst->pacrSelected ?
pinst->hwndAircraftMenu :
pinst->hwndContainerMenu;
// Display menu
WinPopupMenu (HWND_DESKTOP, hwnd, hwndMenu,
ptlMouse.x, ptlMouse.y, 0,
PU_HCONSTRAIN | PU_VCONSTRAIN |
PU_KEYBOARD | PU_MOUSEBUTTON1 |
PU_MOUSEBUTTON2 |
PU_MOUSEBUTTON3);
return 0;
}
case CN_INITDRAG:
ProcessInitDrag (
WinWindowFromID (hwnd, SHORT1FROMMP (mp1)),
((PCNRDRAGINIT) (PVOIDFROMMP(mp2))));
return 0;
case CN_SCROLL:
WinInvalidateRect (pinst->hwndCnr, 0, 0);
return 0;
}
else
/*
* HANDLE WM_CONTROL MESSAGES FROM VALUE SET CONTROL
*/
if (SHORT1FROMMP (mp1) == IDVS_CONTROLLERS)
switch (SHORT2FROMMP (mp1))
{
case VN_SELECT:
DisplayTimedMsg (pinst->hab, hwnd,
"Drag an airplane to one "
"of the controller icons to hand off to "
"another controller.", 8);
return 0;
case VN_DROP:
{
PVSDRAGINFO pvsdinfo = (PVSDRAGINFO)
PVOIDFROMMP (mp2);
PDRAGINFO pdinfo = pvsdinfo->pDragInfo;
PDRAGITEM pditem;
INT iItem;
INT cHandedOffAircraft = 0;
CHAR szHandedOffAircraft [100];
*szHandedOffAircraft = 0;
assert (DrgAccessDraginfo(pdinfo));
for (iItem = 0; iItem < pdinfo->cditem; ++iItem)
{
PAPPCNRREC pacr;
pditem = DrgQueryDragitemPtr (pdinfo, iItem);
pacr = (PAPPCNRREC) pditem->ulItemID;
if (pdinfo->usOperation == DO_MOVE)
{
WinSendMsg (pdinfo->hwndSource,
CM_REMOVERECORD,
MPFROMP(&pacr),
MPFROM2SHORT (1, CMA_INVALIDATE));
if (cHandedOffAircraft++)
strcat (szHandedOffAircraft, ", ");
strcat (szHandedOffAircraft,
pacr->pszCallsign);
}
}
if (cHandedOffAircraft)
{
CHAR szMsg [200];
sprintf (szMsg,
"Aircraft %s %s been handed off "
"to %s Sector controller.",
szHandedOffAircraft,
cHandedOffAircraft > 1 ?
"have" : "has",
pvsdinfo->usColumn == 1 ?
"West" : "East");
DisplayTimedMsg (pinst->hab, hwnd,
szMsg, 8);
}
DrgFreeDraginfo (pdinfo);
WinAlarm (HWND_DESKTOP, WA_NOTE);
return 0;
}
}
return 0;
case WM_COMMAND:
/*
* COMMAND HANDLING
*/
switch (SHORT1FROMMP (mp1))
{
case IDMAIRCRAFT_CONTROLINSTRUCT: // Issue instruction
{
// Present "Control Aircraft" dialog
WinDlgBox (HWND_DESKTOP, hwnd,
ControlInstructionDlg, 0,
IDDLG_CONTROLAIRCRAFT, pinst);
return 0;
}
case IDMVIEW_RADAR:
case IDMVIEW_NAME:
case IDMVIEW_TREE:
case IDMVIEW_DETAILS:
case IDMVIEW_TEXT:
{
static const ULONG aViews [] =
{ CV_ICON, CV_NAME, CV_TREE, CV_DETAIL, CV_TEXT };
CNRINFO ccinfo;
memset (&ccinfo, 0, sizeof ccinfo);
ccinfo.cb = sizeof ccinfo;
ccinfo.flWindowAttr = CA_DETAILSVIEWTITLES |
CA_TITLESEPARATOR | CA_TREELINE |
CA_OWNERPAINTBACKGROUND |
aViews [SHORT1FROMMP (mp1) - IDMVIEW_BASE];
WinSendMsg (pinst->hwndCnr, CM_SETCNRINFO, &ccinfo,
MPFROMLONG(CMA_FLWINDOWATTR));
pinst->CurrentView = SHORT1FROMMP (mp1);
WinInvalidateRect (pinst->hwndCnr, 0, 0);
return 0;
}
}
return WinDefDlgProc (hwnd, msg, mp1, mp2);
default:
return WinDefDlgProc (hwnd, msg, mp1, mp2);
}
}
MRESULT EXPENTRY SliderDlgProc( HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2)
{
CHAR acBuffer[10];
CHAR *cData;
USHORT usNewPctDone;
SHORT ulValue;
static SHORT sPtVal=0;
APIRET rc;
switch(msg)
{
//*********************************
case WM_INITDLG:
if ( CommPortOpen(hwnd) == FALSE)
{
WinDismissDlg( hwnd, TRUE );
return (MRESULT)FALSE;
}
hwndDlg = hwnd; //used in read task to send term input
InitSlider (hwnd, IDC_SLIDER_CONTROL,MaximumTicks,
MinorTickSpacing,MinorTickSize,
MajorTickSpacing,MajorTickSize,
DetentSpacing, TextSpacing,
"10.Courier");
//set the limit of the entry field
WinSendDlgItemMsg(hwnd,
IDC_SLIDER_DATA,
EM_SETTEXTLIMIT,
(MPARAM)3,
(MPARAM)0);
WinStartTimer( hab, hwnd,
TMID_QUERY_TIMER,
750); //every 750 msec
LastVal = 0;
return 0;
//*********************************
case WM_TERMINAL_MSG:
//sent from the DOS read thread
usNewPctDone = (USHORT) mp1;
if ( (usNewPctDone >= 0) && (usNewPctDone <= MaximumTicks) )
{
WinSendDlgItemMsg (hwnd, IDC_SLIDER_CONTROL,
SLM_SETSLIDERINFO,
MPFROM2SHORT (SMA_SLIDERARMPOSITION,
SMA_INCREMENTVALUE),
MPFROMSHORT (usNewPctDone));
LastVal = usNewPctDone;
}
return 0;
//*********************************
case WM_TIMER:
switch(SHORT1FROMMP(mp1))
{
case TMID_QUERY_TIMER:
{
ulValue = (SHORT) WinSendDlgItemMsg(hwnd, IDC_SLIDER_CONTROL,
SLM_QUERYSLIDERINFO,
MPFROM2SHORT(SMA_SLIDERARMPOSITION,SMA_INCREMENTVALUE),
NULL);
if ( ulValue != LastVal)
{
LastVal = ulValue;
cData = _ltoa(ulValue,acBuffer,10);
WinSetDlgItemText(hwnd,IDC_SLIDER_DATA, cData);
strcat( acBuffer, " ");
PrintTerm(acBuffer);
}
break;
}
default: break;
}
break;
//*********************************
case WM_CONTROL:
switch(SHORT2FROMMP(mp1))
{
case SLN_SLIDERTRACK:
case SLN_CHANGE:
{
ulValue = (SHORT) WinSendDlgItemMsg(hwnd, IDC_SLIDER_CONTROL,
SLM_QUERYSLIDERINFO,
MPFROM2SHORT(SMA_SLIDERARMPOSITION,SMA_INCREMENTVALUE),
NULL);
cData = _ltoa(ulValue,acBuffer,10);
WinSetDlgItemText(hwnd,IDC_SLIDER_DATA, cData);
break;
}
default:
break;
}
break;
case WM_COMMAND:
switch (SHORT1FROMMP(mp1))
{
case DID_OK:
WinStopTimer( hab, hwnd, TMID_QUERY_TIMER);
WinDismissDlg (hwnd, FALSE);
return 0;
case IDC_MID_POINT:
WinSendDlgItemMsg (hwnd, IDC_SLIDER_CONTROL,
SLM_SETSLIDERINFO,
MPFROM2SHORT (SMA_SLIDERARMPOSITION,
SMA_INCREMENTVALUE),
MPFROMSHORT (MaximumTicks/2));
return 0;
}
return 0;
default:
return (WinDefDlgProc (hwnd, msg, mp1, mp2));
}
return FALSE;
}
MRESULT EXPENTRY fnwpModemOutStatusDlg(HWND hwnd,USHORT msg,MPARAM mp1,MPARAM mp2)
{
static ULONG idTimer;
char szCaption[80];
switch (msg)
{
case WM_INITDLG:
SetSystemMenu(hwnd);
WinSendDlgItemMsg(hwnd,HWS_DTR,EM_SETREADONLY,MPFROMSHORT(TRUE),(MPARAM)NULL);
WinSendDlgItemMsg(hwnd,HWS_RTS,EM_SETREADONLY,MPFROMSHORT(TRUE),(MPARAM)NULL);
// CenterDlgBox(hwnd);
idTimer = 0L;
break;
case UM_INITLS:
if (!bMOstatusActivated)
{
bMOstatusActivated = TRUE;
if (lStatusWindowCount++ <= 0)
MenuItemEnable(hwndFrame,IDM_SURFACE_THIS,TRUE);
if (stCFG.bLoadWindowPosition && (hProfileInstance != NULL) && (stCFG.ptlMOstatusPos.y > -40))
WinSetWindowPos(hwnd,HWND_TOP,stCFG.ptlMOstatusPos.x,stCFG.ptlMOstatusPos.y,0L,0L,SWP_MOVE);
else
MousePosDlgBox(hwnd);
WinShowWindow(hwnd,TRUE);
WinSetFocus(HWND_DESKTOP,hwnd);
}
UpdateModemOutputStatusDlg(hwnd);
idTimer = WinStartTimer(habAnchorBlock,
hwnd,
TID_STATMDMOUT,
stCFG.wUpdateDelay);
case UM_RESET_NAME:
sprintf(szCaption,"%s - Modem Out",stCFG.szPortName);
WinSetWindowText(hwnd,szCaption);
break;
case WM_CLOSE:
case UM_KILL_MONITOR:
bMOstatusActivated = FALSE;
if (--lStatusWindowCount <= 0)
MenuItemEnable(hwndFrame,IDM_SURFACE_THIS,FALSE);
if (idTimer)
{
WinStopTimer(habAnchorBlock,
hwnd,
idTimer);
idTimer = 0L;
}
return(WinDefDlgProc(hwnd,msg,mp1,mp2));
case UM_RESETTIMER:
if (idTimer != 0L)
idTimer = WinStartTimer(habAnchorBlock,
hwnd,
idTimer,
stCFG.wUpdateDelay);
break;
case WM_TIMER:
UpdateModemOutputStatusDlg(hwnd);
return(FALSE);
case WM_ACTIVATE:
if (bMOstatusActivated)
WinSetFocus(HWND_DESKTOP,hwnd);
break;
default:
return(WinDefDlgProc(hwnd,msg,mp1,mp2));
}
return FALSE;
}
MRESULT EXPENTRY fnwpDeviceStatusDlg(HWND hwnd,USHORT msg,MPARAM mp1,MPARAM mp2)
{
USHORT idDlg;
PFNWP pfnDlgProc;
static ULONG idTimer;
char szStatus[80];
WORD wStatus;
static BOOL bShowingBits;
static SHORT sCurrentFocus;
switch (msg)
{
case WM_INITDLG:
SetSystemMenu(hwnd);
WinSendDlgItemMsg(hwnd,HWS_COMST,EM_SETREADONLY,MPFROMSHORT(TRUE),(MPARAM)NULL);
WinSendDlgItemMsg(hwnd,HWS_COMERROR,EM_SETREADONLY,MPFROMSHORT(TRUE),(MPARAM)NULL);
WinSendDlgItemMsg(hwnd,HWS_COMEVENT,EM_SETREADONLY,MPFROMSHORT(TRUE),(MPARAM)NULL);
WinSendDlgItemMsg(hwnd,HWS_XMITST,EM_SETREADONLY,MPFROMSHORT(TRUE),(MPARAM)NULL);
idTimer = 0L;
bShowingBits = FALSE;
sCurrentFocus = 0;
CenterDlgBox(hwnd);
break;
case UM_INITLS:
if (!bDDstatusActivated)
{
bDDstatusActivated = TRUE;
if (lStatusWindowCount++ <= 0)
MenuItemEnable(hwndFrame,IDM_SURFACE_THIS,TRUE);
if (stCFG.bLoadWindowPosition && (hProfileInstance != NULL) && (stCFG.ptlDDstatusPos.y > -40))
WinSetWindowPos(hwnd,HWND_TOP,stCFG.ptlDDstatusPos.x,stCFG.ptlDDstatusPos.y,0L,0L,SWP_MOVE);
else
MousePosDlgBox(hwnd);
WinShowWindow(hwnd,TRUE);
WinSetFocus(HWND_DESKTOP,hwnd);
}
UpdateDeviceStatusDlg(hwnd);
idTimer = WinStartTimer(habAnchorBlock,
hwnd,
TID_STATDEV,
stCFG.wUpdateDelay);
case UM_RESET_NAME:
sprintf(szStatus,"%s - Device Driver Status",stCFG.szPortName);
WinSetWindowText(hwnd,szStatus);
break;
case WM_CLOSE:
case UM_KILL_MONITOR:
bDDstatusActivated = FALSE;
if (--lStatusWindowCount <= 0)
MenuItemEnable(hwndFrame,IDM_SURFACE_THIS,FALSE);
if (idTimer)
{
WinStopTimer(habAnchorBlock,
hwnd,
idTimer);
idTimer = 0L;
}
return(WinDefDlgProc(hwnd,msg,mp1,mp2));
case UM_RESETTIMER:
if (idTimer != 0L)
idTimer = WinStartTimer(habAnchorBlock,
hwnd,
idTimer,
stCFG.wUpdateDelay);
break;
case WM_CHAR:
if ((sCurrentFocus != 0) && (!bShowingBits) && (SHORT1FROMMP(mp1) & KC_CHAR) && (SHORT1FROMMP(mp2) == ' '))
{
WinPostMsg(hwnd,UM_SHOWBITS,MPFROMSHORT(sCurrentFocus),(MPARAM)0L);
bShowingBits = TRUE;
}
else
return(WinDefDlgProc(hwnd,msg,mp1,mp2));
break;
case WM_BUTTON1UP:
if ((sCurrentFocus != 0) && (!bShowingBits))
{
WinPostMsg(hwnd,UM_SHOWBITS,MPFROMSHORT(sCurrentFocus),(MPARAM)0L);
bShowingBits = TRUE;
}
else
return(WinDefDlgProc(hwnd,msg,mp1,mp2));
break;
case WM_CONTROL:
if (!bShowingBits)
{
switch (SHORT2FROMMP(mp1))
{
case EN_SETFOCUS:
sCurrentFocus = SHORT1FROMMP(mp1);
break;
case EN_KILLFOCUS:
sCurrentFocus = 0;
break;
}
}
break;
case UM_SHOWBITS:
switch(SHORT1FROMMP(mp1))
{
case HWS_COMERROR:
idDlg = CER_DLG;
pfnDlgProc = (PFNWP)fnwpCOMerrorStatesDlg;
WinQueryDlgItemText(hwnd,HWS_COMERROR,sizeof(szStatus),szStatus);
break;
case HWS_COMEVENT:
idDlg = CEV_DLG;
pfnDlgProc = (PFNWP)fnwpCOMeventStatesDlg;
WinQueryDlgItemText(hwnd,HWS_COMEVENT,sizeof(szStatus),szStatus);
break;
case HWS_COMST:
idDlg = CST_DLG;
pfnDlgProc = (PFNWP)fnwpCOMstatusStatesDlg;
WinQueryDlgItemText(hwnd,HWS_COMST,sizeof(szStatus),szStatus);
break;
case HWS_XMITST:
idDlg = TST_DLG;
pfnDlgProc = (PFNWP)fnwpXmitStatusStatesDlg;
WinQueryDlgItemText(hwnd,HWS_XMITST,sizeof(szStatus),szStatus);
break;
default:
return(FALSE);
}
wStatus = (WORD)ASCIItoBin(szStatus,16);
WinDlgBox(HWND_DESKTOP,
hwnd,
pfnDlgProc,
NULLHANDLE,
idDlg,
&wStatus);
WinSetFocus(HWND_DESKTOP,hwnd);
bShowingBits = FALSE;
break;
case WM_TIMER:
UpdateDeviceStatusDlg(hwnd);
break;
case WM_ACTIVATE:
if (bDDstatusActivated)
WinSetFocus(HWND_DESKTOP,hwnd);
break;
default:
return(WinDefDlgProc(hwnd,msg,mp1,mp2));
}
return FALSE;
}
/*----------------------------------------------------------------------*/
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 fnwpRcvBufferStatusDlg(HWND hwnd,USHORT msg,MPARAM mp1,MPARAM mp2)
{
static ULONG idTimer;
char szCaption[80];
static SHORT sCurrentFocus;
switch (msg)
{
case WM_INITDLG:
SetSystemMenu(hwnd);
WinSendDlgItemMsg(hwnd,HWS_BUFLEV,EM_SETREADONLY,MPFROMSHORT(TRUE),(MPARAM)NULL);
WinSendDlgItemMsg(hwnd,HWS_BUFLEN,EM_SETREADONLY,MPFROMSHORT(TRUE),(MPARAM)NULL);
// CenterDlgBox(hwnd);
idTimer = 0L;
break;
case UM_INITLS:
if (!bRBstatusActivated)
{
bRBstatusActivated = TRUE;
if (lStatusWindowCount++ <= 0)
MenuItemEnable(hwndFrame,IDM_SURFACE_THIS,TRUE);
if (stCFG.bLoadWindowPosition && (hProfileInstance != NULL) && (stCFG.ptlRBstatusPos.y > -40))
WinSetWindowPos(hwnd,HWND_TOP,stCFG.ptlRBstatusPos.x,stCFG.ptlRBstatusPos.y,0L,0L,SWP_MOVE);
else
MousePosDlgBox(hwnd);
WinShowWindow(hwnd,TRUE);
WinSetFocus(HWND_DESKTOP,hwnd);
stCFG.fTraceEvent |= CSFUNC_TRACE_RX_BUFF_LEVEL;
if (bCOMscopeEnabled && (hCom != 0xffffffff))
EnableCOMscope(hwnd,hCom,&ulCOMscopeBufferSize,stCFG.fTraceEvent);
ResetHighWater();
}
UpdateRcvBufferStatusDlg(hwnd);
idTimer = WinStartTimer(habAnchorBlock,
hwnd,
TID_STATRCVBUF,
stCFG.wUpdateDelay);
sCurrentFocus = 0;
case UM_RESET_NAME:
sprintf(szCaption,"%s - Receive Buffer",stCFG.szPortName);
WinSetWindowText(hwnd,szCaption);
break;
case WM_CLOSE:
case UM_KILL_MONITOR:
bRBstatusActivated = FALSE;
stCFG.fTraceEvent &= ~CSFUNC_TRACE_RX_BUFF_LEVEL;
if (bCOMscopeEnabled && (hCom != 0xffffffff))
EnableCOMscope(hwnd,hCom,&ulCOMscopeBufferSize,stCFG.fTraceEvent);
if (--lStatusWindowCount <= 0)
MenuItemEnable(hwndFrame,IDM_SURFACE_THIS,FALSE);
if (idTimer)
{
WinStopTimer(habAnchorBlock,
hwnd,
idTimer);
idTimer = 0L;
}
return(WinDefDlgProc(hwnd,msg,mp1,mp2));
case UM_RESETTIMER:
if (idTimer != 0L)
idTimer = WinStartTimer(habAnchorBlock,
hwnd,
idTimer,
stCFG.wUpdateDelay);
break;
case WM_TIMER:
UpdateRcvBufferStatusDlg(hwnd);
return(FALSE);
case WM_CHAR:
if ((sCurrentFocus != 0) && (SHORT1FROMMP(mp1) & KC_CHAR) && (SHORT1FROMMP(mp2) == ' '))
ResetHighWater();
else
return(WinDefDlgProc(hwnd,msg,mp1,mp2));
break;
case WM_BUTTON1UP:
if (sCurrentFocus != 0)
ResetHighWater();
else
return(WinDefDlgProc(hwnd,msg,mp1,mp2));
break;
case WM_CONTROL:
switch (SHORT2FROMMP(mp1))
{
case EN_SETFOCUS:
if (SHORT1FROMMP(mp1) == HWS_BUFHIGH)
sCurrentFocus = SHORT1FROMMP(mp1);
break;
case EN_KILLFOCUS:
sCurrentFocus = 0;
break;
}
break;
case WM_ACTIVATE:
if (bRBstatusActivated)
WinSetFocus(HWND_DESKTOP,hwnd);
break;
default:
return(WinDefDlgProc(hwnd,msg,mp1,mp2));
}
return FALSE;
}
MRESULT EXPENTRY tButProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 )
{
HWND hwndFly = WinQueryWindowULong( hwnd, QWL_USER );
switch( msg )
{
case WM_MOUSEMOVE:
{
if( !hwndFly && useBubbles )
WinStartTimer( 0, hwnd, 1 /* unused id */, 500 );
return ( *oldButProc )( hwnd, msg, mp1, mp2 );
}
break;
case WM_TIMER:
{
RGB rgb;
HPS hps;
HAB hab;
RECTL rectl;
ULONG breite, hoehe;
POINTL p;
char str[200];
if( hwndFly )
break;
hab = WinQueryAnchorBlock( hwnd );
WinLoadString( hab, NULLHANDLE, WinQueryWindowUShort( hwnd, QWS_ID ),
sizeof( str ), str );
hwndFly = WinCreateWindow( HWND_DESKTOP, WC_STATIC, str,
SS_TEXT | DT_VCENTER | DT_CENTER,
0, 0, 0, 0, hwnd, HWND_TOP, 0, 0, NULL );
rgb.bBlue = 0;
rgb.bGreen = 254;
rgb.bRed = 254;
WinSetPresParam( hwndFly, PP_BACKGROUNDCOLOR, sizeof( RGB ), &rgb );
rgb.bBlue = 0;
rgb.bGreen = 0;
rgb.bRed = 0;
WinSetPresParam( hwndFly, PP_FOREGROUNDCOLOR, sizeof( RGB ), &rgb );
WinSetPresParam( hwndFly, PP_FONTNAMESIZE, sizeof( DefCntrFont ),
DefCntrFont );
queryDimensions( hwndFly, str, &breite, &hoehe );
WinQueryPointerPos( HWND_DESKTOP, &p );
p.y -= WinQuerySysValue( HWND_DESKTOP, SV_CYTITLEBAR );
p.y -= hoehe/2;
p.x += 5;
WinSetWindowPos( hwndFly, HWND_TOP, p.x, p.y, breite+4, hoehe+2,
SWP_SHOW | SWP_MOVE | SWP_SIZE );
WinSetWindowULong( hwnd, QWL_USER, (ULONG) hwndFly );
}
break;
case UM_FLYOVER_BEGIN:
useBubbles = 1;
break;
case UM_FLYOVER_END:
WinStopTimer( 0, hwnd, 1 /* unused id */ );
if( hwndFly )
WinDestroyWindow( hwndFly );
WinSetWindowULong( hwnd, QWL_USER, 0 );
break;
default:
return ( *oldButProc )( hwnd, msg, mp1, mp2 );
}
return FALSE;
}
/*@ XTimer::Stop(void)
@group misc
@remarks Stop the timer.
*/
BOOL XTimer::Stop(void) const
{
HWND hwnd = GetWindow()->GetHandle();
return WinStopTimer(WinQueryAnchorBlock(hwnd), hwnd, timerID);
}
static MRESULT EXPENTRY launchPadWindowProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
WPFolder* thisPtr;
launchPad * lp;
LPObject *lpo;
static USHORT id=0;//Initialisation new in V1.00a
switch(msg)
{
#if 0
case DM_ENDCONVERSATION:
case DM_DRAGFILECOMPLETE:
case DM_DROPNOTIFY:
case DM_FILERENDERED:
case DM_RENDERCOMPLETE:
break;
return (MRESULT)FALSE;
case WM_ENDDRAG:
break;
return (MRESULT)TRUE;
#endif
case WM_PAINT:
{
RECTL rcl;
launchPad * lp;
HPS hps=WinBeginPaint(hwnd,NULLHANDLE, &rcl);
WinFillRect(hps, &rcl, SYSCLR_DIALOGBACKGROUND);
lp=(launchPad*)WinQueryWindowULong(hwnd,QWL_USER);
if(lp) {
if(lp->lpQueryNumObjects()==0) {
WinQueryWindowRect(hwnd,&rcl);
WinDrawBorder(hps,&rcl,1,1,SYSCLR_WINDOWFRAME,SYSCLR_DIALOGBACKGROUND, DB_STANDARD);
}
}
WinEndPaint(hps);
return (MRESULT) 0;
}
case DM_DRAGOVER:
return handleDragOver(hwnd, mp1, mp2);
case DM_DROP:
{
ULONG ulCount;
ULONG ulNumberOfObjects;
PDRAGITEM pDragItem;
SOMClass *folderClass;
WPObject * wpObject;
PDRAGINFO pDragInfo;
TRY_LOUD(LP_FRAMEDROP) {
/* A new object dropped on the launchpad */
pDragInfo=(PDRAGINFO)mp1;
if(DrgAccessDraginfo(pDragInfo)) {
/* Get number of items */
ulNumberOfObjects = DrgQueryDragitemCount( pDragInfo);
if(ulNumberOfObjects>1){
/* Free the draginfo */
DrgDeleteDraginfoStrHandles(pDragInfo);
DrgFreeDraginfo(pDragInfo);
}
else {
ulCount=0;
pDragItem=DrgQueryDragitemPtr( pDragInfo, ulCount);
wpObject=(WPObject*)OBJECT_FROM_PREC(DrgQueryDragitemPtr( pDragInfo, ulCount)->ulItemID);
lp=(launchPad*)WinQueryWindowULong(hwnd,QWL_USER);
if(lp) {
if(somIsObj(wpObject)) {
POINTL ptl;
int numB;
SWP swp;
WinQueryWindowPos(hwnd,&swp);
ptl.x=pDragInfo->xDrop;
ptl.y=pDragInfo->yDrop;
/* Pos in window coords */
WinMapWindowPoints(HWND_DESKTOP, hwnd, &ptl, 1);
numB=(ptl.x-xButtonOffset)/(swp.cy+xButtonDelta);
numB=((ptl.x-numB*swp.cy) > swp.cy/2 ? numB+1: numB);
/* Do a link */
lp->lpAddButton(wpObject, numB);
handleDragLeave(hwnd, mp1, mp2);
}
}
DrgDeleteDraginfoStrHandles(pDragInfo);
DrgFreeDraginfo(pDragInfo);
}
}
handleDragLeave(hwnd, mp1, mp2);
}
CATCH(LP_FRAMEDROP)
{
} END_CATCH;
break;
}
case DM_DRAGLEAVE:
return handleDragLeave(hwnd, mp1, mp2);
break;
case WM_COMMAND:
if(SHORT1FROMMP(mp2)==CMDSRC_PUSHBUTTON) {
/* It's a push button */
lpo=(LPObject*)WinQueryWindowULong(WinWindowFromID(hwnd,SHORT1FROMMP(mp1)),QWL_USER);
if(lpo) {
if(somIsObj(lpo->wpObject))
lpo->wpObject->wpViewObject(NULLHANDLE, OPEN_DEFAULT,0);
}
}
return (MRESULT)FALSE;
/***********************************************/
/* Stuff for fly over help */
case WM_MOUSEMOVE:
launchPad * lp;
lp=(launchPad*)WinQueryWindowULong(hwnd,QWL_USER);
if(lp) {
if(lp->lpQueryNumObjects()!=0) {
break;
}
}
#if 0
tempID=WinQueryWindowUShort(hwnd,QWS_ID);/* get the id of the window under the pointer */
if(id!=tempID) { // New Button?
WinStartTimer(WinQueryAnchorBlock(hwnd),hwnd,tempID,(ULONG)iTBFlyOverDelay); // New timer for delay
id=tempID; // Save ID
}
else {
if(!hwndBubbleWindow)
WinStartTimer(WinQueryAnchorBlock(hwnd),hwnd,tempID,(ULONG)iTBFlyOverDelay); // New timer for delay
}
#endif
if(!hwndBubbleWindow)
WinStartTimer(WinQueryAnchorBlock(hwnd), hwnd, 2,(ULONG)iTBFlyOverDelay); // New timer for delay
break;
case WM_DESTROY:
WinStopTimer(WinQueryAnchorBlock(hwnd),hwnd,1);//Stop timer if running
if(hwndBubbleWindow)
WinDestroyWindow(hwndBubbleWindow);/* close the bubblewindow */
hwndBubbleWindow=0;
/* Stop delay timer if running */
WinStopTimer(WinQueryAnchorBlock(hwnd),hwnd, 2);
break;
case WM_NEWBUBBLE:
ULONG bubbleEnabled;
HWND hwndStore;
POINTL ptl;
RECTL rclWork;
LONG ulWinTextLen;
POINTL aptlPoints[TXTBOX_COUNT];
LONG deltaX,deltaY;
HPS hps;
RECTL rcl;
/* we have to build a new information window */
if(hwndBubbleWindow){// if(){...} new in V1.00a
WinDestroyWindow(hwndBubbleWindow);/* close the bubblewindow */
hwndBubbleWindow=NULL;
}
// Query the pointer position
WinQueryPointerPos(HWND_DESKTOP,&ptl);
WinMapWindowPoints(HWND_DESKTOP,hwnd,&ptl,1);
WinQueryWindowRect(hwnd,&rclWork);
if(!hwndBubbleWindow
&& WinPtInRect(WinQueryAnchorBlock(hwnd),&rclWork,&ptl)
&& bTBFlyOverEnabled) {
static HWND hwndBubbleClient;
ULONG style=FCF_BORDER|FCF_NOBYTEALIGN;
char winText[255];
/* Get window text for size calculating */
lp=(launchPad*)WinQueryWindowULong(hwnd,QWL_USER);
if(lp) {
strncpy(winText, lp->lpQueryFlyOverText(), sizeof(winText));
winText[sizeof(winText)-1]=0;
}
ulWinTextLen=(LONG)strlen(winText); // Query text length
/* Delete 'Returns' in object title */
char *pBuchst;
char *pRest;
pRest=winText;
while((pBuchst=strchr(pRest,13))!=NULL) {
*pBuchst=' ';
pBuchst++;
if(*pBuchst==10)
*pBuchst=' ';
pRest=pBuchst;
}
/* Create help window */
hwndBubbleWindow=WinCreateStdWindow(HWND_DESKTOP,
0,
&style,
WC_STATIC,
"",
SS_TEXT|DT_CENTER|DT_VCENTER,
NULLHANDLE,
400,
&hwndBubbleClient);
hwndShadow=WinCreateWindow(HWND_DESKTOP,
WC_STATIC,
"",
SS_TEXT|DT_CENTER|DT_VCENTER,
0, 0,
0, 0,
hwndBubbleWindow,
hwndBubbleWindow,
401,
NULLHANDLE,
NULLHANDLE);
oldProc=WinSubclassWindow(hwndShadow, shadowProc);
// Set the font for the help
WinSetPresParam(hwndBubbleClient,PP_FONTNAMESIZE,
sizeof(chrTBFlyFontName),
chrTBFlyFontName);
/* Calculate text size in pixel */
hps=WinBeginPaint(hwndBubbleClient,(HPS)NULL,(PRECTL)NULL);
GpiQueryTextBox(hps,ulWinTextLen,winText,TXTBOX_COUNT,aptlPoints);
WinEndPaint(hps);
/* Set colors */
WinSetPresParam(hwndBubbleClient,
PP_BACKGROUNDCOLOR,sizeof(rgbTBFlyBackground) ,
&rgbTBFlyBackground );
WinSetPresParam(hwndBubbleClient,
PP_FOREGROUNDCOLOR,sizeof(rgbTBFlyForeground) ,
&rgbTBFlyForeground );
/* Calculate bubble positon and show bubble */
WinQueryPointerPos(HWND_DESKTOP,&ptl);//Query pointer position in the desktop window
WinQueryWindowRect(HWND_DESKTOP,&rcl);//Query desktop size
aptlPoints[TXTBOX_BOTTOMRIGHT].x-aptlPoints[TXTBOX_BOTTOMLEFT].x+7+xVal+ptl.x
> rcl.xRight
? deltaX=-aptlPoints[TXTBOX_BOTTOMRIGHT].x-aptlPoints[TXTBOX_BOTTOMLEFT].x-xVal-xVal-7
: deltaX=0 ;
aptlPoints[TXTBOX_TOPLEFT].y-aptlPoints[TXTBOX_BOTTOMLEFT].y+2+yVal+ptl.y
> rcl.yTop
? deltaY=-aptlPoints[TXTBOX_TOPLEFT].y-aptlPoints[TXTBOX_BOTTOMLEFT].y-2*yVal-7
: deltaY=0 ;
WinSetWindowPos(hwndBubbleWindow,
HWND_TOP,
ptl.x+xVal+deltaX,ptl.y+yVal+deltaY,
aptlPoints[TXTBOX_BOTTOMRIGHT].x-aptlPoints[TXTBOX_BOTTOMLEFT].x+8,
aptlPoints[TXTBOX_TOPLEFT].y-aptlPoints[TXTBOX_BOTTOMLEFT].y+2,
SWP_ZORDER|SWP_SIZE|SWP_MOVE|SWP_SHOW);
WinSetWindowPos(hwndShadow,
hwndBubbleWindow,
ptl.x+xVal+deltaX+5
,ptl.y+yVal+deltaY-5,
aptlPoints[TXTBOX_BOTTOMRIGHT].x-aptlPoints[TXTBOX_BOTTOMLEFT].x+8,
aptlPoints[TXTBOX_TOPLEFT].y-aptlPoints[TXTBOX_BOTTOMLEFT].y+2,
SWP_ZORDER|SWP_SIZE|SWP_MOVE|SWP_SHOW);
/* Set bubble text */
WinSetWindowText(hwndBubbleClient,winText);
WinStartTimer(WinQueryAnchorBlock(hwnd),hwnd,1,35);
} // end if(!hwndBubbleWindow)
break;
case WM_TIMER:
switch (SHORT1FROMMP(mp1))
{
case 1: //Intervall timer
{
POINTL ptl;
RECTL rclWork;
/* Test pointer position */
WinQueryPointerPos(HWND_DESKTOP, &ptl);
WinMapWindowPoints(HWND_DESKTOP, hwnd,&ptl, 1);
WinQueryWindowRect(hwnd, &rclWork);
if(!WinPtInRect(WinQueryAnchorBlock(hwnd),&rclWork,&ptl))
{ // Window has changed
WinStopTimer(WinQueryAnchorBlock(hwnd), hwnd, 1); // stop the running timer
if(hwndBubbleWindow)
WinDestroyWindow(hwndBubbleWindow);/* close the bubblewindow */
hwndBubbleWindow=0;
id=0;
}
break;
}
case 2:// delay over
{//our own timer.
POINTL ptl;
RECTL rclWork;
WinStopTimer(WinQueryAnchorBlock(hwnd), hwnd, 2);//Stop the delay timer
/* Check the pointer position */
WinQueryPointerPos(HWND_DESKTOP,&ptl);
WinMapWindowPoints(HWND_DESKTOP,hwnd,&ptl,1);
WinQueryWindowRect(hwnd,&rclWork);
if(WinPtInRect(WinQueryAnchorBlock(hwnd),&rclWork,&ptl))
WinPostMsg(hwnd,WM_NEWBUBBLE,NULL,NULL);//Request a help window
return (MRESULT)FALSE;
}
default:
break;
}
break;
default:
break;
}
return pfnwpOldLPProc(hwnd, msg, mp1, mp2);
}
/*
** Modeless Dialog to place device status on screen
*/
MRESULT EXPENTRY fnwpDeviceAllStatusDlg(HWND hwnd,USHORT msg,MPARAM mp1,MPARAM mp2)
{
char szCount[10];
static ULONG idTimer;
WORD wTemp;
static BOOL bShowAllActivated;
switch (msg)
{
case WM_INITDLG:
// SetSystemMenu(hwnd);
// CenterDlgBox(hwnd);
bShowAllActivated = FALSE;
idTimer = 0L;
break;
case UM_INITLS:
if (!bShowAllActivated)
{
bShowAllActivated = TRUE;
// MousePosDlgBox(hwnd);
WinSetWindowText(hwnd,stCFG.szPortName);
sprintf(szCount,"%u",stCFG.wUpdateDelay);
WinSetDlgItemText(hwnd,HWS_UPDATE,szCount);
WinShowWindow(hwnd,TRUE);
WinSetFocus(HWND_DESKTOP,hwnd);
}
UpdateDeviceStatusDlg(hwnd);
UpdateModemInputStatusDlg(hwnd);
UpdateModemOutputStatusDlg(hwnd);
UpdateBufferStatusDlg(hwnd);
idTimer = WinStartTimer(habAnchorBlock,
hwnd,
TID_STATALL,
stCFG.wUpdateDelay);
break;
case WM_CLOSE:
case UM_KILL_MONITOR:
if (idTimer != 0)
{
WinStopTimer(habAnchorBlock,
hwnd,
idTimer);
idTimer = 0L;
WinDismissDlg(hwnd,TRUE);
}
bShowAllActivated = FALSE;
break;
case UM_RESETTIMER:
if (idTimer != 0L)
idTimer = WinStartTimer(habAnchorBlock,
hwnd,
idTimer,
stCFG.wUpdateDelay);
break;
case WM_TIMER:
UpdateDeviceStatusDlg(hwnd);
UpdateModemInputStatusDlg(hwnd);
UpdateModemOutputStatusDlg(hwnd);
UpdateBufferStatusDlg(hwnd);
return(FALSE);
case WM_COMMAND:
switch(SHORT1FROMMP(mp1))
{
case DID_UPDATE:
WinQueryDlgItemText(hwnd,HWS_UPDATE,sizeof(szCount),szCount);
wTemp = atol(szCount);
if (wTemp != stCFG.wUpdateDelay)
{
stCFG.wUpdateDelay = wTemp;
WinStartTimer(habAnchorBlock,
hwnd,
idTimer,
stCFG.wUpdateDelay);
}
break;
case DID_OK:
WinStopTimer(habAnchorBlock,
hwnd,
idTimer);
idTimer = 0L;
WinDismissDlg(hwnd,TRUE);
bShowAllActivated = FALSE;
break;
case DID_HELP:
DisplayHelpPanel(HLPP_SHOW_ALL_DLG);
break;
default:
return WinDefDlgProc(hwnd,msg,mp1,mp2);
}
return(FALSE);
default: return(WinDefDlgProc(hwnd,msg,mp1,mp2));
}
return FALSE;
}
