MRESULT EXPENTRY newcomboproc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) { PCLBOX pclb = (PCLBOX)stGetData(WinQueryWindow(hwnd, QW_PARENT)); if (msg == WM_CHAR && (CHARMSG(&msg)->fs & KC_ALT) && !(CHARMSG(&msg)->fs & KC_KEYUP) && ((CHARMSG(&msg)->vkey == VK_UP))) { WinSetFocus(HWND_DESKTOP, pclb->hlbx); return (MRESULT)TRUE; } /* endif */ return pclb->pfef(hwnd, msg, mp1, mp2); // default listsbox controls proc }
MRESULT EXPENTRY newlboxproc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) { PELBOX pelb = (PELBOX)stGetData(WinQueryWindow(hwnd, QW_PARENT)); switch (msg) { case WM_BUTTON1DOWN: lboxMouBtn1dwn(pelb, MOUSEMSG(&msg)); WinPostMsg(hwnd, WM_BUTTON1UP, mp1, mp2); break; case WM_CHAR: if (lboxChar(pelb, CHARMSG(&msg))) return (MRESULT)TRUE; break; case WM_BEGINDRAG: if (lboxBeginDrag(pelb, MOUSEMSG(&msg))) return (MRESULT)TRUE; break; case WM_MOUSEMOVE: if (lboxMouseMove(pelb, MOUSEMSG(&msg))) return (MRESULT)TRUE; break; case WM_ENDDRAG: if (lboxEndDrag(pelb, MOUSEMSG(&msg))) return (MRESULT)TRUE; break; // implementa autoscrolling case WM_TIMER: if (lboxTimer(pelb, (ULONG)mp1)) return (MRESULT)FALSE; break; } /* endswitch */ return pelb->lbxwprc(hwnd, msg, mp1, mp2); }
/*--------------------------------------------------- * Process dialog messages *--------------------------------------------------*/ MRESULT _System KLSetupHKeys::dlg_proc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 ) { switch ( msg ) { case WM_INITDLG: { KLSetupHKeys* instance = (KLSetupHKeys*)mp2; SET_TEXT( hwnd, ID_KEY_TEXT, MSG_KEYPROMPT ); KLApp::do_warpsans( hwnd, ID_KEY_TEXT ); WinSetWindowULong( hwnd, QWL_USER, (ULONG)instance ); instance->hk_exclude = hkey_exclude( hwnd ); break; } case WM_DESTROY: { KLSetupHKeys* instance = (KLSetupHKeys*)WinQueryWindowULong( hwnd, QWL_USER ); hkey_exclude( instance->hk_exclude ); instance->hk_exclude = NULLHANDLE; } case WM_COMMAND: if( SHORT1FROMMP(mp1) == DID_CANCEL ) WinDismissDlg( hwnd, FALSE ); return MRFROMLONG(TRUE); case WM_CLOSE: WinDismissDlg( hwnd, FALSE ); return MRFROMLONG(TRUE); case WM_CHAR: if( !( CHARMSG(&msg)->fs & KC_KEYUP ) && CHARMSG(&msg)->vkey != VK_NUMLOCK && CHARMSG(&msg)->vkey != VK_ESC && CHARMSG(&msg)->vkey != VK_PRINTSCRN && CHARMSG(&msg)->vkey != VK_PAUSE && CHARMSG(&msg)->vkey != VK_SHIFT && CHARMSG(&msg)->vkey != VK_CTRL && CHARMSG(&msg)->vkey != VK_ALT && CHARMSG(&msg)->vkey != VK_CAPSLOCK && CHARMSG(&msg)->vkey != VK_SCRLLOCK && CHARMSG(&msg)->scancode ) { KLSetupHKeys* instance = (KLSetupHKeys*)WinQueryWindowULong( hwnd, QWL_USER ); if( instance ) { instance->hk_state = 0; instance->hk_scancode = CHARMSG(&msg)->scancode; if( CHARMSG(&msg)->fs & KC_CTRL ) instance->hk_state |= KLHotkey::control; if( CHARMSG(&msg)->fs & KC_ALT ) instance->hk_state |= KLHotkey::alt; if( CHARMSG(&msg)->fs & KC_SHIFT ) instance->hk_state |= KLHotkey::shift; instance->hk_assigned->assign( instance->hk_scancode, instance->hk_state ); } WinDismissDlg( hwnd, TRUE ); return MRFROMLONG(TRUE); } break; } return WinDefDlgProc( hwnd, msg, mp1, mp2 ); }
/* Message processing for our PM Window class */ MRESULT EXPENTRY Message_Process( HWND handle, ULONG mess, MPARAM parm1, MPARAM parm2 ) { static HDC screen_dc; static HPS screen_ps; static BOOL minimized; SIZEL sizl; SWP swp; grPMSurface* surface; /* get the handle to the window's surface -- note that this */ /* value will be null when the window is created */ surface = (grPMSurface*)WinQueryWindowPtr( handle, QWL_USER ); if (!surface) { surface = the_surface; WinSetWindowPtr( handle, QWL_USER, surface ); } switch( mess ) { case WM_DESTROY: /* warn the main thread to quit if it didn't know */ surface->event.type = gr_event_key; surface->event.key = grKeyEsc; DosPostEventSem( surface->event_lock ); break; case WM_CREATE: /* set original magnification */ minimized = FALSE; /* create Device Context and Presentation Space for screen. */ screen_dc = WinOpenWindowDC( handle ); screen_ps = GpiCreatePS( surface->anchor, screen_dc, &sizl, PU_PELS | GPIT_MICRO | GPIA_ASSOC | GPIF_DEFAULT ); /* take the input focus */ WinFocusChange( HWND_DESKTOP, handle, 0L ); LOG(( "screen_dc and screen_ps have been created\n" )); /* To permit F9, F10 and others to pass through to the application */ if (TRUE != WinSetAccelTable (surface->anchor, 0, surface->frame_window)) { printf( "Error - failed to clear accel table\n"); } break; case WM_MINMAXFRAME: /* to update minimized if changed */ swp = *((PSWP) parm1); if ( swp.fl & SWP_MINIMIZE ) minimized = TRUE; if ( swp.fl & SWP_RESTORE ) minimized = FALSE; return WinDefWindowProc( handle, mess, parm1, parm2 ); break; case WM_ERASEBACKGROUND: case WM_PAINT: /* copy the memory image of the screen out to the real screen */ LOCK( surface->image_lock ); WinBeginPaint( handle, screen_ps, NULL ); /* main image and magnified picture */ GpiBitBlt( screen_ps, surface->image_ps, 4L, surface->blit_points, ROP_SRCCOPY, BBO_AND ); WinEndPaint( screen_ps ); UNLOCK( surface->image_lock ); break; case WM_HELP: /* this really is a F1 Keypress !! */ surface->event.key = grKeyF1; goto Do_Key_Event; case WM_CHAR: if ( CHARMSG( &mess )->fs & KC_KEYUP ) break; /* look for a specific vkey */ { int count = sizeof( key_translators )/sizeof( key_translators[0] ); Translator* trans = key_translators; Translator* limit = trans + count; for ( ; trans < limit; trans++ ) if ( CHARMSG(&mess)->vkey == trans->os2key ) { surface->event.key = trans->grkey; goto Do_Key_Event; } } /* otherwise, simply record the character code */ if ( (CHARMSG( &mess )->fs & KC_CHAR) == 0 ) break; surface->event.key = CHARMSG(&mess)->chr; Do_Key_Event: surface->event.type = gr_event_key; DosPostEventSem( surface->event_lock ); break; default: return WinDefWindowProc( handle, mess, parm1, parm2 ); } return (MRESULT) FALSE; }
MRESULT EXPENTRY MLECustomProc(HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2) { SHORT sScrollBarFirst; SHORT sScrollBarLast; static SHORT sScrollBarRange; USHORT idVScroll; USHORT idHScroll; static int iFirstVScroll=0; static int iFirstHScroll=0; static HWND hwndHScroll; static HWND hwndVScroll; MRESULT mres; IPT ipt; //Insertion point IPT iptLineStart; //First insertion point for a line IPT iptTotalLineLength; //Total lenght of a line of text IPT iptCursorToEndLength; //Length from cursor to end of line. static long lCurrentLine; static long lCurrentColumn; int iRes; static BOOL bEnterKeyDown; LONG lColor; switch(msg) { case MLM_SETFONT: FontPalProc(); break; case MLM_SETBACKCOLOR: WinDlgBox(HWND_DESKTOP, hwnd, ColorChgDlgProc, NULLHANDLE, IDD_COLORCHANGE, NULL); //Reshow color palette ColorPalProc(); //If background color is changed, let message fall through if(glColorChgAction==COLORCHANGE_BACKGROUND) { //Get color of text. lColor=LONGFROMMR(WinSendMsg(hwndMLE, MLM_QUERYTEXTCOLOR, MPVOID,MPVOID)); if(lColor==mp1) { sprintf(buffer,"Text color and background color may not be the same."); WinMessageBox(HWND_DESKTOP, hwndClient, buffer,szAppName,0, MB_OK|MB_ICONEXCLAMATION|MB_MOVEABLE); return 0; } else { //Set color change flag so color is not changed again. glColorChgAction=COLORCHANGE_CANCEL; break; } } //If text color is changed, change text color and return if(glColorChgAction==COLORCHANGE_TEXT) { //Get color of background. lColor=LONGFROMMR(WinSendMsg(hwndMLE, MLM_QUERYBACKCOLOR, MPVOID,MPVOID)); if(lColor==mp1) { sprintf(buffer,"Text color and background color may not be the same."); WinMessageBox(HWND_DESKTOP, hwndClient, buffer,szAppName,0, MB_OK|MB_ICONEXCLAMATION|MB_MOVEABLE); return 0; } else { WinSendMsg(hwndMLE, MLM_SETTEXTCOLOR, mp1, MPVOID); //Set color change flag so color is not changed again. glColorChgAction=COLORCHANGE_CANCEL; return 0; } } //Handle cancel if(glColorChgAction==COLORCHANGE_CANCEL) return 0; break; //MLM_SETBACKCOLOR case WM_CHAR: //Set enter key flag down for autoindent. if(!(CHARMSG(&msg)->fs & KC_KEYUP)) { switch(CHARMSG(&msg)->vkey) { case VK_ENTER: case VK_NEWLINE: bEnterKeyDown=TRUE; break; } } //Let autosave know there was a modification if(CHARMSG(&msg)->fs & KC_KEYUP) { iRes=AutoSaveModProc(AUTOSAVEMOD_INCREMENT); } //Handle key status changes - caps lock, num lock, insert if(CHARMSG(&msg)->fs & KC_KEYUP) if(CHARMSG(&msg)->fs & KC_VIRTUALKEY) switch(CHARMSG(&msg)->vkey) { case VK_PAGEUP: break; case VK_UP: break; case VK_ENTER: case VK_NEWLINE: if(bEnterKeyDown) { if(bUseAutoIndent) iRes=AutoIndentProc(); } bEnterKeyDown=FALSE; break; case VK_INSERT: case VK_CAPSLOCK: case VK_NUMLOCK: if (bStatusBarOn) UpdateKeyStatus(); //in status.c break; } case WM_BUTTON1CLICK: if (bStatusBarOn) { //Update line display in status window ipt=LONGFROMMR(WinSendMsg(hwndMLE, MLM_QUERYSEL, MPFROMSHORT(MLFQS_CURSORSEL), MPVOID)); lGlobalCurrentLine=LONGFROMMR(WinSendMsg(hwndMLE, MLM_LINEFROMCHAR, MPFROMLONG(ipt), MPVOID))+1; //Get start of current line iptLineStart=LONGFROMMR(WinSendMsg(hwndMLE, MLM_CHARFROMLINE, MPFROMLONG(-1L), //MPFROMLONG(lGlobalCurrentLine), MPVOID)); //Get total length of line iptTotalLineLength=LONGFROMMR(WinSendMsg(hwndMLE, MLM_QUERYLINELENGTH, MPFROMLONG(iptLineStart), MPVOID)); //Get length from cursor to end of line iptCursorToEndLength=LONGFROMMR(WinSendMsg(hwndMLE, MLM_QUERYLINELENGTH, MPFROMLONG(-1L), MPVOID)); //Calculate current column lGlobalCurrentColumn=iptTotalLineLength-iptCursorToEndLength+1; //Update status window if line or column has changed if ( (lCurrentColumn!=lGlobalCurrentColumn) || (lCurrentLine!=lGlobalCurrentLine) ) UpdateStatusWindow(); //store curren line and column lCurrentColumn=lGlobalCurrentColumn; lCurrentLine=lGlobalCurrentLine; } //end if bStatusBarOn break; ///////////////////////////////////////////////////// //Real-time vertical scrolling case WM_VSCROLL: if(iFirstVScroll==0) { //Get scroll bar ID idVScroll=SHORT1FROMMP(mp1); //Get handle of scroll vertical scroll bar. hwndVScroll=WinWindowFromID(hwndMLE,idVScroll); //Get scroll bar range. mres=WinSendMsg(hwndVScroll, SBM_QUERYRANGE, MPVOID,MPVOID); sScrollBarFirst=SHORT1FROMMR(mres); sScrollBarLast=SHORT2FROMMR(mres); sScrollBarRange=sScrollBarLast-sScrollBarFirst; iFirstVScroll=1; } if (SHORT2FROMMP(mp2)==SB_ENDSCROLL) break; switch (SHORT2FROMMP(mp2)) { case SB_SLIDERTRACK: //Send message to fool MLE into thinking scroll has ended WinSendMsg(hwndMLE, WM_VSCROLL, mp1, MPFROMLONG( MAKELONG( SHORT1FROMMP(mp2), SB_SLIDERPOSITION ) )); WinSendMsg(hwndMLE, WM_VSCROLL, mp1, MPFROMLONG( MAKELONG( SHORT1FROMMP(mp2), SB_ENDSCROLL ) )); break; } //Invalidate scroll paint area. WinInvalidateRect(hwndVScroll,NULL,TRUE); //Force update of scroll bar WinUpdateWindow(hwndVScroll); break;//WM_VSCROLL ///////////////////////////////////////////////////// ///////////////////////////////////////////////////// //Real-time horizontal scrolling. case WM_HSCROLL: if(iFirstHScroll==0) { //Get scroll bar ID idHScroll=SHORT1FROMMP(mp1); //Get handle of scroll vertical scroll bar. hwndHScroll=WinWindowFromID(hwndMLE,idHScroll); iFirstHScroll=1; } if (SHORT2FROMMP(mp2)==SB_ENDSCROLL) break; switch (SHORT2FROMMP(mp2)) { case SB_SLIDERTRACK: //Send message to fool MLE into thinking scroll has ended WinSendMsg(hwndMLE, WM_HSCROLL, mp1, MPFROMLONG( MAKELONG( SHORT1FROMMP(mp2), SB_SLIDERPOSITION ) )); WinSendMsg(hwndMLE, WM_HSCROLL, mp1, MPFROMLONG( MAKELONG( SHORT1FROMMP(mp2), SB_ENDSCROLL ) )); break; } //Invalidate scroll paint area. WinInvalidateRect(hwndHScroll,NULL,TRUE); //Force update of scroll bar WinUpdateWindow(hwndHScroll); break; //WM_HSCROLL ///////////////////////////////////////////////////// } return MLEDefProc(hwnd,msg,mp1,mp2); }
/**************************************************************************** * KeyDlgProc * * - Redefines keys by processing WM_CHAR's and assigning the key to the * * selected radiobutton (game key) * * - Standard dialog window I/O * ****************************************************************************/ MRESULT EXPENTRY KeyDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) { int i; static KEY keyTmp[KEYS]; static SHORT id; switch (msg) { case WM_INITDLG: /* Set the associated text for each of the radio buttons */ for (i=0;i<KEYS;i++) { keyTmp[i] = prfProfile.keyDEFS[i]; SetText(hwnd, TEXT_LEFT+i, &prfProfile.keyDEFS[i]); } /* Check the first radio button and let it set up id */ WinSendDlgItemMsg(hwnd, KEY_LEFT, BM_CLICK, MPFROMSHORT(TRUE), MPVOID); return (MRESULT) TRUE; case WM_HELP: i = IDH_KEYS; WinSendMsg(hwndHelp, HM_DISPLAY_HELP, MPFROMP(&i), MPFROMSHORT(HM_RESOURCEID)); return 0; case WM_COMMAND: switch (SHORT1FROMMP(mp1)) { case DID_OK: for (i=0;i<KEYS;i++) prfProfile.keyDEFS[i] = keyTmp[i]; case DID_CANCEL: WinDismissDlg(hwnd, 0); return 0; } return 0; case WM_CONTROL: if (SHORT2FROMMP(mp1) == BN_CLICKED) { switch (SHORT1FROMMP(mp1)) { case KEY_LEFT: id = TEXT_LEFT; break; case KEY_RIGHT: id = TEXT_RIGHT; break; case KEY_THRUST: id = TEXT_THRUST; break; case KEY_HYPER: id = TEXT_HYPER; break; case KEY_FIRE: id = TEXT_FIRE; break; case KEY_SHIELD: id = TEXT_SHIELD; } WinSetFocus(HWND_DESKTOP, WinWindowFromID(hwnd,id)); } return 0; case WM_CHAR: if (!(CHARMSG(&msg)->fs & KC_KEYUP)) { if ((CHARMSG(&msg)->fs & KC_VIRTUALKEY) && (CHARMSG(&msg)->vkey != VK_SHIFT) && (CHARMSG(&msg)->vkey != VK_CTRL) && (CHARMSG(&msg)->vkey != VK_ALT) && (CHARMSG(&msg)->vkey != VK_F1) && (CHARMSG(&msg)->vkey-1 < MAXVKEY)) { if (CHARMSG(&msg)->vkey == VK_F3) { WinSendMsg(hwnd, WM_COMMAND, MPFROM2SHORT(DID_CANCEL, 0), MPVOID); return 0; } keyTmp[id-TEXT_LEFT].vk = (CHAR) (CHARMSG(&msg)->vkey - 1); keyTmp[id-TEXT_LEFT].chr = 0; } else if ((CHARMSG(&msg)->fs & KC_CHAR) && (CHARMSG(&msg)->chr > 32) && (CHARMSG(&msg)->chr < 127)) { keyTmp[id-TEXT_LEFT].vk = 0; keyTmp[id-TEXT_LEFT].chr = (CHAR) CHARMSG(&msg)->chr; } else { keyTmp[id-TEXT_LEFT].vk = 0; keyTmp[id-TEXT_LEFT].chr = 0; } } SetText(hwnd, id, &keyTmp[id-TEXT_LEFT]); return 0; } return WinDefDlgProc(hwnd, msg, mp1, mp2); }
/**************************************************************************** * ClientWndProc * * - Typical PM client window procedure. (see below) * * - Standard client window I/O * ****************************************************************************/ MRESULT EXPENTRY ClientWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) { RECTL rcl; SWP swp; HPS hpsPaint; static HPS hps; /* Permanent HPS */ static INT cx, cy; /* Client window dimensions */ static BOOL bSlowUpdateNow = FALSE; /* Update toggle for asteroids * * and enemy which are slow. */ static POINTL ptlCenter; /* Center of client window */ switch (msg) { /* Recieved from WinCreateStdWindow */ case WM_CREATE: /* Get permanent PS for entire window */ hps = WinGetPS(hwnd); /* Load private Asteroid fonts from ASTEROID.DLL */ if (GpiLoadFonts(hab, "ASTEROID") != GPI_OK) { WinReleasePS(hps); WinAlarm(HWND_DESKTOP, WA_WARNING); WinMessageBox(HWND_DESKTOP,NULLHANDLE, "Please put ASTEROID.DLL in a directory in your LIBPATH.", "Error reading ASTEROID.DLL", 0,MB_ICONHAND|MB_OK|MB_APPLMODAL); WinPostMsg(hwnd,WM_QUIT,(MPARAM) 0L,(MPARAM) 0L); return (MRESULT) TRUE; } /* Register/create logical fonts for use */ InitFonts(hps); /* Display About dialoge box */ WinDlgBox(HWND_DESKTOP, hwnd, (PFNWP)AboutDlgProc, NULLHANDLE, IDD_ABOUT, NULL); return 0; /* Recieved during attract mode when user starts game */ case WM_STARTGAME: /* Determine the number of players */ cPlayers = (INT)LONGFROMMP(mp1); /* Initialize each player */ for (Player=0;Player<cPlayers;Player++) { Level[Player] = 1; Ships[Player] = prfProfile.iSHIPS; DeletePhotons(); InitAsteroids(); InitEnemy(); } /* Start with player 1 */ Player = 0; iGameMode = GAME_MODE_NEXT; iGameModeCnt = GAME_PAUSE_TIME-1; /* Hide the pointer if mouse controls are enabled */ ShowMouse(FALSE); /* Paint everything */ WinSendMsg(hwnd, WM_PAINT, MPVOID, MPVOID); return 0; /* Recieved at startup and at the completion of a game */ case WM_INITGAME: /* Make mouse visible if we hid it before */ ShowMouse(TRUE); /* Fix menu to reflect attract mode */ EnableMenuItem(hwndMenu, IDM_START, TRUE); EnableMenuItem(hwndMenu, IDM_STOP, FALSE); /* Initialize player and enemy data structures */ cPlayers = 0; Level[0] = 1; for (Player=0;Player<2;Player++) { Score[Player] = 0L; Ships[Player] = 0; DeletePhotons(); } Player = 0; /* Initialize asteroids (and enemy) for attract mode */ InitAsteroids(); InitEnemy(); /* Depending on whether ASTEROID was just started or a game just * * completed display the "High Score" or "Press 1 or 2" screen. */ if (SHORT1FROMMP(mp1) == 0) { iGameMode = GAME_MODE_INIT1; iGameModeCnt = GAME_INIT_TIME; } else { iGameMode = GAME_MODE_INIT2; iGameModeCnt = GAME_INIT_TIME; } /* Paint everything */ WinSendMsg(hwnd, WM_PAINT, MPVOID, MPVOID); return 0; /* Usually recieved from the system, sometime forced by the program to * * ensure the screen is not corrupt. */ case WM_PAINT: /* Clear entire window to insure no "droppings" */ WinQueryWindowRect(hwnd,&rcl); WinFillRect(hps, &rcl, CLR_BLACK); WinInvalidateRect(hwnd, &rcl, FALSE); /* Get the update region and paint it black */ hpsPaint = WinBeginPaint(hwnd, (HPS)NULL, &rcl); WinFillRect(hpsPaint, &rcl, CLR_BLACK); WinEndPaint(hpsPaint); /* Only in normal play mode should we draw the ship */ if ((iGameMode == GAME_MODE_PLAY) && (iShipMode[Player] != EXPLOSION) && (iShipMode[Player] != HYPERSPACE)) DrawShip(hps, cx, cy, DRAW_INIT); else if ((iGameMode == GAME_MODE_PLAY) && (iShipMode[Player] == EXPLOSION)) ExplodeShip(hps, cx, cy); /* Draw the enemy if it is on the screen */ if (iEnemyMode[Player] != NONE) if (iEnemyMode[Player] != EXPLOSION) DrawEnemy(hps, cx, cy,DRAW_INIT); else ExplodeEnemy(hps, cx, cy); /* Draw photons and asteroids in all modes but the "Enter your * * initials" mode, otherwise draw that screen. */ if (iGameMode != GAME_MODE_HIGH) { DrawPhotons(hps, cx, cy, DRAW_INIT); DrawAsteroids(hps, cx, cy, DRAW_INIT); } else DrawHighScore(hps, cx, cy, DRAW_INIT); /* Always draw the score */ DrawScore(hps, cx, cy, DRAW_INIT); return 0; /* Left mouse button down. This simulates the move/track function * * in the system menu. */ case WM_BUTTON1DOWN: if (prfProfile.bMOUSECONTROL && iGameMode != GAME_MODE_INIT1 && iGameMode != GAME_MODE_INIT2 && !TogglePause(CHECK)) { UPDATE_FIRE(iShipMode[Player], TRUE); return (MRESULT)TRUE; } return WinSendMsg(hwndFrame, WM_TRACKFRAME, (MPARAM) (SHORT1FROMMP(mp2) | TF_MOVE), MPVOID); case WM_BUTTON1UP: if (prfProfile.bMOUSECONTROL) { UPDATE_FIRE(iShipMode[Player], FALSE); return (MRESULT)TRUE; } return 0; /* Left mouse button double clicked. Toggle frame control display. */ case WM_BUTTON1DBLCLK: if (!prfProfile.bMOUSECONTROL || iGameMode == GAME_MODE_INIT1 || iGameMode == GAME_MODE_INIT2 || TogglePause(CHECK)) { if (prfProfile.bCONTROLS = !prfProfile.bCONTROLS) ShowFrameControls(); else HideFrameControls(); } return 0; case WM_BUTTON2DOWN: if (prfProfile.bMOUSECONTROL) { UPDATE_SHIELD(iShipMode[Player], iShipShieldCnt[Player]); return (MRESULT)TRUE; } return 0; case WM_BUTTON2CLICK: if (prfProfile.bMOUSECONTROL) { UPDATE_HYPERSPACE(iShipMode[Player], iShipModeCnt[Player]); return (MRESULT)TRUE; } return 0; /* Right mouse button double clicked. Display the about dialog box. */ case WM_BUTTON2DBLCLK: if (!prfProfile.bMOUSECONTROL || iGameMode == GAME_MODE_INIT1 || iGameMode == GAME_MODE_INIT2 || TogglePause(CHECK)) { WinDlgBox(HWND_DESKTOP, hwndClient, (PFNWP)AboutDlgProc, NULLHANDLE, IDD_ABOUT, NULL); } return 0; /* User typed a key. Most of this is self explanatory. */ case WM_CHAR: ProcessChar((CHAR) (CHARMSG(&msg)->vkey-1), CHARMSG(&msg)->fs & KC_VIRTUALKEY, (CHAR) (CHARMSG(&msg)->chr), (BOOL) !(CHARMSG(&msg)->fs & KC_KEYUP)); return 0; /* User entered a command via the menu bar. */ case WM_COMMAND: DoCommand(hwnd, msg, mp1, mp2); return 0; /* Suspend/un-suspend game depending on focus */ case WM_SETFOCUS: if ((BOOL) SHORT1FROMMP(mp2)) TogglePause(SUSPEND_OFF); else if (!prfProfile.bBACKGRND) TogglePause(SUSPEND_ON); return 0; /* Keep track of the client window size. Profile information is not * * updated here because there are better places (i.e. at exit) */ case WM_SIZE: cx = (INT)SHORT1FROMMP(mp2); cy = (INT)SHORT2FROMMP(mp2); /* Keep track of client window position. Also updates profile info. */ case WM_MOVE: WinQueryWindowPos(hwndFrame,&swp); if (!(swp.fl & SWP_MAXIMIZE) && !(swp.fl & SWP_MINIMIZE)) { prfProfile.x = swp.x;prfProfile.y = swp.y; prfProfile.cx = swp.cx;prfProfile.cy = swp.cy; } if (swp.fl & SWP_MINIMIZE) if (!prfProfile.bBACKGRND) { /* Set icon */ WinSendMsg(hwndFrame, WM_SETICON, (MPARAM) WinLoadPointer(HWND_DESKTOP, NULLHANDLE, ID_RESOURCE), MPVOID); TogglePause(SUSPEND_ON); } else WinSendMsg(hwndFrame, WM_SETICON, MPVOID, MPVOID); else TogglePause(SUSPEND_OFF); ptlCenter.x = swp.cx / 2; ptlCenter.y = swp.cy / 2; WinMapWindowPoints(hwndClient, HWND_DESKTOP, &ptlCenter, 1L); return 0; /* Recieved approximately 31 times a second. This is the longest and * * ugliest of the messages, partly because there are so many cases * * to keep track of, partly because it must be highly optimized. */ case WM_TIMER: if (prfProfile.bMOUSECONTROL && iGameMode != GAME_MODE_INIT1 && iGameMode != GAME_MODE_INIT2) { POINTL ptl; static BOOL bUp, bLeft, bRight; WinQueryPointerPos(HWND_DESKTOP, &ptl); if (bUp || (ptl.y - ptlCenter.y > 0)) UPDATE_THRUST(iShipMode[Player], bUp = (ptl.y - ptlCenter.y > 0)); if (bLeft || (ptlCenter.x - ptl.x > 0)) UPDATE_LEFT(iShipMode[Player], bLeft = (ptlCenter.x - ptl.x > 0)); if (bRight || (ptlCenter.x - ptl.x < 0)) UPDATE_RIGHT(iShipMode[Player], bRight = (ptlCenter.x - ptl.x < 0)); WinSetPointerPos(HWND_DESKTOP, ptlCenter.x, ptlCenter.y); } /* Determine the current game mode */ switch (iGameMode) { /* Either initialization/attract mode screen. */ case GAME_MODE_INIT1: case GAME_MODE_INIT2: /* Switch screens when count expires */ if (--iGameModeCnt == 0) { if (iGameMode == GAME_MODE_INIT1) iGameMode = GAME_MODE_INIT2; else iGameMode = GAME_MODE_INIT1; iGameModeCnt = GAME_INIT_TIME; /* Score must be redrawn because the attract mode screens * * draw the score differently. */ DrawScore(hps, cx, cy, DRAW_REINIT); } /* Update photons, asteroids, enemy, and score */ UpdatePhotons(hps, cx, cy); if (uiSpeed == SPEED_OS2 || (bSlowUpdateNow = !bSlowUpdateNow)) { UpdateAsteroids(hps, cx, cy); UpdateEnemy(hps, cx, cy); DrawScore(hps, cx, cy, DRAW_REFRESH); } break; /* Completion of one player's turn or new game */ case GAME_MODE_NEXT: /* Initially, erase and redraw everything for new player */ if (iGameModeCnt-- == GAME_PAUSE_TIME) { if ((cPlayers == MAXPLAYERS) && (Ships[(Player+1) % MAXPLAYERS])) { DrawAsteroids(hps, cx, cy, DRAW_ERASE); DrawPhotons(hps, cx, cy, DRAW_ERASE); Player = (Player+1) % MAXPLAYERS; } DrawScore(hps, cx, cy, DRAW_REINIT); DrawAsteroids(hps, cx, cy, DRAW_INIT); } /* During countdown update score and asteroids */ else if (iGameModeCnt > 0) { if (uiSpeed == SPEED_OS2 || (bSlowUpdateNow = !bSlowUpdateNow)) { DrawScore(hps, cx, cy, DRAW_REFRESH); UpdateAsteroids(hps, cx, cy); } } /* At end of countdown start the player */ else { InitShip(); InitEnemy(); iGameMode = GAME_MODE_PLAY; DrawScore(hps, cx, cy, DRAW_REINIT); } break; /* Normal play mode */ case GAME_MODE_PLAY: /* Update ship, photons, asteroids, enemy, and score */ UpdateShip(hps, cx, cy); UpdatePhotons(hps, cx, cy); if (uiSpeed == SPEED_OS2 || (bSlowUpdateNow = !bSlowUpdateNow)) { UpdateAsteroids(hps, cx, cy); UpdateEnemy(hps, cx, cy); /* Erase old and draw new scores if there is a change*/ if (bChangeScore) { bChangeScore = FALSE; DrawScore(hps, cx, cy, DRAW_REINIT); } /* Else just refresh the score */ else DrawScore(hps, cx, cy, DRAW_REFRESH); } break; /* Game over mode. This is the longest and ugliest case because * * conditions are highly dependent on the number of players, * * multiplayer game status, and the number and order of high * * scores. */ case GAME_MODE_OVER: /* Initially, just update the score and number of ships */ if (iGameModeCnt-- == GAME_PAUSE_TIME) DrawScore(hps, cx, cy, DRAW_REINIT); /* During countdown refresh the score and update the asteroids */ else if (iGameModeCnt > 0) { if (uiSpeed == SPEED_OS2 || (bSlowUpdateNow = !bSlowUpdateNow)) { DrawScore(hps, cx, cy, DRAW_REFRESH); UpdateAsteroids(hps, cx, cy); } } /* At the end of the countdown, if there are any other players, * * continue with them. */ else { /* Countinue on with any remaining players. */ if ((cPlayers == MAXPLAYERS) && (Ships[(Player+1) % MAXPLAYERS])) { /* Erase all of the old asteroids. */ DrawAsteroids(hps, cx, cy, DRAW_ERASE); /* Setup everything for the next player */ Player = (Player+1) % MAXPLAYERS; InitShip(); InitEnemy(); iGameMode = GAME_MODE_PLAY; DrawAsteroids(hps, cx, cy, DRAW_INIT); DrawScore(hps, cx, cy, DRAW_REINIT); } /* Check for new high scores and update table as necessary. */ else { /* Erase all of the old asteroids. */ DrawAsteroids(hps, cx, cy, DRAW_ERASE); /* The following if/else block is admittedly a kludge, it is * * simple and it does work, however. Ideally it should * * sort the high scores and update the high score table in * * descending order. */ /* If player 1 scored higher than player 2 then check * * player 1 first for a high score. */ if (Score[0] > Score[1]) for (Player=0;Player<cPlayers;Player++) /* If the player's score is > than the lowest, * * update the high score table. */ if (Score[Player] > prfProfile.lSCORES[9]) { UpdateHighScores(); iGameMode = GAME_MODE_HIGH; } /* Otherwise, make sure he is not asked for his * * initials. */ else Score[Player] = 0; /* Otherwise, check player 2 first */ else for (Player=cPlayers;Player>=0;Player--) /* If the player's score is > than the lowest, * * update the high score table. */ if (Score[Player] > prfProfile.lSCORES[9]) { UpdateHighScores(); iGameMode = GAME_MODE_HIGH; } /* Otherwise, make sure he is not asked for his * * initials. */ else Score[Player] = 0L; /* If there was no high score, go into attract mode */ if (iGameMode != GAME_MODE_HIGH) WinSendMsg(hwnd,WM_INITGAME,MPFROMSHORT(1),(MPARAM) 0L); /* Else, check for player 1's initials first then 2's * * This is not faithful, in the arcade game the player * * with the higher score always goes first. */ else { if (Score[0] > 0L) Player = 0; else Player = 1; DrawScore(hps, cx, cy, DRAW_REINIT); DrawHighScore(hps, cx, cy, DRAW_INIT); } } } break; /* Mode which prompts players to enter their initials */ case GAME_MODE_HIGH: /* If the player's position is > 0 then refresh the screen */ if (Score[Player] > 0L) DrawHighScore(hps, cx, cy, DRAW_REFRESH); /* Else, the current player is done go to the next */ else if ((cPlayers == MAXPLAYERS) && (Player == 0) && (Score[1] > 0L)) { Player++; DrawHighScore(hps, cx, cy, DRAW_REINIT); } /* If there are no more high scores then go into attract mode */ else WinSendMsg(hwnd, WM_INITGAME, MPFROMSHORT(1), MPVOID); break; } return 0; /* Used by help manager */ case HM_QUERY_KEYS_HELP: return((MRESULT)IDH_CLIENTKEYS); /* Recieved always from the system or in the case of an initialization* * error. Both messages will normally save the profile information.* * Ideally the profile section should be moved to a subroutine and the* * the following should be broken into two distinct cases. */ case WM_SAVEAPPLICATION: case WM_DESTROY: /* If the fonts were not found bApplicationOk will be false, in * * that case the window profile information should not be updated.*/ if (TRUE) { /* Copy window position and size info into profile structure */ WinQueryWindowPos(hwndFrame, &swp); if (swp.fl & SWP_MAXIMIZE) prfProfile.ulMINMAX = SWP_MAXIMIZE; else if (swp.fl & SWP_MINIMIZE) prfProfile.ulMINMAX = SWP_MINIMIZE; else { prfProfile.ulMINMAX = 0; prfProfile.x = swp.x;prfProfile.y = swp.y; prfProfile.cx = swp.cx;prfProfile.cy = swp.cy; } /* Write profile information */ PrfWriteProfileData(HINI_USERPROFILE, szClientClass, "Data", &prfProfile, sizeof(PROFILEREC)); } /* If the application is terminating release the fonts and the hps. */ if (msg == WM_DESTROY) { /* Make sure mouse is visible if we hid it before */ ShowMouse(TRUE); /* Release font identifiers and DLL resource module */ GpiSetCharSet(hps, LCID_DEFAULT); GpiDeleteSetId(hps, LCID_LARGE); GpiDeleteSetId(hps, LCID_SMALL); GpiUnloadFonts(hab, "ASTEROID"); /* Release the "permanent" presentation space */ WinReleasePS(hps); } return 0; } return WinDefWindowProc(hwnd, msg, mp1, mp2); }
MRESULT EXPENTRY ClientWndProc ( HWND hwndWnd, ULONG ulMsg, MPARAM mpParm1, MPARAM mpParm2 ) { switch ( ulMsg ) { // For HELP debugging #if 0 case HM_ERROR: { CHAR szTempBuffer[256]; sprintf( szTempBuffer, "Received HM_ERROR message, mp1=0X%8.8X", (ULONG)mpParm1 ); WinMessageBox ( HWND_DESKTOP, HWND_DESKTOP, szTempBuffer, "HM_ERROR", 0, MB_OK ); } break; case HM_EXT_HELP_UNDEFINED: WinMessageBox ( HWND_DESKTOP, HWND_DESKTOP, "Received HM_EXT_HELP_UNDEFINED message", "HM_EXT_HELP_UNDEFINED", 0, MB_OK ); break; case HM_HELPSUBITEM_NOT_FOUND: WinMessageBox ( HWND_DESKTOP, HWND_DESKTOP, "Received HM_HELPSUBITEM_NOT_FOUND message", "HM_HELPSUBITEM_NOT_FOUND", 0, MB_OK ); break; #endif case HM_QUERY_KEYS_HELP: return (MRESULT)IDP_KEYS_INFO; break; case WM_BUTTON1CLICK: MoveCursorToPointer( hwndWnd, (*(POINTS *)&mpParm1).x, (*(POINTS *)&mpParm1).y ); break; #if 0 case WM_BUTTON2CLICK: { HPS hpsClient; POINTL ptl; INT xC, yC; xC = ( ( (*(POINTS *)&mpParm1).x - cxChar) / cxChar ); yC = ( ( cyClient - (*(POINTS *)&mpParm1).y ) / cyChar ); hpsClient = WinGetPS( hwndWnd ); GpiSetColor( hpsClient, CLR_PALEGRAY ); if ( xC < 10 ) GpiSetMix( hpsClient, FM_XOR ); else if ( xC < 20 ) GpiSetMix( hpsClient, FM_INVERT ); else if ( xC < 30 ) GpiSetMix( hpsClient, FM_NOTXORSRC ); else if ( xC < 40 ) GpiSetMix( hpsClient, FM_NOTMASKSRC ); else if ( xC < 50 ) GpiSetMix( hpsClient, FM_SUBTRACT ); /// GpiSetBackColor( hpsClient, CLR_PALEGRAY ); /// GpiSetBackMix( hpsClient, BM_OVERPAINT ); /// ptl.x = ( ( (*(POINTS *)&mpParm1).x - cxChar ) / cxChar ) * cxChar + cxChar; /// ptl.y = ( ( (*(POINTS *)&mpParm1).y - cyClient ) / cyChar - 1 ) * cyChar + cyClient; ptl.x = cxChar + ( xC * cxChar ); ptl.y = cyClient - ( ( yC + 1) * cyChar ); GpiMove( hpsClient, &ptl ); ptl.x += cxChar; ptl.y += cyChar; if ( yC < 5 ) GpiBox( hpsClient, DRO_FILL, &ptl, 0, 0 ); else GpiBox( hpsClient, DRO_OUTLINE, &ptl, 0, 0 ); /// GpiSetBackColor( hpsClient, CLR_BACKGROUND ); /// GpiSetMix( hpsClient, FM_DEFAULT ); WinReleasePS( hpsClient ); } break; #endif case WM_CHAR: if ( !( CHARMSG(&ulMsg)->fs & KC_KEYUP ) ) { if ( CHARMSG(&ulMsg)->fs & KC_CHAR ) { ProcessCharMsg( hwndWnd, ulMsg, mpParm1, mpParm2 ); } else if ( CHARMSG(&ulMsg)->fs & KC_VIRTUALKEY ) { if ( !ProcessCursorMsg( hwndWnd, ulMsg, mpParm1, mpParm2 ) ) { return WinDefWindowProc( hwndWnd, ulMsg, mpParm1, mpParm2 ); } } } break; case WM_CLOSE: if ( QueryAbandonChanges( hwndWnd ) ) return WinDefWindowProc ( hwndWnd, ulMsg, mpParm1, mpParm2 ); break; case WM_COMMAND: return ProcessCommandMsg( hwndWnd, ulMsg, mpParm1, mpParm2 ); break; case WM_CREATE: hwndMenu = WinWindowFromID( WinQueryWindow( hwndWnd, QW_PARENT ), FID_MENU ); hwndHScroll = WinWindowFromID( WinQueryWindow( hwndWnd, QW_PARENT ), FID_HORZSCROLL ); hwndVScroll = WinWindowFromID( WinQueryWindow( hwndWnd, QW_PARENT ), FID_VERTSCROLL ); SetWindowTitle( hwndWnd ); break; case WM_DESTROY: ClearFile( hwndWnd ); break; case WM_ERASEBACKGROUND: return MRFROMSHORT ( TRUE ) ; case WM_HELP: ProcessHelpMessage( hwndWnd, mpParm1, mpParm2 ); break; case WM_HSCROLL: if ( !ProcessHScrollMsg( hwndWnd, ulMsg, mpParm1, mpParm2 ) ) return WinDefWindowProc( hwndWnd, ulMsg, mpParm1, mpParm2 ); break; case WM_PAINT: PaintScreen( hwndWnd ); break; case WM_SAVEAPPLICATION: SaveSettings( hwndWnd, habAnchor ); return WinDefWindowProc( hwndWnd, ulMsg, mpParm1, mpParm2 ); break; case WM_SETFOCUS: if ( SHORT1FROMMP( mpParm2 ) ) CreateCursor( hwndWnd ); else DestroyCursor( hwndWnd ); break; case WM_SIZE: UpdateWindowSize( hwndWnd, SHORT1FROMMP( mpParm2), SHORT2FROMMP( mpParm2 ) ); if ( hwndWnd == WinQueryFocus( HWND_DESKTOP ) ) { DestroyCursor( hwndWnd ); CreateCursor( hwndWnd ); } break; case WM_VSCROLL: if ( !ProcessVScrollMsg( hwndWnd, ulMsg, mpParm1, mpParm2 ) ) return WinDefWindowProc( hwndWnd, ulMsg, mpParm1, mpParm2 ); break; default: return WinDefWindowProc( hwndWnd, ulMsg, mpParm1, mpParm2 ); break; } return MRFROMSHORT ( FALSE ) ; }
MRESULT EXPENTRY ClientWndProc (HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) { static INT aiPuzzle[NUMROWS][NUMCOLS], iBlankRow, iBlankCol, cxSquare, cySquare ; CHAR szNum[10] ; HPS hps ; HWND hwndFrame ; INT iRow, iCol, iMouseRow, iMouseCol, i ; POINTL ptl ; RECTL rcl, rclInvalid, rclIntersect ; SIZEL sizl ; switch (msg) { case WM_CREATE: // Calculate square size in pixels hps = WinGetPS (hwnd) ; sizl.cx = sizl.cy = 0 ; GpiSetPS (hps, &sizl, PU_LOENGLISH) ; ptl.x = SQUARESIZE ; ptl.y = SQUARESIZE ; GpiConvert (hps, CVTC_PAGE, CVTC_DEVICE, 1L, &ptl) ; WinReleasePS (hps) ; cxSquare = ptl.x ; cySquare = ptl.y ; // Calculate client window size and position rcl.xLeft = (WinQuerySysValue (HWND_DESKTOP, SV_CXSCREEN) - NUMCOLS * cxSquare) / 2 ; rcl.yBottom = (WinQuerySysValue (HWND_DESKTOP, SV_CYSCREEN) - NUMROWS * cySquare) / 2 ; rcl.xRight = rcl.xLeft + NUMCOLS * cxSquare ; rcl.yTop = rcl.yBottom + NUMROWS * cySquare ; // Set frame window position and size hwndFrame = WinQueryWindow (hwnd, QW_PARENT) ; WinCalcFrameRect (hwndFrame, &rcl, FALSE) ; WinSetWindowPos (hwndFrame, NULLHANDLE, rcl.xLeft, rcl.yBottom, rcl.xRight - rcl.xLeft, rcl.yTop - rcl.yBottom, SWP_MOVE | SWP_SIZE | SWP_ACTIVATE) ; // Initialize the aiPuzzle array WinSendMsg (hwnd, WM_COMMAND, MPFROMSHORT (IDM_NORMAL), NULL) ; return 0 ; case WM_PAINT: hps = WinBeginPaint (hwnd, NULLHANDLE, &rclInvalid) ; // Draw the squares for (iRow = NUMROWS - 1 ; iRow >= 0 ; iRow--) for (iCol = 0 ; iCol < NUMCOLS ; iCol++) { rcl.xLeft = cxSquare * iCol ; rcl.yBottom = cySquare * iRow ; rcl.xRight = rcl.xLeft + cxSquare ; rcl.yTop = rcl.yBottom + cySquare ; if (!WinIntersectRect (0, &rclIntersect, &rcl, &rclInvalid)) continue ; if (iRow == iBlankRow && iCol == iBlankCol) WinFillRect (hps, &rcl, CLR_BLACK) ; else { WinDrawBorder (hps, &rcl, 5, 5, CLR_PALEGRAY, CLR_DARKGRAY, DB_STANDARD | DB_INTERIOR) ; WinDrawBorder (hps, &rcl, 2, 2, CLR_BLACK, 0L, DB_STANDARD) ; sprintf (szNum, "%d", aiPuzzle[iRow][iCol]) ; WinDrawText (hps, -1, szNum, &rcl, CLR_WHITE, CLR_DARKGRAY, DT_CENTER | DT_VCENTER) ; } } WinEndPaint (hps) ; return 0 ; case WM_BUTTON1DOWN: iMouseCol = MOUSEMSG(&msg)->x / cxSquare ; iMouseRow = MOUSEMSG(&msg)->y / cySquare ; // Check if mouse was in valid area if ( iMouseRow < 0 || iMouseCol < 0 || iMouseRow >= NUMROWS || iMouseCol >= NUMCOLS || (iMouseRow != iBlankRow && iMouseCol != iBlankCol) || (iMouseRow == iBlankRow && iMouseCol == iBlankCol)) break ; // Move a row right or left if (iMouseRow == iBlankRow) { if (iMouseCol < iBlankCol) for (iCol = iBlankCol ; iCol > iMouseCol ; iCol--) aiPuzzle[iBlankRow][iCol] = aiPuzzle[iBlankRow][iCol - 1] ; else for (iCol = iBlankCol ; iCol < iMouseCol ; iCol++) aiPuzzle[iBlankRow][iCol] = aiPuzzle[iBlankRow][iCol + 1] ; } // Move a column up or down else { if (iMouseRow < iBlankRow) for (iRow = iBlankRow ; iRow > iMouseRow ; iRow--) aiPuzzle[iRow][iBlankCol] = aiPuzzle[iRow - 1][iBlankCol] ; else for (iRow = iBlankRow ; iRow < iMouseRow ; iRow++) aiPuzzle[iRow][iBlankCol] = aiPuzzle[iRow + 1][iBlankCol] ; } // Calculate invalid rectangle rcl.xLeft = cxSquare * min (iMouseCol, iBlankCol) ; rcl.yBottom = cySquare * min (iMouseRow, iBlankRow) ; rcl.xRight = cxSquare * (max (iMouseCol, iBlankCol) + 1) ; rcl.yTop = cySquare * (max (iMouseRow, iBlankRow) + 1) ; // Set new array and blank values iBlankRow = iMouseRow ; iBlankCol = iMouseCol ; aiPuzzle[iBlankRow][iBlankCol] = 0 ; // Invalidate rectangle WinInvalidateRect (hwnd, &rcl, FALSE) ; break ; case WM_CHAR: if (!(CHARMSG(&msg)->fs & KC_VIRTUALKEY) || CHARMSG(&msg)->fs & KC_KEYUP) return 0 ; // Mimic a WM_BUTTON1DOWN message iMouseCol = iBlankCol ; iMouseRow = iBlankRow ; switch (CHARMSG(&msg)->vkey) { case VK_LEFT: iMouseCol++ ; break ; case VK_RIGHT: iMouseCol-- ; break ; case VK_UP: iMouseRow-- ; break ; case VK_DOWN: iMouseRow++ ; break ; default: return 0 ; } WinSendMsg (hwnd, WM_BUTTON1DOWN, MPFROM2SHORT (iMouseCol * cxSquare, iMouseRow * cySquare), NULL) ; return 0 ; case WM_COMMAND: switch (COMMANDMSG(&msg)->cmd) { // Initialize aiPuzzle array case IDM_NORMAL: case IDM_INVERT: for (iRow = 0 ; iRow < NUMROWS ; iRow++) for (iCol = 0 ; iCol < NUMCOLS ; iCol++) aiPuzzle[iRow][iCol] = iCol + 1 + NUMCOLS * (NUMROWS - iRow - 1) ; if (COMMANDMSG(&msg)->cmd == IDM_INVERT) { aiPuzzle[0][NUMCOLS-2] = NUMCOLS * NUMROWS - 2 ; aiPuzzle[0][NUMCOLS-3] = NUMCOLS * NUMROWS - 1 ; } aiPuzzle[iBlankRow = 0][iBlankCol = NUMCOLS - 1] = 0 ; WinInvalidateRect (hwnd, NULL, FALSE) ; return 0 ; // Randomly scramble the squares case IDM_SCRAMBLE: WinSetPointer (HWND_DESKTOP, WinQuerySysPointer ( HWND_DESKTOP, SPTR_WAIT, FALSE)) ; srand ((int) WinGetCurrentTime (0)) ; for (i = 0 ; i < SCRAMBLEREP ; i++) { WinSendMsg (hwnd, WM_BUTTON1DOWN, MPFROM2SHORT (rand() % NUMCOLS * cxSquare, iBlankRow * cySquare), NULL) ; WinUpdateWindow (hwnd) ; WinSendMsg (hwnd, WM_BUTTON1DOWN, MPFROM2SHORT (iBlankCol * cxSquare, rand() % NUMROWS * cySquare), NULL) ; WinUpdateWindow (hwnd) ; } WinSetPointer (HWND_DESKTOP, WinQuerySysPointer ( HWND_DESKTOP, SPTR_ARROW, FALSE)); return 0 ; } break ; } return WinDefWindowProc (hwnd, msg, mp1, mp2) ; }
/* * * BrowseWndProc * * DESCRIPTION: * * Processes messages for the Browse-O-Matic client window. * */ MRESULT EXPENTRY BrowseWndProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) { switch( msg){ case WM_CREATE: { CHAR pszTitle[ MAX_TITLE_LENGTH]; PBROWSEDATA pWindowData; pWindowData = (PBROWSEDATA)mp1; WinSetWindowPtr( hwnd, QWL_USER, pWindowData); /*******************/ /* Load the object */ /*******************/ _LoadObject( pWindowData->somSelf, pWindowData->pszObjectName, &pWindowData->ulFileLength, &pWindowData->pBuffer, &pWindowData->pLines, &pWindowData->usNumberOfTextLines, &pWindowData->usNumberOfTextColumns); _GetLinesAndColumns( pWindowData->somSelf, pWindowData->bDisplay, &pWindowData->sTotalLines, &pWindowData->sTotalColumns, pWindowData->usNumberOfTextLines, pWindowData->usNumberOfTextColumns, pWindowData->ulFileLength); /*********************************************/ /* Get the window handle for the scroll bars */ /*********************************************/ pWindowData->hwndVscroll = WinWindowFromID( WinQueryWindow( hwnd, QW_PARENT), FID_VERTSCROLL); pWindowData->hwndHscroll = WinWindowFromID( WinQueryWindow( hwnd, QW_PARENT), FID_HORZSCROLL); /*************************/ /* Save font information */ /*************************/ WinSendMsg( hwnd, IDL_SETFONTINFO, (MPARAM)0, (MPARAM)0); /*****************/ /* Get the focus */ /*****************/ WinSetFocus( HWND_DESKTOP, hwnd); /*****************************************************/ /* Create the title for the Browse-O-Matic title bar */ /*****************************************************/ if( pWindowData->bDisplay == PMBROWSE_HEX_DISPLAY_MODE) sprintf( pszTitle, "Object: %s (%d Bytes)", pWindowData->pszObjectName, pWindowData->ulFileLength); else sprintf( pszTitle, "Object: %s (%hd Lines)", pWindowData->pszObjectName, pWindowData->sTotalLines); /************************************************/ /* Register the current open view of the object */ /************************************************/ _wpAddToObjUseList( pWindowData->somSelf, &(pWindowData->UseItem)); _wpRegisterView( pWindowData->somSelf, WinQueryWindow( hwnd, QW_PARENT), pszTitle); } break; case WM_CLOSE: { HWND hwndFrame; PBROWSEDATA pWindowData; pWindowData = (PBROWSEDATA) WinQueryWindowPtr( hwnd, QWL_USER); hwndFrame = WinQueryWindow( hwnd, QW_PARENT); /*****************************************************/ /* Save the window info - size, location, and fonts. */ /*****************************************************/ WinStoreWindowPos( APPL_NAME, pWindowData->pszApplKey, hwndFrame); /**********************************************************/ /* Free the window data and unload the file system object */ /**********************************************************/ if( pWindowData){ if( pWindowData->pszObjectName) _wpFreeMem( pWindowData->somSelf, ( PBYTE)pWindowData->pszObjectName); _wpFreeMem( pWindowData->somSelf, ( PBYTE)pWindowData); } _UnloadObject( pWindowData->somSelf, pWindowData->pBuffer, pWindowData->pLines); _wpDeleteFromObjUseList( pWindowData->somSelf, &pWindowData->UseItem); /*******************/ /* Kill the window */ /*******************/ WinPostMsg( hwnd, WM_QUIT, 0, 0 ); WinDestroyWindow( hwndFrame); } break; /*******************************************************************/ /* The font characteristics have changed. This happens when a font */ /* from the font palette is dropped on the client window. */ /*******************************************************************/ case WM_PRESPARAMCHANGED: { PBROWSEDATA pWindowData; pWindowData = (PBROWSEDATA) WinQueryWindowPtr( hwnd, QWL_USER); if( (ULONG)mp1 == PP_FONTNAMESIZE){ /***********************************************/ /* Get the new font information and redraw the */ /* window with the new font/font size. */ /***********************************************/ WinSendMsg( hwnd, IDL_SETFONTINFO, (MPARAM)0, (MPARAM)0); WinSendMsg( hwnd, WM_SIZE, 0, MPFROM2SHORT( pWindowData->sClientWidth, pWindowData->sClientHeight)); } } break; case WM_SIZE: { PBROWSEDATA pWindowData; pWindowData = (PBROWSEDATA) WinQueryWindowPtr( hwnd, QWL_USER); /***************************************/ /* Save client window size information */ /***************************************/ pWindowData->sClientWidth = SHORT1FROMMP( mp2); pWindowData->sClientHeight = SHORT2FROMMP( mp2); pWindowData->sPageHeight = pWindowData->sClientHeight/ pWindowData->sCharHeight; pWindowData->sPageWidth = pWindowData->sClientWidth / pWindowData->sCharWidth; /**************************************/ /* Set the ranges for the scroll bars */ /**************************************/ WinPostMsg( pWindowData->hwndVscroll, SBM_SETSCROLLBAR, (MPARAM)pWindowData->sCurrentLine, MPFROM2SHORT( 0, pWindowData->sTotalLines - pWindowData->sPageHeight)); WinPostMsg( pWindowData->hwndHscroll, SBM_SETSCROLLBAR, (MPARAM)pWindowData->sCurrentColumn, MPFROM2SHORT( 0, pWindowData->sTotalColumns - pWindowData->sPageWidth)); /*************************************/ /* Set scroll bar thumb control size */ /*************************************/ WinPostMsg( pWindowData->hwndVscroll, SBM_SETTHUMBSIZE, MPFROM2SHORT( pWindowData->sPageHeight, pWindowData->sTotalLines), (MPARAM) 0); WinPostMsg( pWindowData->hwndHscroll, SBM_SETTHUMBSIZE, MPFROM2SHORT( pWindowData->sPageWidth, pWindowData->sTotalColumns), (MPARAM) 0); /************************************************************/ /* If the all the lines and/or columns can fit in the new */ /* sized window, set the sCurrentLine and/or sCurrentColumn */ /* to the top/right side. */ /************************************************************/ if( pWindowData->sPageHeight >= pWindowData->sTotalLines) pWindowData->sCurrentLine = 0; if( pWindowData->sPageWidth >= pWindowData->sTotalColumns) pWindowData->sCurrentColumn = 0; /********************************************/ /* Repaint window with new size information */ /********************************************/ WinInvalidateRect( hwnd, NULL, FALSE); } return( 0); case WM_PAINT: { HPS hps; CHAR pszText[255]; UINT nLength = 0; RECTL rect; POINTL point; SHORT sLine; SHORT sTopLine; SHORT sBottomLine; SHORT sLinesFromTop; PBROWSEDATA pWindowData; pWindowData = (PBROWSEDATA) WinQueryWindowPtr( hwnd, QWL_USER); hps = WinBeginPaint( hwnd, NULLHANDLE, &rect); /*******************************************/ /* Clear the area that needs to be redrawn */ /*******************************************/ GpiErase( hps); /********************************/ /* Determine first clipped line */ /********************************/ sLinesFromTop = ( pWindowData->sClientHeight - rect.yTop) / pWindowData->sCharHeight; rect.yTop = pWindowData->sClientHeight - ( pWindowData->sCharHeight * sLinesFromTop); /***************************************************************/ /* Determine the first position to write at. NOTE: PM handles */ /* clipping for point.x < 0. Any characters written before the */ /* the first column or after the last column are clipped. */ /***************************************************************/ point.y = rect.yTop - pWindowData->sCharHeight + pWindowData->sCharDescender; point.x = pWindowData->sCurrentColumn*pWindowData->sCharWidth * -1; /***********************************************/ /* Determine the top and bottom lines to write */ /***********************************************/ sTopLine = rect.yTop / pWindowData->sCharHeight; sBottomLine = rect.yBottom / pWindowData->sCharHeight; /*********************************************************/ /* Make sure that we aren't trying to display more lines */ /* then are available. */ /*********************************************************/ if( pWindowData->sPageHeight - sBottomLine + 1 > pWindowData->sTotalLines - pWindowData->sCurrentLine) sBottomLine=pWindowData->sPageHeight-(pWindowData->sTotalLines - pWindowData->sCurrentLine) + 1; /********************************/ /* Redraw the invalid rectangle */ /********************************/ for( sLine = sTopLine; sLine >= sBottomLine; sLine--){ /*******************************************/ /* Get the line of text or hex information */ /* that we are going to write. */ /*******************************************/ if( pWindowData->bDisplay == PMBROWSE_HEX_DISPLAY_MODE) nLength = _GetHexLine( pWindowData->somSelf, pWindowData->sPageHeight-sLine+pWindowData->sCurrentLine +1, pWindowData->pBuffer, pWindowData->ulFileLength, pszText); else nLength = _GetTextLine( pWindowData->somSelf, pWindowData->sPageHeight-sLine+pWindowData->sCurrentLine +1, pWindowData->pLines, pszText); /******************/ /* Write the text */ /******************/ if( nLength != 0) GpiCharStringAt( hps, &point, nLength, pszText); point.y -= pWindowData->sCharHeight; } WinEndPaint( hps); } return( 0); /*******************************************/ /* Keyboard support for scrolling and help */ /*******************************************/ case WM_CHAR: /****************************************/ /* Show general help if user selects F1 */ /****************************************/ if( CHARMSG( &msg)->vkey == VK_F1){ PBROWSEDATA pWindowData; pWindowData = (PBROWSEDATA) WinQueryWindowPtr(hwnd,QWL_USER); _wpDisplayHelp( pWindowData->somSelf, PANEL_MAIN, "browse.hlp"); return 0; } if( (CHARMSG( &msg)->fs & KC_KEYUP)) return 0; switch( CHARMSG( &msg)->vkey){ case VK_UP: WinPostMsg( hwnd, WM_VSCROLL, 0, MPFROM2SHORT( 0, SB_LINEUP)); return 0; case VK_DOWN: WinPostMsg( hwnd, WM_VSCROLL, 0, MPFROM2SHORT( 0, SB_LINEDOWN)); return 0; case VK_RIGHT: /************************************************************/ /* Ctrl-Right scrolls one page to the right. Right scrolls */ /* to the right. */ /************************************************************/ if( (CHARMSG( &msg)->fs & KC_CTRL)) WinPostMsg( hwnd, WM_HSCROLL, 0, MPFROM2SHORT(0, SB_PAGERIGHT)); else WinPostMsg( hwnd, WM_HSCROLL, 0, MPFROM2SHORT(0, SB_LINERIGHT)); return 0; case VK_LEFT: /*********************************************************/ /* Ctrl-Left scrolls one page to the left. Left scrolls */ /* to the Left. */ /*********************************************************/ if( (CHARMSG( &msg)->fs & KC_CTRL)) WinPostMsg( hwnd, WM_HSCROLL, 0, MPFROM2SHORT( 0, SB_PAGELEFT)); else WinPostMsg( hwnd, WM_HSCROLL, 0, MPFROM2SHORT( 0, SB_LINELEFT)); return 0; case VK_PAGEUP: WinPostMsg( hwnd, WM_VSCROLL, 0, MPFROM2SHORT( 0, SB_PAGEUP)); return 0; case VK_PAGEDOWN: WinPostMsg( hwnd, WM_VSCROLL, 0, MPFROM2SHORT( 0, SB_PAGEDOWN)); return 0; case VK_HOME: { PBROWSEDATA pWindowData; pWindowData = (PBROWSEDATA) WinQueryWindowPtr(hwnd,QWL_USER); /*********************************************************/ /* Ctrl-Home positions at the first line, Home positions */ /* at the beginning of the current line. */ /*********************************************************/ if( (CHARMSG( &msg)->fs & KC_CTRL)){ WinPostMsg( hwnd, WM_VSCROLL, (MPARAM)0, MPFROM2SHORT( 0, SB_SLIDERPOSITION)); WinPostMsg( pWindowData->hwndVscroll, SBM_SETPOS, MPFROMSHORT( 0), 0); } else{ WinPostMsg( hwnd, WM_HSCROLL, (MPARAM)0, MPFROM2SHORT( 0, SB_SLIDERPOSITION)); WinPostMsg( pWindowData->hwndHscroll, SBM_SETPOS, MPFROMSHORT( 0), 0); } return 0; } case VK_END: { PBROWSEDATA pWindowData; pWindowData = (PBROWSEDATA) WinQueryWindowPtr(hwnd,QWL_USER); /*********************************************************/ /* Ctrl-End positions at the last line, End positions at */ /* the end of the current line. */ /*********************************************************/ if( (CHARMSG( &msg)->fs & KC_CTRL)){ WinPostMsg( hwnd, WM_VSCROLL, (MPARAM)0, MPFROM2SHORT( pWindowData->sTotalLines - pWindowData->sPageHeight, SB_SLIDERPOSITION)); WinPostMsg( pWindowData->hwndVscroll, SBM_SETPOS, MPFROMSHORT( pWindowData->sTotalLines - pWindowData->sPageHeight), 0); } else{ WinPostMsg( hwnd, WM_HSCROLL, (MPARAM)0, MPFROM2SHORT( pWindowData->sTotalColumns - pWindowData->sPageWidth, SB_SLIDERPOSITION)); WinPostMsg( pWindowData->hwndHscroll, SBM_SETPOS, MPFROMSHORT( pWindowData->sTotalColumns - pWindowData->sPageWidth), 0); } return 0; } } break; /******************/ /* Scroll Up/Down */ /******************/ case WM_VSCROLL: { PBROWSEDATA pWindowData; pWindowData = (PBROWSEDATA) WinQueryWindowPtr(hwnd,QWL_USER); switch( SHORT2FROMMP( mp2)){ case SB_LINEUP: if( pWindowData->sCurrentLine > 0){ pWindowData->sCurrentLine--; WinPostMsg( pWindowData->hwndVscroll, SBM_SETPOS, (MPARAM)pWindowData->sCurrentLine, 0); WinScrollWindow( hwnd, 0, pWindowData->sCharHeight * -1, NULL, NULL, NULLHANDLE, NULL, SW_INVALIDATERGN); } return( 0); case SB_LINEDOWN: if( pWindowData->sCurrentLine < pWindowData->sTotalLines - pWindowData->sPageHeight){ pWindowData->sCurrentLine++; WinPostMsg( pWindowData->hwndVscroll, SBM_SETPOS, (MPARAM)pWindowData->sCurrentLine, 0); WinScrollWindow( hwnd, 0, pWindowData->sCharHeight, NULL, NULL, NULLHANDLE, NULL, SW_INVALIDATERGN); } return( 0); case SB_PAGEUP: if( pWindowData->sCurrentLine > 0){ pWindowData->sCurrentLine = max( 0, pWindowData->sCurrentLine - pWindowData->sPageHeight); WinPostMsg( pWindowData->hwndVscroll, SBM_SETPOS, (MPARAM)pWindowData->sCurrentLine,0); WinInvalidateRect( hwnd, NULL, FALSE); } return( 0); case SB_PAGEDOWN: if( pWindowData->sCurrentLine < pWindowData->sTotalLines - pWindowData->sPageHeight){ pWindowData->sCurrentLine= min( pWindowData->sTotalLines - pWindowData->sPageHeight, pWindowData->sCurrentLine + pWindowData->sPageHeight); WinPostMsg( pWindowData->hwndVscroll, SBM_SETPOS, (MPARAM)pWindowData->sCurrentLine,0); WinInvalidateRect( hwnd, NULL, FALSE); } return( 0); case SB_SLIDERPOSITION: /***********************************************************/ /* Can't change current line if all the text fits in the */ /* window. */ /***********************************************************/ if( pWindowData->sTotalLines > pWindowData->sPageHeight){ pWindowData->sCurrentLine = SHORT1FROMMP( mp2); WinInvalidateRect( hwnd, NULL, FALSE); } return( 0); } } break; /*********************/ /* Scroll Right/Left */ /*********************/ case WM_HSCROLL: { PBROWSEDATA pWindowData; pWindowData = ( PBROWSEDATA)WinQueryWindowPtr( hwnd, QWL_USER); switch( SHORT2FROMMP( mp2)){ case SB_LINELEFT: if( pWindowData->sCurrentColumn > 0){ pWindowData->sCurrentColumn = max( 0, pWindowData->sCurrentColumn - 1); WinPostMsg( pWindowData->hwndHscroll, SBM_SETPOS, (MPARAM)pWindowData->sCurrentColumn,0); WinScrollWindow( hwnd, pWindowData->sCharWidth, 0, NULL, NULL, NULLHANDLE, NULL, SW_INVALIDATERGN); } return( 0); case SB_LINERIGHT: if(pWindowData->sCurrentColumn < pWindowData->sTotalColumns - pWindowData->sPageWidth){ pWindowData->sCurrentColumn=min(pWindowData->sTotalColumns, pWindowData->sCurrentColumn + 1); WinPostMsg( pWindowData->hwndHscroll, SBM_SETPOS, (MPARAM)pWindowData->sCurrentColumn, 0); WinScrollWindow( hwnd, pWindowData->sCharWidth * -1, 0, NULL, NULL, NULLHANDLE, NULL, SW_INVALIDATERGN); } return( 0); case SB_PAGELEFT: if( pWindowData->sCurrentColumn > 0){ pWindowData->sCurrentColumn = max( 0, pWindowData->sCurrentColumn - pWindowData->sPageWidth); WinPostMsg( pWindowData->hwndHscroll, SBM_SETPOS, (MPARAM)pWindowData->sCurrentColumn, 0); WinInvalidateRect( hwnd, NULL, FALSE); } return( 0); case SB_PAGERIGHT: if(pWindowData->sCurrentColumn < pWindowData->sTotalColumns - pWindowData->sPageWidth){ pWindowData->sCurrentColumn=min(pWindowData->sTotalColumns - pWindowData->sPageWidth, pWindowData->sCurrentColumn + pWindowData->sPageWidth); WinPostMsg( pWindowData->hwndHscroll, SBM_SETPOS, (MPARAM)pWindowData->sCurrentColumn, 0); WinInvalidateRect( hwnd, NULL, FALSE); } return( 0); case SB_SLIDERPOSITION: /***********************************************************/ /* Can't change current column if all the text fits in the */ /* window. */ /***********************************************************/ if( pWindowData->sTotalColumns > pWindowData->sPageWidth){ pWindowData->sCurrentColumn = SHORT1FROMMP( mp2); WinInvalidateRect( hwnd, NULL, FALSE); } return( 0); } } break; /*****************************/ /* Get font size information */ /*****************************/ case IDL_SETFONTINFO: { HPS hps; FONTMETRICS fm; PBROWSEDATA pWindowData; pWindowData = ( PBROWSEDATA)WinQueryWindowPtr( hwnd, QWL_USER); hps = WinGetPS( hwnd); GpiQueryFontMetrics( hps, sizeof( fm), &fm); WinReleasePS( hps); /***********************************************************/ /* The character width is average of the average uppercase */ /* and average lower case widths. */ /***********************************************************/ pWindowData->sCharWidth = (SHORT)fm.lMaxCharInc; pWindowData->sCharHeight = (SHORT)fm.lMaxBaselineExt; pWindowData->sCharDescender = (SHORT)fm.lMaxDescender; } return( 0); /*********************************************/ /* Display no help available message to user */ /*********************************************/ case HM_HELPSUBITEM_NOT_FOUND: return( ( MRESULT)FALSE); /**************************************/ /* Return name of help for keys panel */ /**************************************/ case HM_QUERY_KEYS_HELP: return( ( MRESULT)PANEL_HELPKEYS); } /********************************************************/ /* Let the default window procedure process the message */ /********************************************************/ return( WinDefWindowProc( hwnd, msg, mp1, mp2)); }
MRESULT EXPENTRY ROPsTestWndProc(HWND hWnd, ULONG msg, MPARAM mp1, MPARAM mp2) { CHAR szTitle[300]; /* Title Bar Text */ HPS hPS; /* Presentation Space Handle */ LONG lClrBack; /* Colour Holder */ LONG lClrFore; /* Colour Holder */ LONG lScrollInc;/* Scroll Increment */ PBITMAPARRAYFILEHEADER pbafh; /* Bitmap Array File Header Pointer */ PBITMAPARRAYFILEHEADER2 pbafh2; /* Bitmap Array File Header Pointer */ PBITMAPFILEHEADER pbfh; /* Bitmap File Header Pointer */ PBITMAPFILEHEADER2 pbfh2; /* Bitmap File Header Pointer */ PBITMAPINFO pbmi; /* Bitmap Info Pointer */ PBITMAPINFO2 pbmi2; /* Bitmap Info Pointer */ POINTL ptl; /* Pointer Position */ RECTL rcl; /* Window Rectangle */ register INT i; /* Index */ switch ( msg ) { /************************************************************************/ /* Window being created, perform window initialization */ /************************************************************************/ case WM_CREATE : hptrWait = WinQuerySysPointer(HWND_DESKTOP, SPTR_WAIT, FALSE); hptrArrow = WinQuerySysPointer(HWND_DESKTOP, SPTR_ARROW, FALSE); cxScreen = WinQuerySysValue(HWND_DESKTOP, SV_CXSCREEN); hmenuROPs = WinWindowFromID(WinQueryWindow(hWnd, QW_PARENT), FID_MENU); hwndHScroll = WinWindowFromID(WinQueryWindow(hWnd, QW_PARENT), FID_HORZSCROLL); hwndVScroll = WinWindowFromID(WinQueryWindow(hWnd, QW_PARENT), FID_VERTSCROLL); /************************************************/ /* PDSGetTemplate is used to allow controls in */ /* windows. Do not remove this function if you */ /* intend to include controls within the window.*/ /************************************************/ PDSGetTemplate(hWnd, WIN_ROPSTEST); break; /************************************************************************/ /* Window being sized */ /************************************************************************/ case WM_SIZE : if ( cBitmaps ) SizeBitmapStack(hWnd); WinQueryWindowRect(hWnd, &rcl); if ( (lHorzRange = cxROP - (cxWindow = rcl.xRight - rcl.xLeft)) < 0L ) { lHorzRange = 0L; rclROP.xLeft = 0L; rclROP.xRight = cxROP; } else rclROP.xRight = rclROP.xLeft + cxWindow; if ( (lVertRange = cyROP - (cyWindow = rcl.yTop - rcl.yBottom)) < 0L ) { lVertRange = 0L; rclROP.yBottom = 0L; rclROP.yTop = cyROP; } else rclROP.yBottom = (rclROP.yTop = cyROP - lVertPos) - cyWindow; WinSendMsg(hwndVScroll, SBM_SETSCROLLBAR, MPFROMSHORT(lVertPos), MPFROM2SHORT(0, lVertRange)); WinSendMsg(hwndVScroll, SBM_SETTHUMBSIZE, MPFROM2SHORT(cyWindow, cyROP), 0L); WinSendMsg(hwndHScroll, SBM_SETSCROLLBAR, MPFROMSHORT(lHorzPos), MPFROM2SHORT(0, lHorzRange)); WinSendMsg(hwndHScroll, SBM_SETTHUMBSIZE, MPFROM2SHORT(cxWindow, cxROP), 0L); WinInvalidateRect(hWnd, NULL, FALSE); break; /************************************************************************/ /* Perform menu initialization */ /************************************************************************/ case WM_INITMENU : switch ( SHORT1FROMMP(mp1) ) { case IDM_DISPLAY : WinSendMsg(hmenuROPs, MM_SETITEMATTR, MPFROM2SHORT(IDM_BITMAPARRAY, TRUE), MPFROM2SHORT(MIA_CHECKED, fBitmapArray ? MIA_CHECKED : 0)); WinSendMsg(hmenuROPs, MM_SETITEMATTR, MPFROM2SHORT(IDM_ROPARRAY, TRUE), MPFROM2SHORT(MIA_CHECKED, fBitmapArray ? 0 : MIA_CHECKED)); break; case IDM_FILE : break; } break; /************************************************************************/ /* Process key press from keyboard */ /************************************************************************/ case WM_CHAR : if ( CHARMSG(&msg)->fs & KC_VIRTUALKEY ) switch ( CHARMSG(&msg)->vkey ) { case VK_PAGEUP : WinSendMsg(hWnd, WM_VSCROLL, MPFROMSHORT(FID_VERTSCROLL), MPFROM2SHORT(0, SB_PAGEUP)); return(0L); case VK_PAGEDOWN : WinSendMsg(hWnd, WM_VSCROLL, MPFROMSHORT(FID_VERTSCROLL), MPFROM2SHORT(0, SB_PAGEDOWN)); return(0L); } /************************************************/ /* PDSKeyProc is used to allow controls in */ /* windows. Do not remove this function if you */ /* intend to include controls within the window.*/ /************************************************/ return(PDSKeyProc(hWnd, msg, mp1, mp2)); /************************************************************************/ /* Button 2 being depressed */ /************************************************************************/ case WM_BUTTON2DOWN : if ( !fBitmapArray && hbmROP ) { lHorzPos = SHORT1FROMMR(WinSendMsg(hwndHScroll, SBM_QUERYPOS, 0L, 0L)); lVertPos = SHORT1FROMMR(WinSendMsg(hwndVScroll, SBM_QUERYPOS, 0L, 0L)); lRop = (lVertPos + (cyWindow - SHORT2FROMMP(mp1))) / cyImage * 16 + (lHorzPos + SHORT1FROMMP(mp1)) / cxImage; WinDlgBox(HWND_DESKTOP, hwndROPsFrame, (PFNWP)ViewROPDlgProc, (HMODULE)NULL, DLG_VIEWROP, NULL); } break; /************************************************************************/ /* Process vertical scroll requests */ /************************************************************************/ case WM_VSCROLL : lVertPos = SHORT1FROMMR(WinSendMsg(hwndVScroll, SBM_QUERYPOS, 0L, 0L)); switch ( HIUSHORT(mp2) ) { case SB_LINEUP : lScrollInc = -cyImage; break; case SB_LINEDOWN : lScrollInc = cyImage; break; case SB_PAGEUP : lScrollInc = -cyWindow; break; case SB_PAGEDOWN : lScrollInc = cyWindow; break; case SB_SLIDERPOSITION : case SB_SLIDERTRACK : lScrollInc = SHORT1FROMMP(mp2) - lVertPos; break; default : return(0L); } if ( lScrollInc = max(-lVertPos, min(lScrollInc, lVertRange - lVertPos)) ) { rclROP.yBottom = (rclROP.yTop = cyROP - (lVertPos += lScrollInc)) - cyWindow; WinInvalidateRect(hWnd, NULL, FALSE); WinSendMsg(hwndVScroll, SBM_SETPOS, MPFROM2SHORT(lVertPos, 0), 0L); } break; /************************************************************************/ /* Process horizontal scroll requests */ /************************************************************************/ case WM_HSCROLL : lHorzPos = SHORT1FROMMR(WinSendMsg(hwndHScroll, SBM_QUERYPOS, 0L, 0L)); switch ( HIUSHORT(mp2) ) { case SB_LINELEFT : lScrollInc = -cxImage; break; case SB_LINERIGHT : lScrollInc = cxImage; break; case SB_PAGELEFT : lScrollInc = -cxWindow; break; case SB_PAGERIGHT : lScrollInc = cxWindow; break; case SB_SLIDERPOSITION : case SB_SLIDERTRACK : lScrollInc = SHORT1FROMMP(mp2) - lHorzPos; break; default : return(0L); } if ( lScrollInc = max(-lHorzPos, min(lScrollInc, lHorzRange - lHorzPos)) ) { rclROP.xRight = (rclROP.xLeft = (lHorzPos += lScrollInc)) + cxWindow; WinInvalidateRect(hWnd, NULL, FALSE); WinSendMsg(hwndHScroll, SBM_SETPOS, MPFROM2SHORT(lHorzPos, 0), 0L); } break; /************************************************************************/ /* Process control selections */ /************************************************************************/ case WM_CONTROL : switch ( SHORT2FROMMP(mp1) ) { } break; /************************************************************************/ /* Process menu and button selections */ /************************************************************************/ case WM_COMMAND : switch ( SHORT1FROMMP(mp1) ) { case IDM_OPTIONS : if ( WinDlgBox(HWND_DESKTOP, hwndROPsFrame, (PFNWP)OptionsDlgProc, (HMODULE)NULL, DLG_OPTIONS, NULL) ) { WinSetPointer(HWND_DESKTOP, hptrWait); CreateROPBitmap(hWnd); WinInvalidateRect(hWnd, NULL, FALSE); WinSetPointer(HWND_DESKTOP, hptrArrow); } break; case IDM_OPEN : if ( WinDlgBox(HWND_DESKTOP, hwndROPsFrame, (PFNWP)OpenBitmapDlgProc, (HMODULE)NULL, DLG_OPENBITMAP, NULL) ) { WinSetPointer(HWND_DESKTOP, hptrWait); hbmView = hbmGetBitmap(szBitmapFile); SizeBitmap(hWnd); if ( cBitmaps ) SizeBitmapStack(hWnd); CreateROPBitmap(hWnd); WinInvalidateRect(hWnd, NULL, FALSE); strcat(memcpy(szTitle, "Bitmap Viewer - ", 17), szBitmapFile); if ( fWindowsBitmap ) strcat(szTitle, " [Windows 3.x format]"); else if ( f20Bitmap ) strcat(szTitle, " [OS/2 2.x format]"); else strcat(szTitle, " [OS/2 1.x format]"); WinSetWindowText(hwndROPsFrame, szTitle); WinSetPointer(HWND_DESKTOP, hptrArrow); } break; case IDM_ROPARRAY : fBitmapArray = FALSE; WinInvalidateRect(hWnd, NULL, FALSE); break; case IDM_BITMAPARRAY : fBitmapArray = TRUE; WinInvalidateRect(hWnd, NULL, FALSE); break; } break; /************************************************************************/ /* Erase window background */ /************************************************************************/ case WM_ERASEBACKGROUND : WinQueryWindowRect(hWnd, &rcl); WinFillRect((HPS)LONGFROMMP(mp1), &rcl, CLR_PALEGRAY); break; /************************************************************************/ /* Paint client window */ /************************************************************************/ case WM_PAINT : GpiCreateLogColorTable(hPS = WinBeginPaint(hWnd, (HPS)NULL, &rcl), 0UL, LCOLF_RGB, 0L, 0L, (PLONG)NULL); /* Display the bitmap array images side-by-side */ if ( fBitmapArray ) { WinFillRect(hPS, &rcl, RGBCLR_PALEGRAY); for ( i = 0; i < cBitmaps; i++ ) { /* Check to see if the image is a 2-colour which */ /* menas that the colours have to be set */ /* explicitely */ if ( abm[i].cColours == 2L ) { lClrBack = lClrFore = 0L; /* Check to see if a 2.x format bitmap since the */ /* the structures are slightly different */ if ( f20Bitmap ) { /* Locate the bitmap information structure */ if ( (cBitmaps == 1) && !fBitmapArray ) { pbfh2 = (PBITMAPFILEHEADER2)abm[i].pb; pbmi2 = (PBITMAPINFO2)&pbfh2->bmp2; } else { pbafh2 = (PBITMAPARRAYFILEHEADER2)abm[i].pb; pbmi2 = (PBITMAPINFO2)&pbafh2->bfh2.bmp2; } /* Transfer the RGB info to the colour */ /* holders */ memcpy(&lClrBack, &pbmi2->argbColor[0], 3); memcpy(&lClrFore, &pbmi2->argbColor[1], 3); } else { /* Locate the bitmap information structure */ if ( (cBitmaps == 1) && !fBitmapArray ) { pbfh = (PBITMAPFILEHEADER)abm[i].pb; pbmi = (PBITMAPINFO)&pbfh->bmp; } else { pbafh = (PBITMAPARRAYFILEHEADER)abm[i].pb; pbmi = (PBITMAPINFO)&pbafh->bfh.bmp; } /* Transfer the RGB info to the colour */ /* holders */ memcpy(&lClrBack, &pbmi->argbColor[0], 3); memcpy(&lClrFore, &pbmi->argbColor[1], 3); } /* Draw the 2-colour bitmap using the */ /* provided colours from the bitmap */ WinDrawBitmap(hPS, abm[i].hbm, (PRECTL)NULL, (PPOINTL)(PVOID)&abm[i].rclDest, lClrFore, lClrBack, DBM_NORMAL); } else /* Draw the bitmap from the array */ WinDrawBitmap(hPS, abm[i].hbm, (PRECTL)NULL, (PPOINTL)(PVOID)&abm[i].rclDest, RGB_WHITE, RGB_BLACK, DBM_NORMAL); /* Draw the 3-D frame around the image */ GpiSetColor(hPS, RGBCLR_SHADOW); GpiMove(hPS, &abm[i].aptlArea[7]); GpiPolyLine(hPS, 2L, &abm[i].aptlArea[4]); GpiSetColor(hPS, RGB_WHITE); GpiPolyLine(hPS, 2L, &abm[i].aptlArea[6]); GpiSetColor(hPS, RGB_BLACK); GpiMove(hPS, &abm[i].aptlArea[3]); GpiPolyLine(hPS, 2L, &abm[i].aptlArea[0]); GpiSetColor(hPS, RGBCLR_PALEGRAY); GpiPolyLine(hPS, 2L, &abm[i].aptlArea[2]); } } else { if ( (rclROP.xRight < cxWindow) || (rclROP.yTop < cyWindow) ) WinFillRect(hPS, &rcl, RGBCLR_PALEGRAY); ptl.x = ptl.y = 0L; WinDrawBitmap(hPS, hbmROP, &rclROP, &ptl, 0L, 0L, DBM_NORMAL); } WinEndPaint(hPS); break; /************************************************************************/ /* Window being destroyed, perform clean-up operations */ /************************************************************************/ case WM_DESTROY : for ( i = 0; i < cBitmaps; i++ ) GpiDeleteBitmap(abm[i].hbm); if ( hbmROP ) GpiDeleteBitmap(hbmROP); if ( pb ) free(pb); break; /* Default message processing */ default : return(WinDefWindowProc(hWnd, msg, mp1, mp2)); } return(0L); }
MRESULT _System MainWndProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) { switch (msg) { case WM_INITDLG: InitDlg( hwnd); break; case WM_COMMAND: if ((USHORT)mp1 == IDC_OK) Run( hwnd); else if ((USHORT)mp1 == IDC_CLEAR) ClearDlg( hwnd); break; case WM_CONTROL: if (SHORT2FROMMP( mp1) != CBN_LBSELECT) break; switch (SHORT1FROMMP( mp1)) { case IDC_PROCTYPE: SwitchTypeLists( hwnd, (HWND)mp2); break; case IDC_ARG1TYPE: case IDC_ARG2TYPE: case IDC_ARG3TYPE: case IDC_ARG4TYPE: case IDC_ARG5TYPE: case IDC_ARG6TYPE: SetXDS( hwnd, (HWND)mp2, SHORT1FROMMP( mp1)); break; } break; case WM_CHAR: // defeat default button action if (((CHARMSG(&msg)->fs & (USHORT)KC_VIRTUALKEY) && CHARMSG(&msg)->vkey == VK_ENTER) || ((CHARMSG(&msg)->fs & (USHORT)KC_CHAR) && CHARMSG(&msg)->chr == '\r')) break; return (WinDefDlgProc( hwnd, msg, mp1, mp2)); case WM_CLOSE: WinPostMsg( hwnd, WM_QUIT, NULL, NULL); break; case WM_DESTROY: if (RwsClientTerminate()) printf( "\r\nRwsClientTerminate failed\r\n"); return (WinDefDlgProc( hwnd, msg, mp1, mp2)); default: return (WinDefDlgProc( hwnd, msg, mp1, mp2)); } //end switch (msg) return (0); }