ATimeHandler //V6 &ATimeHandler :: handleEventsFor( IWindow *window ) //V6 { //V6 /*--------------------------- Start a Timer ------------------------------| V6 | The Presentation Manager start timer routine is called by specifying | V6 | the anchor block handle for the current thread, | V6 | the handle of the window passed in, | V6 | a unique timer ID that is below the PM TID_USER_MAX constant, and | V6 | a time interval in milliseconds which is set to a constant 1000UL. | V6 | Since this application uses only a single timer, the timer ID is | V6 | specified as a constant. | V6 | When the timer expires, PM will post a WM_TIMER event to the window | V6 | specified in parameter 2 of the WinStartTimer call. IParameter1 | V6 | of the timer event will contain the timer ID. | V6 |------------------------------------------------------------------------*/ //V6 timerId = TIMER_ID; //V6 WinStartTimer( IThread::current().anchorBlock(), //V6 window->handle(), timerId, timeInterval); //V6 /*------------------------- Start the Handler ----------------------------| V6 | Start the handler by explicitly calling the overridden function. | V6 |------------------------------------------------------------------------*/ //V6 Inherited::handleEventsFor(window); //V6 return (*this); //V6 } /* end ATimeHandler :: handleEventsFor(...) */ //V6
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); }
MRESULT EXPENTRY ClientWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) { HPS hps; RECTL rcl; static ULONG i = 1; ULONG ulMem; char szBuf[200]; switch (msg) { case WM_CREATE: /* use smaller text */ WinSetPresParam(hwnd, PP_FONTNAMESIZE, 7, (PVOID)"8.Helv"); /* start the timer (ticks each 0.5 sec.) */ AddFloat(WinQueryWindow(hwnd, QW_PARENT)); WinStartTimer(hab, hwnd, ID_TIMER, 500); break; /* make window always stay on top (if desired) */ case WM_VRNENABLED: if (bFloat) WinSetWindowPos(hwndFrame, HWND_TOP, 0, 0, 0, 0, SWP_ZORDER); break; case WM_COMMAND: /* why doesn't WM_SYSCOMMAND work? */ if (LOUSHORT(mp1) == IDM_FLOAT) { bFloat = !bFloat; WinCheckMenuItem(hwndSysSubmenu, IDM_FLOAT, bFloat); } break; case WM_TIMER: if (++i > 13) i = 1; WinInvalidateRect(hwnd, NULL, FALSE); return FALSE; case WM_PAINT: hps = WinBeginPaint(hwnd, NULLHANDLE, &rcl); /* necessary to avoid incorrectly repainting window */ WinQueryWindowRect(hwnd, &rcl); /* sprintf(szBuf, " Current use %dK Maximum ever used %dK Errors %d", meminfo->used / 1024, meminfo->maxused / 1024, meminfo->num_err);*/ sprintf(szBuf, " Current use %dB Maximum ever used %dK Errors %d", meminfo->used, meminfo->maxused / 1024, meminfo->num_err); WinDrawText(hps, -1, szBuf, &rcl, CLR_BLACK, CLR_WHITE, DT_CENTER | DT_VCENTER | DT_ERASERECT); WinEndPaint(hps); break; } return WinDefWindowProc(hwnd, msg, mp1, mp2); }
static INT DisplayTimedMsg (HAB hab, HWND hwndDlg, PSZ pszMsg, LONG lSeconds) { WinSetDlgItemText (hwndDlg, IDST_STATUSMESSAGES, pszMsg); // Start a timer for message WinStartTimer (hab, hwndDlg, IDTIMER_DISPLAYTIMEDMSG, lSeconds * 1000); return 0; }
/*@ XTimer::Start() @group misc @remarks Start the timer. @parameters ULONG time time-interval in milli-seconds. */ BOOL XTimer::Start(const ULONG time) { timeOut = time; HWND hwnd = GetWindow()->GetHandle(); if (WinStartTimer(WinQueryAnchorBlock(hwnd), hwnd, timerID, time) == 0) return FALSE; else return TRUE; }
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)); }
/**************************************************************************** * 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); } }
void EnableReloadButton(HWND hwnd) { HAB hab = WinQueryAnchorBlock(hwnd); if (!use_smarttoolbar) return; if (*szFullPath=='\0') return; WinPostMsg(hwndToolbar,TOOLBAR_USERM_SHOWITEM,MPFROMLONG(TOOLBAR_RELOAD),MPFROMLONG(TRUE)); WinPostMsg(hwndToolbar,TOOLBAR_USERM_UPDATE,0,0); WinStartTimer(hab,hwnd,ID_TIMER,10000); }
/* 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; }
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 ; }
/****************************************************************\ * *-------------------------------------------------------------- * * Name:ClkCreate() * * Purpose:Intialize a newly created client window * * * * Usage: * * Method: * - * * - * - * * - * - * * Returns: * 1 - if sucessful execution completed * 0 - if error \****************************************************************/ VOID ClkCreate ( HWND hwnd ) { LONG cxScreen , cyScreen; /* screen dimensions */ LONG xLeft , yBottom ; /* frame window location */ ULONG cbBuf; LONG cyHeight; LONG cxWidth; hwndClient = hwnd; WinLoadString(hab, NULLHANDLE, IDS_TITLE, 0, (PSZ)szTitle ); WinLoadString(hab, NULLHANDLE, IDS_HELPTITLE, 256, (PSZ)szHelpTitle); GetCountryDependent(); /* we are called before the global hwndFrame is valid */ hwndFrame = WinQueryWindow ( hwnd , QW_PARENT) ; hwndTitleBar = WinWindowFromID ( hwndFrame , FID_TITLEBAR ) ; hwndSysMenu = WinWindowFromID ( hwndFrame , FID_SYSMENU ) ; hwndMinMax = WinWindowFromID ( hwndFrame , FID_MINMAX ) ; /* load our menus */ hwndMenu = WinLoadMenu (hwndFrame, NULLHANDLE, IDR_MAIN); /* determine screen dimensions */ /* open a device context and create a presentation space */ hdc = WinOpenWindowDC (hwnd); hps = GpiCreatePS (hab, hdc, &sizl, PU_ARBITRARY | GPIT_MICRO | GPIA_ASSOC); /* * Create our off-screen 'buffer'. */ hdcBuffer = DevOpenDC ( (HAB)0L, OD_MEMORY, "*", 0L, NULL, hdc); hpsBuffer = GpiCreatePS (hab, hdcBuffer, &sizl, PU_ARBITRARY | GPIT_MICRO | GPIA_ASSOC); GpiCreateLogColorTable (hpsBuffer, 0, LCOLF_RGB, 0, 0, (PLONG)NULL); /* get the device resolutions so we can make the face appear circular */ DevQueryCaps (hdc, (LONG)CAPS_VERTICAL_RESOLUTION,(LONG) 1L, &cyRes); DevQueryCaps (hdc, CAPS_HORIZONTAL_RESOLUTION, 1L, &cxRes); DevQueryCaps (hdc, CAPS_COLOR_PLANES, 1L, &cColorPlanes); DevQueryCaps (hdc, CAPS_COLOR_BITCOUNT, 1L, &cColorBitcount); cxScreen = WinQuerySysValue (HWND_DESKTOP, SV_CXSCREEN); cyScreen = WinQuerySysValue (HWND_DESKTOP, SV_CYSCREEN); /* * Calculate an initial window position and size. */ xLeft = cxScreen / 8; yBottom = cyScreen / 2; cxWidth = cxScreen / 3; cyHeight = cyScreen / 2; WinSetWindowPos (hwndFrame, NULLHANDLE, xLeft, yBottom, cxWidth, cyHeight, SWP_SIZE | SWP_MOVE | SWP_ACTIVATE); cbBuf = sizeof(cp); if (!PrfQueryProfileData(HINI_USER, SZ_APPNAME, SZ_KEYNAME, &cp, &cbBuf)) { cp.usMajorTickPref = CLKTM_ALWAYS; cp.usMinorTickPref = CLKTM_NOTICONIC; cp.clrBackground = 0x00008080; cp.clrFace = 0x00008080; cp.clrHourHand = RGB_RED; cp.clrMinuteHand = RGB_RED; cp.fControlsHidden = FALSE; cp.usDispMode = DM_TIME | DM_ANALOG | DM_SECONDHAND; cp.alarm.uchHour = 0; cp.alarm.uchMinutes = 0; cp.alarm.usMode = 0; SetRGBColors(); /* position the window and make it visible */ WinSetWindowPos( hwndFrame , NULLHANDLE , xLeft , yBottom , cxWidth , cyHeight , SWP_SIZE | SWP_MOVE | SWP_ACTIVATE); WinQueryWindowPos(hwndFrame, &cp.swp); } else { /*Protect against garbage swp*/ cp.swp.hwnd = hwndFrame; cp.swp.hwndInsertBehind = HWND_TOP; cp.swp.fl = (cp.swp.fl & (SWP_MINIMIZE | SWP_MAXIMIZE)) | SWP_SIZE | SWP_MOVE | SWP_ACTIVATE; SetRGBColors(); WinSetMultWindowPos(hab, &cp.swp, 1); } if (cp.fControlsHidden) ClkHideFrameControls (hwndFrame); /* * Check relevant items. */ WinSendMsg( hwndMenu, MM_SETITEMATTR, MPFROM2SHORT( IDM_TIME, TRUE), MPFROM2SHORT( MIA_CHECKED, ( (cp.usDispMode & DM_TIME)? MIA_CHECKED : ~MIA_CHECKED) ) ); WinSendMsg( hwndMenu, MM_SETITEMATTR, MPFROM2SHORT( IDM_DATE, TRUE), MPFROM2SHORT( MIA_DISABLED, ( (!(cp.usDispMode & DM_TIME))? MIA_DISABLED : ~MIA_DISABLED) ) ); WinSendMsg( hwndMenu, MM_SETITEMATTR, MPFROM2SHORT( IDM_DATE, TRUE), MPFROM2SHORT( MIA_CHECKED, ( (cp.usDispMode & DM_DATE)? MIA_CHECKED : ~MIA_CHECKED) ) ); WinSendMsg( hwndMenu, MM_SETITEMATTR, MPFROM2SHORT( IDM_TIME, TRUE), MPFROM2SHORT( MIA_DISABLED, ( ((!(cp.usDispMode & DM_DATE) || (cp.usDispMode & DM_ANALOG)))? MIA_DISABLED : ~MIA_DISABLED) ) ); WinSendMsg( hwndMenu, MM_SETITEMATTR, MPFROM2SHORT( (cp.usDispMode & DM_DIGITAL) ?IDM_DIGITAL :IDM_ANALOG, TRUE), MPFROM2SHORT( MIA_CHECKED, MIA_CHECKED)); WinSendMsg(hwndMenu, MM_SETITEMATTR, MPFROM2SHORT(IDM_SECONDHAND, TRUE), MPFROM2SHORT( MIA_CHECKED, ( (cp.usDispMode & DM_SECONDHAND) ? MIA_CHECKED : ~MIA_CHECKED))); /* * Disable these items if the digital clock is visible * since they won't apply. */ if (cp.usDispMode & DM_DIGITAL) { WinSendMsg (hwndMenu, MM_SETITEMATTR, MPFROM2SHORT(IDM_SECONDHAND, TRUE), MPFROM2SHORT(MIA_DISABLED, MIA_DISABLED)); WinSendMsg (hwndMenu, MM_SETITEMATTR, MPFROM2SHORT( IDM_TICKS, TRUE), MPFROM2SHORT( MIA_DISABLED, MIA_DISABLED)); } /* have we been asked to start as an icon? */ if (fStartAsIcon) WinSetWindowPos(hwndFrame, NULLHANDLE, 0, 0, 0, 0, SWP_MINIMIZE); WinShowWindow(hwndFrame, TRUE); /* get the time in a format for dislaying */ DosGetDateTime(&dt); dt.hours = (UCHAR )(dt.hours * (UCHAR) 5) % (UCHAR) 60 + dt.minutes / (UCHAR)12; /* start a timer */ WinStartTimer (hab, hwnd, IDR_MAIN, 1000); WinLoadString(hab, NULLHANDLE, IDS_TITLE, 80, (PSZ)szTitle); GetCountryDependent(); }
/************************************************************************** * * Name : main() * * Description: Initializes the process for OS/2 PM services and * process the application message queue until a * WM_QUIT message is received. It then destroys all * OS/2 PM resources and terminates. * * Concepts : - obtains anchor block handle and creates message * queue * - creates the main frame window which creates the * main client window * - polls the message queue via Get/Dispatch Msg loop * - upon exiting the loop, exits * * API's : WinInitialize * WinCreateMsgQueue * WinTerminate * WinSetWindowPos * WinSetWindowText * WinRegisterClass * WinCreateStdWindow * WinGetMsg * WinDispatchMsg * WinDestroyWindow * WinDestroyMsgQueue * * Parameters : [none] * * Return : 1 - if successful execution completed * 0 - if error * *************************************************************************/ INT main (VOID) { HMQ hmq; /* Message queue handle */ HWND hwndClient = NULLHANDLE; /* Client area window handle */ HWND hwndFrame = NULLHANDLE; /* Frame window handle */ QMSG qmsg; /* Message from message queue */ ULONG flCreate; /* Window creation control flags*/ if ((hab = WinInitialize(0)) == 0L) /* Initialize PM */ AbortHello(hwndFrame, hwndClient); /* Terminate the application */ if ((hmq = WinCreateMsgQueue( hab, 0 )) == 0L)/* Create a msg queue */ AbortHello(hwndFrame, hwndClient); /* Terminate the application */ if (!WinRegisterClass( /* Register window class */ hab, /* Anchor block handle */ (PSZ)"MyWindow", /* Window class name */ (PFNWP)MyWindowProc, /* Address of window procedure */ CS_SIZEREDRAW, /* Class style */ 0 /* No extra window words */ )) AbortHello(hwndFrame, hwndClient); /* Terminate the application */ flCreate = FCF_STANDARD & /* Set frame control flags to */ ~FCF_SHELLPOSITION; /* standard except for shell */ /* positioning. */ if ((hwndFrame = WinCreateStdWindow( HWND_DESKTOP, /* Desktop window is parent */ 0, /* STD. window styles */ &flCreate, /* Frame control flag */ "MyWindow", /* Client window class name */ "", /* No window text */ 0, /* No special class style */ (HMODULE)0L, /* Resource is in .EXE file */ ID_WINDOW, /* Frame window identifier */ &hwndClient /* Client window handle */ )) == 0L) AbortHello(HWND_DESKTOP, HWND_DESKTOP); /* Terminate the application */ WinSetWindowText(hwndFrame, "ColorPicker"); if (!WinSetWindowPos( hwndFrame, /* Shows and activates frame */ HWND_TOP, /* window at position 100, 100, */ 100, 100, 170, 100, /* and size 200, 200. */ SWP_SIZE | SWP_MOVE | SWP_ACTIVATE | SWP_SHOW )) AbortHello(hwndFrame, hwndClient); /* Terminate the application */ WinStartTimer(hab, hwndClient, 1UL, /* Ignored as previous parm. is null */ 100UL); /* * Get and dispatch messages from the application message queue * until WinGetMsg returns FALSE, indicating a WM_QUIT message. */ while( WinGetMsg( hab, &qmsg, 0L, 0, 0 ) ) WinDispatchMsg( hab, &qmsg ); WinDestroyWindow(hwndFrame); /* Tidy up... */ WinDestroyMsgQueue( hmq ); /* Tidy up... */ WinTerminate( hab ); /* Terminate the application */ return(0); } /* End of main */
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; }
/************************************************************************* * * 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 Window::stdWndProc( HWND hWnd, ULONG iMessage, MPARAM mParam1, MPARAM mParam2, BOOL *returned ) { switch( iMessage ) { // case WM_FOCUSCHANGE : case WM_SETSELECTION : case WM_ACTIVATE : { if( type != Window::LISTBOX && type != Window::COMBOLISTBOX ) { focus( (BOOL)mParam1 );//SHORT1FROMMP( mParam2 ) ); } break; } case WM_SETFOCUS : { if( type != Window::LISTBOX && type != Window::COMBOLISTBOX ) focusSet( (BOOL)mParam2 ); break; } case WM_BUTTON1DOWN : { if( type == SCROLLBAR ) setFocus(); HWND hwnd = WinQueryFocus( HWND_DESKTOP ); if( mouseListener.getSize() != 0 ) { mouseButtonDown = TRUE; WinSetCapture( HWND_DESKTOP, hWnd ); WinStartTimer( Application::hab, hWndClient, 1, 50 ); Point pos( SHORT1FROMMP(mParam1), SHORT2FROMMP(mParam1) ); performMouseEvent( &pos, AMouseEvent::LEFT, AMouseEvent::DOWN ); } if( hwnd != WinQueryFocus( HWND_DESKTOP ) ) return (MRESULT)TRUE; break; } case WM_BUTTON1UP : { if( type == LISTBOX || type == COMBOLISTBOX ) { performFocusEvent( (int)WinSendMsg( (HWND)mParam2, LM_QUERYSELECTION, MPARAM(0), MPARAM(NULL) ) ); } else if( mouseListener.getSize() != 0 ) { mouseButtonDown = FALSE; WinStopTimer( Application::hab, hWndClient, 1 ); WinSetCapture( HWND_DESKTOP, NULLHANDLE ); Point pos( SHORT1FROMMP(mParam1), SHORT2FROMMP(mParam1) ); performMouseEvent( &pos, AMouseEvent::LEFT, AMouseEvent::RELEASE ); // return (MPARAM)TRUE; } break; } case WM_BUTTON2DOWN : { if( mouseListener.getSize() != 0 ) { WinSetCapture( HWND_DESKTOP, hWnd ); WinStartTimer( Application::hab, hWndClient, 1, 50 ); Point pos( SHORT1FROMMP(mParam1), SHORT2FROMMP(mParam1) ); performMouseEvent( &pos, AMouseEvent::RIGHT, AMouseEvent::DOWN ); } break; } case WM_BUTTON2UP : { if( mouseListener.getSize() != 0 ) { WinStopTimer( Application::hab, hWndClient, 1 ); WinSetCapture( HWND_DESKTOP, NULLHANDLE ); Point pos( SHORT1FROMMP(mParam1), SHORT2FROMMP(mParam1) ); performMouseEvent( &pos, AMouseEvent::RIGHT, AMouseEvent::RELEASE ); } break; } case WM_BUTTON1CLICK : { if( mouseListener.getSize() != 0 ) { // Check if triple click int newTick = WinGetCurrentTime( Application::hab ); if( newTick - lastTick <= WinQuerySysValue( HWND_DESKTOP, SV_DBLCLKTIME ) ) { Point pos( SHORT1FROMMP(mParam1), SHORT2FROMMP(mParam1) ); performMouseEvent( &pos, AMouseEvent::LEFT, AMouseEvent::TRIPLECLICK ); } else { Point pos( SHORT1FROMMP(mParam1), SHORT2FROMMP(mParam1) ); performMouseEvent( &pos, AMouseEvent::LEFT, AMouseEvent::CLICK ); } } break; } case WM_BUTTON2CLICK : { if( mouseListener.getSize() != 0 ) { Point pos( SHORT1FROMMP(mParam1), SHORT2FROMMP(mParam1) ); performMouseEvent( &pos, AMouseEvent::RIGHT, AMouseEvent::CLICK ); } break; } case WM_BUTTON1DBLCLK : { if( mouseListener.getSize() != 0 ) { Point pos( SHORT1FROMMP(mParam1), SHORT2FROMMP(mParam1) ); performMouseEvent( &pos, AMouseEvent::LEFT, AMouseEvent::DOUBLECLICK ); } lastTick = WinGetCurrentTime( Application::hab ); break; } case WM_BUTTON2DBLCLK : { if( mouseListener.getSize() != 0 ) { Point pos( SHORT1FROMMP(mParam1), SHORT2FROMMP(mParam1) ); performMouseEvent( &pos, AMouseEvent::RIGHT, AMouseEvent::DOUBLECLICK ); } break; } case WM_MOUSEMOVE : { if( currentPointer != NULLHANDLE ) WinSetPointer( HWND_DESKTOP, currentPointer ); if( mouseListener.getSize() != 0 ) { Point pos( (SHORT)SHORT1FROMMP(mParam1), (SHORT)SHORT2FROMMP(mParam1) ); performMouseEvent( &pos, 0, AMouseEvent::MOVE ); } if( currentPointer != NULLHANDLE ) return (MPARAM)TRUE; break; } case WM_TIMER : { if( mouseButtonDown ) { POINTL ptl; WinQueryPointerPos( HWND_DESKTOP, &ptl ); WinMapWindowPoints( HWND_DESKTOP, hWnd, &ptl, 1 ); if( ptl.y < 0 || ptl.y > height ) { Point pos( ptl.x, ptl.y ); performMouseEvent( &pos, 0, AMouseEvent::MOVE ); } } break; } case WM_SIZE : { int oldWidth = width, oldHeight = height; SWP swp; WinQueryWindowPos( hWndFrame, &swp ); width = swp.cx; height = swp.cy; size( oldWidth, oldHeight ); break; } case WM_HSCROLL : { int pos = SHORT1FROMMP( mParam2 ), id = SHORT1FROMMP( mParam1 ); switch( SHORT2FROMMP( mParam2 ) ) { case SB_PAGERIGHT : { performScrollbarEvent( id, Scrollbar::PAGERIGHT, pos ); break; } case SB_PAGELEFT : { performScrollbarEvent( id, Scrollbar::PAGELEFT, pos ); break; } case SB_LINERIGHT : { performScrollbarEvent( id, Scrollbar::LINERIGHT, pos ); break; } case SB_LINELEFT : { performScrollbarEvent( id, Scrollbar::LINELEFT, pos ); break; } case SB_SLIDERTRACK : { performScrollbarEvent( id, Scrollbar::HORZTRACK, pos ); break; } case SB_SLIDERPOSITION : { performScrollbarEvent( id, Scrollbar::HORZRELEASED, pos ); break; } } break; } case WM_SYSCOMMAND : { // Check if the parent is a dialog, then chain the WM_SYSCOMMAND if( parent->getType() == DIALOG ) WinSendMsg( ((Window *)parent)->getHWND(), WM_SYSCOMMAND, mParam1, mParam2 ); break; } case WM_VSCROLL : { int id = SHORT1FROMMP( mParam1 ); Scrollbar *scrollbar = (Scrollbar *)getControl( id ); int pos; if( scrollbar ) pos = scrollbar->convertScrollPosToReal( SHORT1FROMMP( mParam2 ) ); else pos = SHORT1FROMMP( mParam2 ); switch( SHORT2FROMMP( mParam2 ) ) { case SB_PAGEDOWN : { performScrollbarEvent( id, Scrollbar::PAGEDOWN, pos ); break; } case SB_PAGEUP : { performScrollbarEvent( id, Scrollbar::PAGEUP, pos ); break; } case SB_LINEDOWN : { performScrollbarEvent( id, Scrollbar::LINEDOWN, pos ); break; } case SB_LINEUP : { performScrollbarEvent( id, Scrollbar::LINEUP, pos ); break; } case SB_SLIDERTRACK : { performScrollbarEvent( id, Scrollbar::VERTTRACK, pos ); break; } case SB_SLIDERPOSITION : { performScrollbarEvent( id, Scrollbar::VERTRELEASED, pos ); break; } } break; } case WM_MOVE : { SWP swp; WinQueryWindowPos( hWndFrame, &swp ); x = swp.x; y = swp.y; move(); break; } case WM_CLOSE : { if( close() ) break; else return (MPARAM)FALSE; } case WM_COMMAND : { if( SHORT1FROMMP( mParam2 ) == CMDSRC_PUSHBUTTON ) { Window *control = (Window *)getControl( SHORT1FROMMP(mParam1)); if( control != NULL ) { if( control->type == PUSHBUTTON ) { control->performButtonEvent( control, control->id ); return FALSE; } } else return FALSE; // In case ESC would close the dialog } break; } case WM_CHAR : { if( type == LISTBOX ) { performFocusEvent( (int)WinSendMsg( (HWND)mParam2, LM_QUERYSELECTION, MPARAM(0), MPARAM(NULL) ) ); } if( (SHORT1FROMMP( mParam1 ) & KC_KEYUP) || (SHORT1FROMMP( mParam1 ) & KC_DEADKEY) || (SHORT1FROMMP( mParam1 ) & KC_INVALIDCOMP) ) break; /* if( SHORT1FROMMP( mParam1 ) & KC_COMPOSITE ) mParam1 = MPFROM2SHORT( SHORT1FROMMP( mParam1 ) & ~KC_VIRTUALKEY, SHORT2FROMMP( mParam1 ) );*/ int modifiers = 0; if( SHORT1FROMMP( mParam1 ) & KC_SHIFT ) modifiers |= KeyDef::SHIFT; if( SHORT1FROMMP( mParam1 ) & KC_ALT ) modifiers |= KeyDef::kALT; if( SHORT1FROMMP( mParam1 ) & KC_CTRL) modifiers |= KeyDef::CTRL; if( SHORT1FROMMP( mParam1 ) & KC_VIRTUALKEY ) { int key = 0, vKey = SHORT2FROMMP( mParam2 ); // Maybe NumLock is on if( SHORT1FROMMP(mParam1) & KC_CHAR && !(vKey == VK_ENTER || vKey == VK_NEWLINE || vKey == VK_TAB || vKey == VK_BACKSPACE )) key = SHORT1FROMMP( mParam2 ); else if( vKey == VK_UP ) key = KeyDef::UP; else if( vKey == VK_DOWN ) key = KeyDef::DOWN; else if( vKey == VK_LEFT ) key = KeyDef::LEFT; else if( vKey == VK_RIGHT ) key = KeyDef::RIGHT; else if( vKey == VK_PAGEUP ) key = KeyDef::PAGEUP; else if( vKey == VK_PAGEDOWN ) key = KeyDef::PAGEDOWN; else if( vKey == VK_INSERT ) key = KeyDef::INSERT; else if( vKey == VK_DELETE ) key = KeyDef::kDELETE; else if( vKey == VK_HOME ) key = KeyDef::HOME; else if( vKey == VK_END ) key = KeyDef::END; else if( vKey == VK_ESC ) key = KeyDef::ESCAPE; else if( vKey == VK_F1 ) key = KeyDef::F1; else if( vKey == VK_F2 ) key = KeyDef::F2; else if( vKey == VK_F3 ) key = KeyDef::F3; else if( vKey == VK_F4 ) key = KeyDef::F4; else if( vKey == VK_F5 ) key = KeyDef::F5; else if( vKey == VK_F6 ) key = KeyDef::F6; else if( vKey == VK_F7 ) key = KeyDef::F7; else if( vKey == VK_F8 ) key = KeyDef::F8; else if( vKey == VK_F9 ) key = KeyDef::F9; else if( vKey == VK_F10 ) key = KeyDef::F10; else if( vKey == VK_F11 ) key = KeyDef::F11; else if( vKey == VK_F12 ) key = KeyDef::F12; else if( vKey == VK_ENTER ) key = KeyDef::ENTER; else if( vKey == VK_NEWLINE ) key = KeyDef::RETURN; else if( vKey == VK_BACKSPACE ) key = KeyDef::BACKSPACE; else if( vKey == VK_TAB ) key = KeyDef::TAB; else if( vKey == VK_BACKTAB ) { key = KeyDef::TAB; modifiers |= KeyDef::SHIFT; } else if( vKey == VK_SPACE ) key = KeyDef::SPACE; if( parent->getType() == DIALOG ) ((Dialog *)parent)->focusHotkey( key ); if( key != 0 ) if( performKeyEvent( this, modifiers, key ) ) return MPARAM(TRUE); // Do not pass up and down key to dialog if this is a combobox (would // move focus) /* if( getFilterDialogArrows() && (vKey == VK_UP || vKey == VK_DOWN) ) return (MPARAM)TRUE;*/ } else { int key = SHORT1FROMMP( mParam2 ); if( performKeyEvent( this, modifiers, key ) ) return MPARAM(TRUE); } break; } case WM_CONTROL : { Window *control = (Window *)getControl( SHORT1FROMMP(mParam1)); if( control != NULL ) { if( control->type == Window::LISTBOX || control->type == Window::COMBOLISTBOX ) { switch( SHORT2FROMMP(mParam1) ) { case LN_KILLFOCUS : control->focus( FALSE ); break; case LN_SETFOCUS : control->focus( TRUE );break; case LN_ENTER : control->performSelectionEvent( (int)WinSendMsg( (HWND)mParam2, LM_QUERYSELECTION, MPARAM(0), MPARAM(NULL) ) ); break; } } else if( control->type == Window::SCROLLBAR ) { switch( SHORT2FROMMP(mParam1) ) { case SLN_KILLFOCUS : control->focus( FALSE ); break; case SLN_SETFOCUS : control->setFocus(); break; } } else if( control->type == Window::RADIOBUTTON || control->type == Window::CHECKBOX ) { switch( SHORT2FROMMP( mParam1) ) { case BN_CLICKED : case BN_DBLCLICKED : control->performButtonEvent( control, control->id ); break; } } } break; } case DM_DRAGOVER: { PDRAGINFO pDInfo; PDRAGITEM pDItem; if( !acceptDropFiles ) return MRFROM2SHORT(DOR_NODROPOP, 0); pDInfo = (PDRAGINFO)mParam1; DrgAccessDraginfo(pDInfo); pDItem = DrgQueryDragitemPtr(pDInfo, 0); USHORT usOp = 0, usDrop = DOR_NEVERDROP; /* Inspect each item to see if it is acceptable */ ULONG ulItems = DrgQueryDragitemCount (pDInfo); for (INT i = 0; i < ulItems; i++) { pDItem = DrgQueryDragitemPtr(pDInfo, i); /* The item is acceptable only if it is copyable and the */ /* operation is a copy, or it is moveable and the operation */ /* is a move, and it can render <DRM_OS2FILE, NULL> */ if (pDItem->fsSupportedOps & DO_COPYABLE) { usOp = DO_COPY; /* Only check files, all types */ if (DrgVerifyRMF(pDItem, "DRM_OS2FILE", 0)) usDrop = DOR_DROP; else { usDrop = DOR_NEVERDROP; break; } } else { /* Must be a file but not droppable in type op */ usDrop = DOR_NODROPOP; usOp = 0; break; } } /* end for all items dragged */ DrgFreeDraginfo(pDInfo); return MRFROM2SHORT(usDrop, usOp); } case DM_DROP: { PDRAGINFO pDInfo; PDRAGITEM pDItem; pDInfo = (PDRAGINFO)mParam1; DrgAccessDraginfo(pDInfo); pDItem = DrgQueryDragitemPtr(pDInfo, 0); ULONG ulItems = DrgQueryDragitemCount (pDInfo); ULONG p; char **files; files = (char **)malloc( sizeof( char * ) * ulItems ); for (INT i=0; i < ulItems; i++) { CHAR DragSrcPath[CCHMAXPATH], DragSrcName[CCHMAXPATH]; pDItem = DrgQueryDragitemPtr(pDInfo, i); DrgQueryStrName(pDItem->hstrContainerName, sizeof(DragSrcPath), (PSZ)DragSrcPath); if (!(PSZ)DragSrcPath) break; if (DragSrcPath[(strlen(DragSrcPath)-1)] != '\\') strcat((PSZ)DragSrcPath, "\\"); /* Use the dragitem source name, it's the real name */ DrgQueryStrName(pDItem->hstrSourceName, sizeof(DragSrcName), (PSZ)DragSrcName); if (!((PSZ)DragSrcName)) break; strcat((PSZ)DragSrcPath, (PSZ)DragSrcName); FILESTATUS3 fsFile; DosError(FERR_DISABLEHARDERR); APIRET rc = DosQueryPathInfo(DragSrcPath, FIL_STANDARD, &fsFile, sizeof(FILESTATUS3)); DosError(FERR_ENABLEHARDERR); if (!rc && !(fsFile.attrFile & FILE_DIRECTORY)) { files[i] = (char *)malloc( strlen(DragSrcPath) + 1 ); strcpy( files[i], DragSrcPath ); DrgSendTransferMsg(pDItem->hwndItem, DM_ENDCONVERSATION, MPFROMLONG(pDItem->ulItemID), MPFROMLONG(DMFL_TARGETSUCCESSFUL)); } else { DosBeep(100,10); // EditorDisplay[BufNum]->DisplayMessage( pszDropNoFile ); } } filesDropped( files, ulItems ); for( i = 0; i < ulItems; i++ ) free( (void *)files[i] ); free( (void *)files ); DrgFreeDraginfo(pDInfo); break; } case WM_USER + 1 : { return (MPARAM)execFromMainThread( (int)mParam1, (void *)mParam2 ); } case WM_USER + 2 : { setFocus(); break; } } *returned = FALSE; return (MRESULT)NULL; }
MRESULT EXPENTRY 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; }
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 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); } }
/**************************************************************************** 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); }
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; }
/**************************************************************************** * ProcessChar * * Processes WM_CHAR messages for ClientWndProc * * Receives the virtual key and character codes * ****************************************************************************/ VOID ProcessChar(CHAR vkey, BOOL vkv, CHAR chr, BOOL keydown) { BOOL bKeyPress = TRUE; static INT iSpeed = 0, iPos = 0; static CHAR szSpeed[2][8] = { "Windows", "OS/2" }; if (!vkv && !keydown) { if (iSpeed == 0 && chr == szSpeed[0][iPos] || iSpeed == 1 && chr == szSpeed[1][iPos]) { iPos++; } else if (iSpeed == 0 && chr == szSpeed[1][iPos]) { iPos = 1; iSpeed = 1; } else if (iSpeed == 1 && chr == szSpeed[0][iPos]) { iPos = 1; iSpeed = 0; } else { iPos = 0; } if (iSpeed == 0 && iPos == 7) { iPos = 0; if (uiSpeed == SPEED_WINDOWS) { uiSpeed = SPEED_NORMAL; iTickLen = TIMER_TICK_LENGTH; WinStartTimer(hab, hwndClient, ID_TIMER, iTickLen); } else { uiSpeed = SPEED_WINDOWS; iTickLen = TIMER_TICK_LENGTH*4; WinStartTimer(hab, hwndClient, ID_TIMER, iTickLen); } } else if (iSpeed == 1 && iPos == 4) { iPos = 0; if (uiSpeed == SPEED_WINDOWS) { uiSpeed = SPEED_OS2; iTickLen = TIMER_TICK_LENGTH; WinStartTimer(hab, hwndClient, ID_TIMER, iTickLen); } else if (uiSpeed == SPEED_OS2) { uiSpeed = SPEED_NORMAL; } else { uiSpeed = SPEED_OS2; } } } if ((iGameMode == GAME_MODE_HIGH) && !keydown) return; if ((vkv && (vkey == prfProfile.keyDEFS[4].vk)) || (!vkv && (chr == prfProfile.keyDEFS[4].chr))) { if (iShipMode[Player] & FIRERELEASE) { if (!keydown) { iShipMode[Player] &= ~FIRERELEASE; } } else { UPDATE_FIRE(iShipMode[Player], keydown); } } else if ((vkv && (vkey == prfProfile.keyDEFS[0].vk)) || (!vkv && (chr == prfProfile.keyDEFS[0].chr))) { UPDATE_LEFT(iShipMode[Player], keydown); } else if ((vkv && (vkey == prfProfile.keyDEFS[1].vk)) || (!vkv && (chr == prfProfile.keyDEFS[1].chr))) { UPDATE_RIGHT(iShipMode[Player], keydown); } else if ((vkv && (vkey == prfProfile.keyDEFS[2].vk)) || (!vkv && (chr == prfProfile.keyDEFS[2].chr))) { UPDATE_THRUST(iShipMode[Player], keydown); } else if ((vkv && (vkey == prfProfile.keyDEFS[3].vk)) || (!vkv && (chr == prfProfile.keyDEFS[3].chr))) { UPDATE_HYPERSPACE(iShipMode[Player], iShipModeCnt[Player]); } else if ((vkv && (vkey == prfProfile.keyDEFS[5].vk )) || (!vkv && (chr == prfProfile.keyDEFS[5].chr))) { UPDATE_SHIELD(iShipMode[Player], iShipShieldCnt[Player]); } else { bKeyPress = FALSE; } if (bKeyPress && TogglePause(CHECK)) TogglePause(TOGGLE); }
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); }
MRESULT EXPENTRY MyWindowProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 ) { RECTL clientrect; /* Rectangle coordinates */ HPS hpsPaint; POINTL pt; /* String screen coordinates */ BOOL Invalid; int Line; ERRORID Err; HWND Focus,Active; HMQ hmqDeb; PID pid,cpid; TID tid,ctid; switch( msg ) { case WM_CREATE: WinStartTimer(hab,hwnd,1234,500); break; /* end the application. */ case WM_TIMER: rc=DosOpen("KBD$", &hKbd, &Action, 0, FILE_NORMAL, FILE_OPEN, OPEN_ACCESS_READONLY | OPEN_SHARE_DENYNONE | OPEN_FLAGS_FAIL_ON_ERROR, 0); if (rc) { char Buf[80]; sprintf(Buf,"Open rc = %d",rc); WinMessageBox(HWND_DESKTOP, HWND_DESKTOP, Buf, "TRAPIT", 1234, MB_OK); } /* endif */ Dlen= sizeof(State); rc = DosDevIOCtl( hKbd, 4, 0x73, 0, 0, 0, &State, sizeof(State), &Dlen ); Shift=(USHORT)State; DosClose(hKbd); Invalid=FALSE; if ((State&0x0500)==0x0500) { if (Color!=CLR_RED) { Color=CLR_RED; Invalid=TRUE; } /* endif */ Focus=WinQueryFocus(HWND_DESKTOP); Active=WinQueryActiveWindow(HWND_DESKTOP); WinQueryWindowProcess(Focus,&pid,&tid); hmqDeb=(HMQ)WinQueryWindowULong(Focus,QWL_HMQ); if (hmqDeb==hmq) { sprintf(Buffer,"Sorry Can't unhang Myself"); } else { DosKillProcess(DKP_PROCESS,pid); } /* endif */ } else { if ((State&0x0A00)==0x0A00) { if (Color!=CLR_BLUE) { Color=CLR_BLUE; Invalid=TRUE; } /* endif */ Focus=WinQueryFocus(HWND_DESKTOP); Active=WinQueryActiveWindow(HWND_DESKTOP); WinQueryWindowProcess(Focus,&pid,&tid); hmqDeb=(HMQ)WinQueryWindowULong(Focus,QWL_HMQ); if (hmqDeb==hmq) { sprintf(Buffer,"Sorry Can't trap Myself"); } else { HENUM hEnum; CHAR Class[20]; HWND Child; hEnum = WinBeginEnumWindows(HWND_OBJECT); while ( (Child=WinGetNextWindow(hEnum)) != 0) { WinQueryWindowProcess(Child,&cpid,&ctid); if (cpid==pid) { Class[0]=0; WinQueryClassName(Child,sizeof(Class)-1,Class); if (strcmp(Class,"Killer")==0) { if (WinPostMsg(Child,WM_USER+1,0,0)) { DosBeep(1800,80); DosBeep(600,80); DosBeep(1800,80); } } /* endif */ } /* endif */ } WinEndEnumWindows(hEnum); } /* endif */ } else { if (Color!=CLR_BACKGROUND) { Color=CLR_BACKGROUND; Invalid=TRUE; } } /* endif */ } /* endif */ if (Invalid) { WinInvalidateRect( hwnd, NULL, TRUE ); } /* endif */ break; case WM_PAINT: hpsPaint=WinBeginPaint( hwnd,0, &clientrect ); WinFillRect( hpsPaint, &clientrect,Color );/* Fill invalid rectangle */ pt.x = 10; pt.y = 190; /* Set the text coordinates, */ GpiCharStringAt( hpsPaint, &pt, (LONG)strlen(Buffer),Buffer); for (Line=0;Line<8;Line++ ) { pt.x = 10; pt.y = 170-(20*Line); /* Set the text coordinates, */ GpiCharStringAt( hpsPaint, &pt, (LONG)strlen(LabelText[Line]),LabelText[Line]); } /* endfor */ WinEndPaint( hpsPaint ); /* Drawing is complete */ break; case WM_CLOSE: /******************************************************************/ /* This is the place to put your termination routines */ /******************************************************************/ WinPostMsg( hwnd, WM_QUIT, 0L, 0L ); /* Cause termination */ break; default: /******************************************************************/ /* Everything else comes here. This call MUST exist */ /* in your window procedure. */ /******************************************************************/ return WinDefWindowProc( 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 ) ); }
/************************************************************************** * * FUNCTION NAME: ProcessSpeedDialog * * DESCRIPTION: * * * INPUT PARAMETERS: * None. * * OUTPUT PARAMETERS: * None. * **************************************************************************/ MRESULT EXPENTRY ProcessSpeedDialog (HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) { USHORT i; static USHORT usPosition; switch (msg) { case WM_INITDLG : /* Set the marks on the slider */ for (i = 0; i < 10; i++) { WinSendDlgItemMsg (hwnd, SLIDER_ID, SLM_SETTICKSIZE, MPFROM2SHORT(i, 2), NULL); } /* Label the ends of the slider */ WinSendDlgItemMsg (hwnd, SLIDER_ID, SLM_SETTICKSIZE, MPFROM2SHORT(0, 5), NULL); WinSendDlgItemMsg (hwnd, SLIDER_ID, SLM_SETTICKSIZE, MPFROM2SHORT(9, 5), NULL); WinSendDlgItemMsg (hwnd, SLIDER_ID, SLM_SETSCALETEXT, MPFROMSHORT(0), MPFROMP(SLOW_LABEL)); WinSendDlgItemMsg (hwnd, SLIDER_ID, SLM_SETSCALETEXT, MPFROMSHORT(9), MPFROMP(FAST_LABEL)); /* Set the slider position */ usPosition = (gFramesPerSec / 5) - 1; WinSendDlgItemMsg (hwnd, SLIDER_ID, SLM_SETSLIDERINFO, MPFROM2SHORT(SMA_SLIDERARMPOSITION, SMA_INCREMENTVALUE), MPFROMSHORT(usPosition)); /* Center the dialog box in the frame window of the parent */ CenterDialog (hwnd); return (0); case WM_COMMAND : switch (SHORT1FROMMP (mp1)) { case DID_OK: /* Calculate the frame rate from the position of the arm */ gFramesPerSec = (usPosition + 1) * 5; /* Reset the timer to tick at this rate */ WinStartTimer (hab, hwndDefClient, TIMER_ID, 1000/gFramesPerSec); WinDismissDlg (hwnd, DID_OK); return (0); case DID_CANCEL: /* Dismiss the dialog without saving the values */ WinDismissDlg (hwnd, DID_CANCEL); return (0); case DID_HELP: /* Display the keys help panel */ WinSendMsg (hwndHelpInstance, HM_DISPLAY_HELP, MPFROM2SHORT(PANEL_GAMESPEED, NULL), MPFROMSHORT(HM_RESOURCEID)); return (0); default: break; } break; case WM_CONTROL : switch (SHORT1FROMMP(mp1)) { case SLIDER_ID: if (SHORT2FROMMP(mp1) == SLN_CHANGE) { usPosition = (USHORT) WinSendDlgItemMsg (hwnd, SLIDER_ID, SLM_QUERYSLIDERINFO, MPFROM2SHORT (SMA_SLIDERARMPOSITION, SMA_INCREMENTVALUE), NULL); } break; default: break; } break; default: break; } return (WinDefDlgProc (hwnd, msg, mp1, mp2)); }
static MRESULT beginDrag(HWND hwnd, POINTS *p) { ICQFRAME *cfg = WinQueryWindowPtr(hwnd,0); RECTL rcl; POINTL ptl = { p->x, p->y }; CHKPoint(); DBGTrace(p->x); DBGTrace(p->y); cfg->xPos = cfg->yPos = 0xFFFF; WinMapWindowPoints(hwnd, HWND_DESKTOP, &ptl, 1); WinQueryWindowRect(hwnd, &rcl); rcl.xRight -= rcl.xLeft; rcl.yTop -= rcl.yBottom; DBGTrace(rcl.xRight); DBGTrace(rcl.yTop); if(p->y > (rcl.yTop - TOP_MARGIN) && (p->x < (rcl.xRight - RIGHT_MARGIN)) && (p->x > LEFT_MARGIN) ) { DBGMessage("Drag window"); cfg->yPos = ptl.y; cfg->xPos = ptl.x; cfg->flags |= ICQFRAME_FLAG_MOVEX|ICQFRAME_FLAG_MOVEY; } else { if(p->x < LEFT_MARGIN) { cfg->xPos = ptl.x; cfg->flags |= ICQFRAME_FLAG_SETCX|ICQFRAME_FLAG_MOVEX; CHKPoint(); } if(p->x > (rcl.xRight - RIGHT_MARGIN)) { CHKPoint(); cfg->xPos = ptl.x; cfg->flags |= ICQFRAME_FLAG_SETCX; } if(p->y < BOTTOM_MARGIN) { CHKPoint(); cfg->yPos = ptl.y; cfg->flags |= ICQFRAME_FLAG_SETCY|ICQFRAME_FLAG_MOVEY; } if(p->y > (rcl.yTop - TOP_MARGIN)) { CHKPoint(); cfg->yPos = ptl.y; cfg->flags |= ICQFRAME_FLAG_SETCY; } } DBGTracex(cfg->xPos); DBGTracex(cfg->yPos); if(cfg->xPos != 0xFFFF || cfg->yPos != 0xFFFF) { DBGTrace(cfg->xPos) DBGTrace(cfg->yPos); WinSetCapture(HWND_DESKTOP, hwnd); cfg->timer = WinStartTimer(WinQueryAnchorBlock(hwnd), hwnd, 1, 50); DBGTracex(cfg->timer); if(!cfg->timer) { DBGMessage("Error starting timer"); icqWriteSysLog(cfg->icq,PROJECT,"Failure starting size timer"); } } return (MRESULT) TRUE; }