BOOL EXPENTRY inputHook( HAB hab, PQMSG pQmsg, USHORT fsOptions ) { if(( pQmsg->msg >= WM_BUTTONCLICKFIRST ) && ( pQmsg->msg <= WM_BUTTONCLICKLAST )) { ULONG flHIAState = (ULONG) WinSendMsg( hwndHIA, HIAM_QUERYSTATE, 0L, 0L ); BOOL fRunningHCHLB = queryRunningHCHLB(); if( HIUSHORT( flHIAState ) || fRunningHCHLB ) { if( !fRunningHCHLB ) { WinSendMsg( hwndHIA, HIAM_COMPLETEHCH, 0, 0 ); WinPostMsg( pQmsg->hwnd, pQmsg->msg, pQmsg->mp1, pQmsg->mp2 ); return TRUE; } if( !isHCHLB( pQmsg->hwnd )) { WinSendMsg( hwndHIA, HIAM_DESTROYHCHLB, 0, 0 ); WinPostMsg( pQmsg->hwnd, pQmsg->msg, pQmsg->mp1, pQmsg->mp2 ); return TRUE; } } } #ifdef ODIN_SUPPORT_IN_INPUT_HOOK else if( pQmsg->msg == WM_CHAR_SPECIAL ) // for Odin { ULONG flHIAState = (ULONG) WinSendMsg( hwndHIA, HIAM_QUERYSTATE, 0L, 0L ); USHORT fsFlags = SHORT1FROMMP( pQmsg->mp1 ); //UCHAR ucRepeat = CHAR3FROMMP( pQmsg->mp1 ); //UCHAR ucScancode = CHAR4FROMMP( pQmsg->mp1 ); //USHORT usCh = SHORT1FROMMP( pQmsg->mp2 ); //USHORT usVk = SHORT2FROMMP( pQmsg->mp2 ); if( !( fsFlags & KC_KEYUP ) && HIUSHORT( flHIAState )) { WinSendMsg( hwndHIA, HIAM_COMPLETEHCH, 0, 0 ); WinPostMsg( pQmsg->hwnd, pQmsg->msg, pQmsg->mp1, pQmsg->mp2 ); return TRUE; } } #endif return FALSE; }
int sa_stream_get_volume_abs(sa_stream_t *s, float *vol) { int status = SA_SUCCESS; uint32_t rc; MCI_STATUS_PARMS StatusParms; if (!s || !vol) return os2_error(SA_ERROR_NO_INIT, "sa_stream_get_volume_abs", "s or vol is null", 0); memset(&StatusParms, 0, sizeof(MCI_STATUS_PARMS)); StatusParms.ulItem = MCI_STATUS_VOLUME; rc = _mciSendCommand(s->hwDeviceID, MCI_STATUS, MCI_WAIT | MCI_STATUS_ITEM, (void*)&StatusParms, 0); if (LOUSHORT(rc)) { /* if there's an error, return a reasonable value */ StatusParms.ulReturn = (50 | 50 << 16); status = os2_error(SA_ERROR_SYSTEM, "sa_stream_get_volume_abs", "MCI_STATUS_VOLUME - rc=", LOUSHORT(rc)); } /* left channel is the low-order word, right channel is the * high-order word - convert the average of the channels from * an integer (range 0 - 100) to a floating point value */ *vol = (LOUSHORT(StatusParms.ulReturn) + HIUSHORT(StatusParms.ulReturn)) / 200.0; return status; }
/**************************************************************************\ * * * ROUTINE: AlarmDlgProc ( ) * * * * COMMENT: "Alarm..." dialog * * * * RETURNS: MRESULT, 0 or return value from WinDefDlgProc * * * \**************************************************************************/ MRESULT EXPENTRY AlarmDlgProc(HWND hwnd, ULONG usMsg, MPARAM mp1, MPARAM mp2) { switch (usMsg) { case WM_INITDLG: hAlarmTime = hwnd; /* Put in a global variable so all functions know we have already have an opened dialog box. */ InitAlarm(hwnd); break; case WM_COMMAND: switch (LOUSHORT(mp1)) { case DID_OK: AlarmSet(hwnd); case DID_CANCEL: hAlarmTime = NULLHANDLE; WinDismissDlg(hwnd, TRUE); } return NULL; case WM_CONTROL: break; case WM_VSCROLL: AlarmVScrolls(hwnd, HIUSHORT(mp2), mp1); break; } return WinDefDlgProc(hwnd, usMsg, mp1, mp2); }
void wxConvertVectorFontSize( FIXED fxPointSize , PFATTRS pFattrs ) { HPS hPS; HDC hDC; LONG lXFontResolution; LONG lYFontResolution; SIZEF vSizef; hPS = WinGetScreenPS(HWND_DESKTOP); // Screen presentation space // // Query device context for the screen and then query // the resolution of the device for the device context. // hDC = GpiQueryDevice(hPS); DevQueryCaps( hDC, CAPS_HORIZONTAL_FONT_RES, (LONG)1, &lXFontResolution); DevQueryCaps( hDC, CAPS_VERTICAL_FONT_RES, (LONG)1, &lYFontResolution); // // Calculate the size of the character box, based on the // point size selected and the resolution of the device. // The size parameters are of type FIXED, NOT int. // NOTE: 1 point == 1/72 of an inch. // // multiply first to avoid getting vSizef.cx,cy = 0 since fxPointSize // is normally < 72 and FontResolution is typically ca. 100 vSizef.cx = (FIXED)( (fxPointSize * lXFontResolution) / 72 ); vSizef.cy = (FIXED)( (fxPointSize * lYFontResolution) / 72 ); if (pFattrs) { pFattrs->lMaxBaselineExt = MAKELONG( HIUSHORT( vSizef.cy ), 0 ); pFattrs->lAveCharWidth = MAKELONG( HIUSHORT( vSizef.cx ), 0 ); } WinReleasePS(hPS); } // end of wxConvertVectorPointSize
USHORT usCopyEAS(PVOLINFO pVolInfo, ULONG ulSrcDirCluster, PSZ pszSrcFile, ULONG ulTarDirCluster, PSZ pszTarFile) { USHORT rc; ULONG ulSrcCluster, ulTarCluster; PSZ pszSrcEAName = NULL, pszTarEAName = NULL; DIRENTRY SrcEntry, TarEntry; rc = GetEASName(pVolInfo, ulSrcDirCluster, pszSrcFile, &pszSrcEAName); if (rc) goto usCopyEASExit; rc = GetEASName(pVolInfo, ulTarDirCluster, pszTarFile, &pszTarEAName); if (rc) goto usCopyEASExit; ulSrcCluster = FindPathCluster(pVolInfo, ulSrcDirCluster, pszSrcEAName, &SrcEntry, NULL); ulTarCluster = FindPathCluster(pVolInfo, ulTarDirCluster, pszTarEAName, &TarEntry, NULL); if (ulTarCluster != FAT_EOF) { rc = ModifyDirectory(pVolInfo, ulTarDirCluster, MODIFY_DIR_DELETE, &TarEntry, NULL, NULL, 0); if (rc) goto usCopyEASExit; DeleteFatChain(pVolInfo, ulTarCluster); } if (ulSrcCluster == FAT_EOF) goto usCopyEASExit; rc = CopyChain(pVolInfo, ulSrcCluster, &ulTarCluster); if (rc) goto usCopyEASExit; SrcEntry.wCluster = LOUSHORT(ulTarCluster); SrcEntry.wClusterHigh = HIUSHORT(ulTarCluster); /* Make new direntry */ rc = ModifyDirectory(pVolInfo, ulTarDirCluster, MODIFY_DIR_INSERT, NULL, &SrcEntry, pszTarEAName, 0); usCopyEASExit: if (pszSrcEAName) free(pszSrcEAName); if (pszTarEAName) free(pszTarEAName); if (f32Parms.fMessageActive & LOG_EAS) Message("usCopyEAS for returned %d", rc); return rc; }
/** * Probes and initializes. */ static int Open (vlc_object_t *obj) { services_discovery_t *sd = (services_discovery_t *)obj; HFILE hcd2; ULONG ulAction; ULONG ulParamLen; ULONG ulData; ULONG ulDataLen; ULONG rc; sd->description = _("Discs"); if (DosOpen ((PSZ)"CD-ROM2$", (PHFILE)&hcd2, &ulAction, 0, FILE_NORMAL, OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_FAIL_IF_NEW, OPEN_ACCESS_READONLY | OPEN_SHARE_DENYNONE, NULL)) return VLC_EGENERIC; rc = DosDevIOCtl (hcd2, IOCTL_CDROMDISK2, CDROMDISK2_DRIVELETTERS, NULL, 0, &ulParamLen, &ulData, sizeof(ulData), &ulDataLen); if (!rc) { char mrl[] = "file:///A:/", name[] = "A:"; int count = LOUSHORT(ulData); int drive = HIUSHORT(ulData); input_item_t *item; char letter; for (; count; --count, ++drive) { letter = 'A' + drive; mrl[8] = name[0] = letter; item = input_item_NewDisc (mrl, name, -1); msg_Dbg (sd, "adding %s (%s)", mrl, name); if (item == NULL) break; services_discovery_AddItem (sd, item); } } DosClose (hcd2); return rc ? VLC_EGENERIC : VLC_SUCCESS; }
MRESULT EXPENTRY DrivesDlgProc (HWND hWnd, ULONG msg, MPARAM mp1, MPARAM mp2) { BOOL bHandled = TRUE; MRESULT mReturn = 0; switch (msg) { case WM_INITDLG: QueryDrives (hWnd); break; case WM_CONTROL: switch (LOUSHORT(mp1)) { case IDC_DRIVELIST: if (HIUSHORT(mp1) == CBN_EFCHANGE) { DisplayDriveInfo (hWnd, (ULONG)WinSendDlgItemMsg (hWnd, IDC_DRIVELIST, LM_QUERYSELECTION, (MPARAM)LIT_FIRST, 0L)); } break; } break; case WM_SYSCOMMAND: switch (SHORT1FROMMP(mp1)) { case SC_CLOSE: WinDismissDlg (hWnd, FALSE); bHandled = TRUE; break; } break; default: bHandled = FALSE; break; } if (!bHandled) mReturn = WinDefDlgProc (hWnd, msg, mp1, mp2); return (mReturn); }
BOOL WndSize(HWND hwnd,MPARAM mp2) { RECTL rcl; usWndDepth = HIUSHORT(mp2)/ stCell.cy; usWndWidth = LOUSHORT(mp2)/ stCell.cx; /************************************************************************/ /* The test below caters for the first instance of WM_SIZE that invokes */ /* this function BEFORE window creation is complete and the Frame handle*/ /* has been set. */ /************************************************************************/ hwndFrame = (hwndFrame != (HWND)0) ? hwndFrame : WinQueryWindow(hwnd,QW_PARENT); WinQueryWindowRect(hwndClient,&rcl); ulWindowWidth = rcl.xRight; ulWindowHeight = rcl.yTop; WinInvalidateRect(hwnd,(PRECTL)0,FALSE); return(TRUE); }
MRESULT EXPENTRY ClientWndProc (HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) { static SHORT cxClient, cyClient ; HPS hps ; switch (msg) { case WM_SIZE: cxClient = LOUSHORT (mp2) ; cyClient = HIUSHORT (mp2) ; return 0 ; case WM_PAINT: hps = WinBeginPaint (hwnd, NULLHANDLE, NULL) ; GpiErase (hps) ; PaintClient (hps, cxClient, cyClient) ; WinEndPaint (hps) ; return 0 ; } return WinDefWindowProc (hwnd, msg, mp1, mp2) ; }
BOOL kimeAccelHook( PQMSG pQmsg ) { if( pQmsg->msg == WM_CHAR #ifndef ODIN_SUPPORT_IN_INPUT_HOOK || pQmsg->msg == WM_CHAR_SPECIAL #endif ) { USHORT fsFlags = SHORT1FROMMP( pQmsg->mp1 ); UCHAR ucRepeat = CHAR3FROMMP( pQmsg->mp1 ); UCHAR ucScancode = CHAR4FROMMP( pQmsg->mp1 ); USHORT usCh = SHORT1FROMMP( pQmsg->mp2 ); USHORT usVk = SHORT2FROMMP( pQmsg->mp2 ); ULONG flHIAState; BOOL hanIn; BOOL consumed; BOOL callHanja; //BOOL patched; if( queryRunningHCHLB()) { WinSendMsg( hwndHIA, HIAM_CHAR, pQmsg->mp1, pQmsg->mp2 ); return TRUE; } //patched = FALSE; if(( fsFlags & KC_VIRTUALKEY ) && ( usVk == VK_PAGEDOWN + 0x90 ) && ( ucScancode = 0x96 )) { usVk = VK_PAGEDOWN; ucScancode = 0x67; pQmsg->mp1 = MPFROMSH2CH( fsFlags, ucRepeat, ucScancode ); pQmsg->mp2 = MPFROM2SHORT( usCh, usVk ); //patched = TRUE; } if(( fsFlags & KC_SCANCODE ) && ( ucScancode == 0x2B ) && ( fsFlags & KC_INVALIDCHAR )) { fsFlags &= ~KC_INVALIDCHAR; fsFlags |= KC_CHAR; usCh = 0x5C; pQmsg->mp1 = MPFROMSH2CH( fsFlags, ucRepeat, ucScancode ); pQmsg->mp2 = MPFROM2SHORT( usCh, usVk ); //patched = TRUE; } callHanja = isHanjaKey( fsFlags, ucScancode, usVk, usCh ); if((( fsFlags & KC_KEYUP ) || (( fsFlags & 0x0FFF ) == KC_SCANCODE ) || !( fsFlags & KC_SCANCODE )) && !callHanja ) return FALSE; #ifdef FOCUS_ON dprintf(("inputFocusChanged %d, hwndCurrentInput %04X\n", inputFocusChanged, hwndCurrentInput )); if( inputFocusChanged || ( hwndCurrentInput != pQmsg->hwnd )) { inputFocusChanged = FALSE; hwndCurrentInput = pQmsg->hwnd; supportDBCS = checkDBCSSupport( hwndCurrentInput ); exception = checkExceptWindow( hwndCurrentInput ); } #else dprintf(("hwndCurrentInput %04X\n", hwndCurrentInput )); if( hwndCurrentInput != pQmsg->hwnd ) { hwndCurrentInput = pQmsg->hwnd; initKimeStatus( hwndCurrentInput, FALSE ); supportDBCS = checkDBCSSupport( hwndCurrentInput ); exception = checkExceptWindow( hwndCurrentInput ); } #endif dprintf(("hwndCurrentInput %04X, supportDBCS %d, exception %d\n", hwndCurrentInput, supportDBCS, exception )); if(( fsFlags & ( KC_CTRL | KC_SHIFT )) && (( fsFlags & KC_VIRTUALKEY ) && ( usVk == VK_SPACE ))) supportDBCS = checkDBCSSupport( hwndCurrentInput ); if( kimeOpt.useOS2IME ) { if( exception /* || !supportDBCS */) return FALSE; if((( fsFlags & ( KC_ALT | KC_CTRL | KC_SHIFT )) == KC_SHIFT ) && (( fsFlags & KC_VIRTUALKEY ) && ( usVk == VK_SPACE ))) { toggleOS2IMEHanEng( hwndCurrentInput ); return TRUE; } #if 0 if( callHanja ) { callIMEHanja( pQmsg->hwnd ); return TRUE; } #endif return FALSE; } dprintf(("hwndCurrentInput %04X, supportDBCS %d, exception %d\n", hwndCurrentInput, supportDBCS, exception )); if( !hwndCurrentInput || !supportDBCS || exception ) return FALSE; if(( fsFlags & ( KC_CTRL | KC_SHIFT )) && (( fsFlags & KC_VIRTUALKEY ) && ( usVk == VK_SPACE ))) return ( BOOL )WinSendMsg( hwndHIA, WM_CHAR, pQmsg->mp1, pQmsg->mp2 ); flHIAState = (ULONG) WinSendMsg( hwndHIA, HIAM_QUERYSTATE, 0L, 0L ); hanIn = flHIAState & HIAST_HANMODE; #if 0 if( !HIUSHORT( flHIAState ) && ( fsFlags & ( KC_VIRTUALKEY | KC_CTRL | KC_ALT )) && !callHanja ) return FALSE; #endif if( hanIn /*|| patched */ ) { //MPARAM mp2; consumed = FALSE; if( callHanja ) { WinPostMsg( hwndKime, KIMEM_CALLHANJAINPUT, 0, 0 ); consumed = TRUE; } else if((( fsFlags & KC_CHAR ) || (( fsFlags & KC_VIRTUALKEY ) && (( usVk == VK_ESC ) || ( usVk == VK_SHIFT )))) && !(( fsFlags & KC_VIRTUALKEY ) && (( usVk == VK_TAB )/* || ( usVk == VK_SPACE )*/))) { //mp2 = pQmsg->mp2; //kbdKeyTranslate( pQmsg ); consumed = (BOOL)WinSendMsg( hwndHIA, WM_CHAR, pQmsg->mp1, pQmsg->mp2 ); //pQmsg->mp2 = mp2; } else if( !isHanjaKey( fsFlags | KC_LONEKEY, ucScancode, usVk, usCh )) WinSendMsg( hwndHIA, HIAM_COMPLETEHCH, 0, 0 ); if( !consumed ) { if( !HIUSHORT( flHIAState )) return FALSE; if( fsFlags & ( KC_CTRL | KC_ALT )) return FALSE; if(( fsFlags & KC_VIRTUALKEY ) && (( usVk == VK_SHIFT ) || (( usVk >= VK_F1 ) && ( usVk <= VK_F24 )))) return FALSE; #ifndef ODIN_SUPPORT_IN_INPUT_HOOK if( pQmsg->msg == WM_CHAR ) { #endif #if 0 // IME do as the following. if( HIUSHORT( flHIAState ) && ( fsFlags & KC_CHAR ) && ( usCh == ' ' )) { pQmsg->mp1 = MPFROMSH2CH( KC_CHAR, ucRepeat, 0 ); pQmsg->mp2 = MPFROM2SHORT( usCh, 0 ); } #endif #ifndef ODIN_SUPPORT_IN_INPUT_HOOK } #endif WinPostMsg( pQmsg->hwnd, pQmsg->msg, pQmsg->mp1, pQmsg->mp2 ); } return TRUE; } } return FALSE; }
/************************ END OF SPECIFICATIONS ***********************/ void USBInit( RPH FAR *pRP ) { PRPINITOUT pRPO; /* output request packet far pointer */ PRPINITIN pRPI; /* input request packet far pointer */ UINT ctrlID; KeyData keyData[3]={"V",CFSTR_TYPE_DEC,0,0, "REQ:",CFSTR_TYPE_STRING,0,0, "I13",CFSTR_TYPE_DEC,0,0}; // 31/05/1999 MB PSZ cmdLine; ULONG cmdRStatus, errColumn; USHORT cmdRc; #ifdef DEBUG dsPrint(DBG_HLVLFLOW, "USBD: USBInit started\r\n"); #endif pRP->Status = STATUS_DONE; if (ghDriver) // initialization already passed return; pRPI = (PRPINITIN) pRP; pRPO = (PRPINITOUT) pRP; Device_Help = ((PRPINITIN)pRP)->DevHlpEP; /* save devhlp entry point */ // process CONFIG.SYS BASEDEV= line parameters cmdLine=(PSZ) MAKEP( SELECTOROF(pRPI->InitArgs), OFFSETOF(((PDDD_PARM_LIST)pRPI->InitArgs)->cmd_line_args) ); cmdRStatus=ProcessConfigString(cmdLine, sizeof(keyData)/sizeof(keyData[0]), (KeyData FAR *)&keyData); cmdRc=LOUSHORT(cmdRStatus); errColumn=(ULONG)HIUSHORT(cmdRStatus); switch (cmdRc) // set cmd line processing errors { case CFSTR_UNKWN_KEYS: SetLongValue( gVMessages[INIT_MESSAGE_UNKNOWNKWD], errColumn ); gMessageCount=AddToMsgArray( gMessageIDs, INIT_MESSAGE_UNKNOWNKWD, gMessageCount, MAX_INIT_MESSAGE_COUNT ); break; case CFSTR_CONVERR: SetLongValue( gVMessages[INIT_MESSAGE_INVNUMERIC], errColumn ); gMessageCount=AddToMsgArray( gMessageIDs, INIT_MESSAGE_INVNUMERIC, gMessageCount, MAX_INIT_MESSAGE_COUNT ); break; default: break; } if (keyData[1].value && // check for HCD layer drivers !CheckHCDDriversLoaded( cmdLine, LOUSHORT(keyData[1].value), HIUSHORT(keyData[1].value) )) { pRP->Status = STATUS_DONE | STERR | ERROR_I24_QUIET_INIT_FAIL; // 05/16/2000 MB - exit code changed to quiet exit code gMessageCount=AddToMsgArray( gMessageIDs, INIT_MESSAGE_NO_HCD, gMessageCount, MAX_INIT_MESSAGE_COUNT ); } gVerbose= keyData[0].keyStatus!=CFSTR_STATUS_NOTFOUND; gDelayHostStart = keyData[2].keyStatus!=CFSTR_STATUS_NOTFOUND; // 31/05/1999 MB if(gDelayHostStart && (pRP->Status == STATUS_DONE) ) // 05/16/2000 MB - fixed error code processing { USHORT ctxOffset; USHORT rc; ctxOffset=(USHORT)(LONG)(StartHostCtxHookRtn); // IRQ processing thread rc = DevHelp_AllocateCtxHook((NPFN)ctxOffset, &gStartHostHookHandle); if (rc) { pRP->Status = STATUS_DONE | STERR | STATUS_ERR_UNKCMD; gMessageCount=AddToMsgArray( gMessageIDs, INIT_MESSAGE_SETCTXFAILED, gMessageCount, MAX_INIT_MESSAGE_COUNT ); #ifdef DEBUG dsPrint(DBG_CRITICAL, " USBD: USBDInit failed to allocate CTX hook routine\r\n"); #endif } } /*---------------------------------------------------*/ /* Register device driver with resource manager */ /*---------------------------------------------------*/ if (pRP->Status == STATUS_DONE) RegisterUSBD(); if (pRP->Status == STATUS_DONE) { // initialize local structures setmem((PSZ)&gHostControllers,0,sizeof(gHostControllers)); setmem((PSZ)&gClassDrivers,0,sizeof(gClassDrivers)); setmem((PSZ)&gDevices,0,sizeof(gDevices)); setmem((PSZ)&gHubs,0,sizeof(gHubs)); for (ctrlID=1; ctrlID<gMaxControllers; ctrlID++) { gSetAddress[ctrlID]=gSetAddress[0]; gSetConfiguration[ctrlID]=gSetConfiguration[0]; gDeviceStruct[ctrlID]=gDeviceStruct[0]; gGetConfiguration[ctrlID]=gGetConfiguration[0]; gGetHubConfigurationLength[ctrlID]=gGetHubConfigurationLength[0]; } } if (pRP->Status == STATUS_DONE) { SetLongValue( gVMessages[INIT_MESSAGE_LOADED], (ULONG)gDriverStruct.MajorVer ); SetLongValue( gVMessages[INIT_MESSAGE_LOADED], (ULONG)gDriverStruct.MinorVer ); gMessageCount=AddToMsgArray( gMessageIDs, INIT_MESSAGE_LOADED, gMessageCount, MAX_INIT_MESSAGE_COUNT ); pRPO->CodeEnd = ((USHORT) &USBInit) - 1; /* set end of code segment */ pRPO->DataEnd = ((USHORT) &gInitDataStart) - 1; /* set end of data segment */ } else { pRPO->CodeEnd = 0; /* set end of code segment */ pRPO->DataEnd = 0; /* set end of data segment */ } TTYWrite(gVMessages, gMessageIDs, gMessageCount); #ifdef DEBUG dsPrint1(DBG_HLVLFLOW, "USBD: USBInit ended. Status %x\r\n", pRP->Status); #endif return; }
void JOYInit() { KeyData keyData[2] = {"V", CFSTR_TYPE_DEC, 0, 0, "DEVICE:", CFSTR_TYPE_DEC, 0, 0}; PSZ kbdCmdLine; ULONG cmdRStatus, errColumn; USHORT cmdRc, i; #ifdef DEBUG dsPrint (DBG_HLVLFLOW, "USBJOY: Init Entry\r\n"); #endif pRP->Status = STATUS_DONE; if (ghDriver) return; // initialization already passed Device_Help = ((PRPINITIN)pRP)->DevHlpEP; // save DevHlp Entry Point kbdCmdLine = (PSZ)MAKEP (SELECTOROF (((PRPINITIN)pRP)->InitArgs), OFFSETOF (((PRPINITIN)pRP)->InitArgs)); cmdRStatus = ProcessConfigString (kbdCmdLine, 2, (KeyData FAR *)&keyData); cmdRc = LOUSHORT (cmdRStatus); errColumn = (ULONG)HIUSHORT (cmdRStatus); switch (cmdRc) { case CFSTR_UNKWN_KEYS: SetLongValue (gVMessages[INIT_MESSAGE_UNKNOWNKWD], errColumn); gMessageCount = AddToMsgArray (gMessageIDs, INIT_MESSAGE_UNKNOWNKWD, gMessageCount, MAX_INIT_MESSAGE_COUNT); break; case CFSTR_CONVERR: SetLongValue (gVMessages[INIT_MESSAGE_INVNUMERIC], errColumn ); gMessageCount = AddToMsgArray (gMessageIDs, INIT_MESSAGE_INVNUMERIC, gMessageCount, MAX_INIT_MESSAGE_COUNT); } gVerbose = (BYTE)(keyData[0].keyStatus != CFSTR_STATUS_NOTFOUND); if (keyData[1].keyStatus == CFSTR_STATUS_OK) gDevice = (keyData[1].value < MAX_JOYS)? (BYTE)keyData[1].value : (BYTE)NULL; else gDevice = NULL; if (DevHelp_AttachDD ("USBHID$ ", (NPBYTE)&gIDCTable)) // obtain USBHID's IDC entry point { pRP->Status |= STERR; gMessageCount = AddToMsgArray (gMessageIDs, INIT_MESSAGE_NO_HID, gMessageCount, MAX_INIT_MESSAGE_COUNT); #ifdef DEBUG dsPrint (DBG_HLVLFLOW, "USBJOY: Init Faild to Attach to USBHID$ \r\n"); #endif } else { gpHIDIDC = (PUSBIDCEntry)gIDCTable.ProtIDCEntry; gdsHIDIDC = gIDCTable.ProtIDC_DS; } if (pRP->Status == STATUS_DONE) { RegisterJOY(); // register driver with RM gNoOfJOYs = 0; for (i = 0; i < MAX_JOYS; i++) gJOY[i].active = 0; ((PRPINITOUT)pRP)->CodeEnd = ((USHORT)&JOYInit); // set end of code segment ((PRPINITOUT)pRP)->DataEnd = ((USHORT)&gInitDataStart); // set end of data segment SetLongValue (gVMessages[INIT_MESSAGE_LOADED], (ULONG)gDriverStruct.MajorVer); SetLongValue (gVMessages[INIT_MESSAGE_LOADED], (ULONG)gDriverStruct.MinorVer); SetLongValue (gVMessages[INIT_MESSAGE_LOADED], (ULONG)gDevice); gMessageCount = AddToMsgArray (gMessageIDs, INIT_MESSAGE_LOADED, gMessageCount, MAX_INIT_MESSAGE_COUNT); } else { ((PRPINITOUT)pRP)->CodeEnd = 0; ((PRPINITOUT)pRP)->DataEnd = 0; } if (gVerbose) TTYWrite (gVMessages, gMessageIDs, gMessageCount); #ifdef DEBUG dsPrint1 (DBG_HLVLFLOW, "USBJOY: Init Status = %x\r\n", pRP->Status); #endif return; }
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); }
USHORT usWriteEAS(PVOLINFO pVolInfo, ULONG ulDirCluster, PSZ pszFileName, PFEALIST pFEAL) { ULONG ulCluster, ulNextCluster; PBYTE pszEAName; PBYTE pWrite; USHORT rc; USHORT usClustersNeeded; DIRENTRY DirEntry; DIRENTRY DirNew; BOOL fCritical; PFEA pFea, pFeaEnd; if (pFEAL->cbList > MAX_EA_SIZE) return ERROR_EA_LIST_TOO_LONG; rc = GetEASName(pVolInfo, ulDirCluster, pszFileName, &pszEAName); if (rc) return rc; usClustersNeeded = (USHORT)pFEAL->cbList / pVolInfo->usClusterSize; if (pFEAL->cbList % pVolInfo->usClusterSize) usClustersNeeded++; ulCluster = FindPathCluster(pVolInfo, ulDirCluster, pszEAName, &DirEntry, NULL); if (!ulCluster || ulCluster == FAT_EOF) { BOOL fNew = FALSE; if (ulCluster == FAT_EOF) { fNew = TRUE; memset(&DirNew, 0, sizeof DirNew); DirNew.bAttr = FILE_HIDDEN | FILE_SYSTEM | FILE_READONLY; DirNew.ulFileSize = pFEAL->cbList; } else memcpy(&DirNew, &DirEntry, sizeof DirEntry); ulCluster = MakeFatChain(pVolInfo, FAT_EOF, (ULONG)usClustersNeeded, NULL); if (ulCluster == FAT_EOF) { free(pszEAName); return ERROR_DISK_FULL; } DirNew.wCluster = LOUSHORT(ulCluster); DirNew.wClusterHigh = HIUSHORT(ulCluster); if (fNew) rc = MakeDirEntry(pVolInfo, ulDirCluster, &DirNew, pszEAName); else rc = ModifyDirectory(pVolInfo, ulDirCluster, MODIFY_DIR_UPDATE, &DirEntry, &DirNew, NULL, 0); if (rc) { free(pszEAName); return rc; } } else { memcpy(&DirNew, &DirEntry, sizeof (DIRENTRY)); DirNew.ulFileSize = pFEAL->cbList; rc = ModifyDirectory(pVolInfo, ulDirCluster, MODIFY_DIR_UPDATE, &DirEntry, &DirNew, NULL, 0); if (rc) { free(pszEAName); return rc; } } free(pszEAName); pWrite = (PBYTE)pFEAL; ulNextCluster = FAT_EOF; while (usClustersNeeded) { ulNextCluster = GetNextCluster(pVolInfo, ulCluster); if (!ulNextCluster) ulNextCluster = FAT_EOF; rc = WriteCluster(pVolInfo, ulCluster, pWrite, 0); if (rc) return rc; usClustersNeeded --; pWrite += pVolInfo->usClusterSize; if (usClustersNeeded) { if (ulNextCluster == FAT_EOF) ulCluster = MakeFatChain(pVolInfo, ulCluster, (ULONG)usClustersNeeded, NULL); else ulCluster = ulNextCluster; if (ulCluster == FAT_EOF) return ERROR_DISK_FULL; } } if (ulNextCluster != FAT_EOF) { SetNextCluster(pVolInfo, ulCluster, FAT_EOF); DeleteFatChain(pVolInfo, ulNextCluster); } pFea = pFEAL->list; pFeaEnd = (PFEA)((PBYTE)pFEAL + pFEAL->cbList); fCritical = FALSE; while (pFea < pFeaEnd) { if (pFea->fEA & FEA_NEEDEA) fCritical = TRUE; pFea = (PFEA)((PBYTE)pFea + sizeof (FEA) + (USHORT)pFea->cbName + 1 + pFea->cbValue); } if (fCritical) rc = MarkFileEAS(pVolInfo, ulDirCluster, pszFileName, FILE_HAS_CRITICAL_EAS); else rc = MarkFileEAS(pVolInfo, ulDirCluster, pszFileName, FILE_HAS_EAS); return rc; }
MRESULT EXPENTRY fnwpReadColumnClient(HWND hwnd,USHORT msg,MPARAM mp1,MPARAM mp2) { static HDC hdcPs; RECTL rclRect; POINTL ptl; LONG lSaveEdge; SWP swp; HWND hwndMenu; static USHORT usMenuStyle; static CLRDLG stColor; static USHORT usLastPopupItem; switch(msg) { case WM_CHAR: if (bSendNextKeystroke) if (ProcessKeystroke(&stCFG,mp1,mp2)) return((MRESULT)TRUE); return( WinDefWindowProc(hwnd,msg,mp1,mp2)); case WM_CREATE: hdcPs = WinOpenWindowDC(hwnd); usLastPopupItem = IDMPU_SYNC; stRead.lBackgrndColor = stCFG.lReadColBackgrndColor; stRead.bActive = FALSE; stRead.lScrollIndex = 0; stRead.hwndScroll = (HWND)NULL; stRead.wDirection = CS_READ; stColor.cbSize = sizeof(CLRDLG); usMenuStyle = (PU_POSITIONONITEM | PU_MOUSEBUTTON2 | PU_HCONSTRAIN | PU_VCONSTRAIN | PU_KEYBOARD | PU_MOUSEBUTTON1); WinSendMsg(hwnd,UM_TRACKFRAME,0L,0L); break; case WM_ACTIVATE: if(SHORT1FROMMP(mp1)) { if (!bFrameActivated) { WinSetFocus(HWND_DESKTOP,hwndFrame); WinSendMsg(WinQueryHelpInstance(hwndClient),HM_SET_ACTIVE_WINDOW,0L,0L); bFrameActivated = TRUE; } } else bFrameActivated = FALSE; break; case WM_VSCROLL: switch(HIUSHORT(mp2)) { case SB_LINEDOWN: ColScroll(&stRead,1,FALSE); break; case SB_LINEUP: ColScroll(&stRead,-1,FALSE); break; case SB_PAGEDOWN: ColScroll(&stRead,stRead.lCharHeight,FALSE); break; case SB_PAGEUP: ColScroll(&stRead,-stRead.lCharHeight,FALSE); break; case SB_SLIDERPOSITION: ColScroll(&stRead,LOUSHORT(mp2),TRUE); break; } break; case WM_COMMAND: switch (SHORT1FROMMP(mp1)) { case IDMPU_ASCII_FONT: if (!stCFG.bStickyMenus) usLastPopupItem = IDMPU_FONT; else usLastPopupItem = IDMPU_SYNC; if (stCFG.wColReadFont != wASCIIfont) { stCFG.wColReadFont = wASCIIfont; WinInvalidateRect(stRead.hwndClient,(PRECTL)NULL,FALSE); } break; case IDMPU_HEX_FONT: if (!stCFG.bStickyMenus) usLastPopupItem = IDMPU_FONT; else usLastPopupItem = IDMPU_SYNC; if (stCFG.wColReadFont != wHEXfont) { stCFG.wColReadFont = wHEXfont; WinInvalidateRect(stRead.hwndClient,(PRECTL)NULL,FALSE); } break; case IDMPU_SYNC: usLastPopupItem = IDMPU_SYNC; if (bStopDisplayThread) stRead.lScrollIndex = stWrite.lScrollIndex; else stRead.lScrollIndex = 0; stRead.lScrollRow = GetColScrollRow(&stRead,0); WinSendMsg(stRead.hwndScroll, SBM_SETPOS, MPFROMSHORT(stRead.lScrollRow), MPFROMSHORT(0)); if (stRead.bSync) { stRow.lScrollIndex = stRead.lScrollIndex; stRow.lScrollRow = GetRowScrollRow(&stRow); } WinInvalidateRect(stRead.hwndClient,(PRECTL)NULL,FALSE); break; case IDMPU_COLORS: if (!stCFG.bStickyMenus) usLastPopupItem = IDMPU_COLORS; else usLastPopupItem = IDMPU_SYNC; stColor.lForeground = stCFG.lReadColForegrndColor; stColor.lBackground = stCFG.lReadColBackgrndColor; sprintf(stColor.szCaption,"Lexical Receive Data Display Colors"); if (WinDlgBox(HWND_DESKTOP, hwnd, (PFNWP)fnwpSetColorDlg, (USHORT)NULL, CLR_DLG, MPFROMP(&stColor))) { stCFG.lReadColForegrndColor = stColor.lForeground; stCFG.lReadColBackgrndColor = stColor.lBackground; stRead.lBackgrndColor = stColor.lBackground; stRead.lForegrndColor = stColor.lForeground; WinInvalidateRect(stRead.hwndClient,(PRECTL)NULL,FALSE); } break; case IDMPU_LOCK_WIDTH: if (!stCFG.bStickyMenus) usLastPopupItem = IDMPU_LOCK_WIDTH; else usLastPopupItem = IDMPU_SYNC; if (stCFG.fLockWidth == LOCK_READ) stCFG.fLockWidth = LOCK_NONE; else { stCFG.lLockWidth = ((stRead.lWidth / stCell.cx) + 1); stCFG.fLockWidth = LOCK_READ; } break; case IDMPU_DISP_FILTERS: if (!stCFG.bStickyMenus) usLastPopupItem = IDMPU_DISP_FILTERS; else usLastPopupItem = IDMPU_SYNC; if (WinDlgBox(HWND_DESKTOP, hwnd, (PFNWP)fnwpDisplaySetupDlgProc, (USHORT)NULL, DISP_FILTER_DLG, MPFROMP(&stRead))) { stCFG.bReadTestNewLine = stRead.bTestNewLine; stCFG.bSkipReadBlankLines = stRead.bSkipBlankLines; stCFG.byReadNewLineChar = stRead.byNewLineChar; stCFG.bFilterRead = stRead.bFilter; stCFG.fFilterReadMask = stRead.fFilterMask; stCFG.byReadMask = stRead.byDisplayMask; if (stRead.bSync) { if (!stCFG.bSyncToRead) { stWrite.bSync = FALSE; stCFG.bSyncToWrite = FALSE; stCFG.bSyncToRead = TRUE; if (stCFG.fDisplaying & (DISP_DATA | DISP_FILE)) { ClearColScrollBar(&stWrite); SetupColScrolling(&stRead); } } } else { if (stCFG.bSyncToRead) { stCFG.bSyncToRead = FALSE; if (stCFG.fDisplaying & (DISP_DATA | DISP_FILE)) SetupColScrolling(&stWrite); } } WinInvalidateRect(stRead.hwndClient,(PRECTL)NULL,FALSE); } break; } break; // case WM_CHORD: case WM_BUTTON2DOWN: if(bFrameActivated) { hwndMenu = WinLoadMenu(stRead.hwnd,(HMODULE)NULL,IDMPU_COL_DISP_POPUP); if (mp1 != 0) { WinQueryPointerPos(HWND_DESKTOP,&ptl); if (!stCFG.bStickyMenus) usMenuStyle |= PU_MOUSEBUTTON2DOWN; else usMenuStyle &= ~PU_MOUSEBUTTON2DOWN; } else { usMenuStyle &= ~PU_MOUSEBUTTON2DOWN; WinQueryWindowPos(hwndFrame,&swp); ptl.x = (swp.x + (swp.cx - (swp.cx / 4))); ptl.y = (swp.y + (swp.cy / 2)); } if (stCFG.wColReadFont == wASCIIfont) PopupMenuItemCheck(hwndMenu,IDMPU_ASCII_FONT,TRUE); else PopupMenuItemCheck(hwndMenu,IDMPU_HEX_FONT,TRUE); if (stCFG.fLockWidth == LOCK_READ) PopupMenuItemCheck(hwndMenu,IDMPU_LOCK_WIDTH,TRUE); if (!bStopDisplayThread) WinSendMsg(hwndMenu,MM_SETITEMTEXT,(MPARAM)IDMPU_SYNC,"~Reset Display"); WinPopupMenu(HWND_DESKTOP,stRead.hwndClient,hwndMenu,ptl.x,ptl.y,usLastPopupItem,usMenuStyle); } else return WinDefWindowProc(hwnd,msg,mp1,mp2); break; case WM_BUTTON1DOWN: if(bFrameActivated) { WinCopyRect(habAnchorBlock,&rclRect,&stRead.rcl); lSaveEdge = rclRect.xLeft; if (TrackChildWindow(habAnchorBlock,hwndClient,&rclRect,TF_LEFT)) { if (rclRect.xLeft != lSaveEdge) { WinSendMsg(stWrite.hwndClient,UM_TRACKSIB,0L,(MPARAM)rclRect.xLeft); WinSendMsg(stRead.hwndClient,UM_TRACKSIB,(MPARAM)rclRect.xLeft,0L); if (stCFG.fLockWidth == LOCK_WRITE) stCFG.lLockWidth = ((stWrite.lWidth / stCell.cx) + 1); else stCFG.lLockWidth = ((stRead.lWidth / stCell.cx) + 1); } } } else return WinDefWindowProc(hwnd,msg,mp1,mp2); break; case WM_DESTROY: GpiDestroyPS(hdcPs); break; case UM_SHOWNEW: stRead.lScrollIndex = 0; stRead.lScrollRow = 0; ClearColScrollBar(&stRead); case UM_SHOWAGAIN: stRead.bActive = TRUE; if ((stCFG.fDisplaying & (DISP_DATA | DISP_FILE)) && !stCFG.bSyncToWrite) SetupColScrolling(&stRead); WinShowWindow(stRead.hwnd,TRUE); WinSendMsg(hwnd,UM_TRACKFRAME,0L,0L); WinInvalidateRect(stRead.hwndClient,(PRECTL)NULL,FALSE); WinInvalidateRect(hwndStatus,(PRECTL)NULL,FALSE); break; case UM_HIDEWIN: ClearColScrollBar(&stRead); stRead.bActive = FALSE; WinShowWindow(hwnd,FALSE); WinSetWindowPos(stRead.hwnd,HWND_BOTTOM,0L,0L,0L,0L,(SWP_MOVE | SWP_SIZE | SWP_ZORDER)); break; case WM_PAINT: #ifdef this_junk if (!pstCFG->bDisplayingData && (stCFG.bSyncToRead || stCFG.bSyncToWrite)) ColumnPaint(&stRead,WinPeekMsg(habAnchorBlock,&stQmsg,stWrite.hwndClient,WM_PAINT,WM_PAINT,PM_REMOVE)); else #endif ColumnPaint(&stRead); break; case UM_TRACKSIB: ColumnSize(&stRead,(LONG)mp1,(LONG)mp2,TRUE); break; case UM_TRACKFRAME: ColumnSize(&stRead,(LONG)mp1,(LONG)mp2,FALSE); break; case WM_ERASEBACKGROUND: return (MRESULT)(TRUE); case WM_CLOSE: WinPostMsg(hwnd,WM_QUIT,0L,0L); default: return WinDefWindowProc(hwnd,msg,mp1,mp2); } return(FALSE); }
/**************************************************************************\ * * * ROUTINE: EntryFieldSubProc * * * * COMMENT: "Alarm..." dialog * * This procedure filter messages for the entry field and make it a time * * entry field. It doesn't allow for illigal characters according to the * * current selection. It doesn't allow modification of the time separator. * * It works only for hours and minutes. The entry field has to be limited * * to 5 characters. * * * * * * RETURNS: MRESULT, 0 or return value from WinDefDlgProc * * * \**************************************************************************/ MRESULT EXPENTRY EntryFieldSubProc(HWND hwnd, ULONG usMsg, MPARAM mp1, MPARAM mp2) { USHORT usSelect, fsKeyFlags, usLast; UCHAR usChr1; UCHAR uchHourMinutes[6]; BOOL bValid; if ((usMsg > WM_MOUSEFIRST) && (usMsg < WM_MOUSELAST)) { MRESULT mresult = pfnwpEntryField(hwnd, usMsg, mp1, mp2); MRESULT mresultSel = pfnwpEntryField(hwnd, EM_QUERYSEL, (PLONG)NULL, (PLONG)NULL); usSelect = LOUSHORT(mresultSel); usLast = HIUSHORT(mresultSel); if ((usSelect == 2)) pfnwpEntryField(hwnd, EM_SETSEL, MPFROM2SHORT(3, 3), NULL); if ((usSelect == 5)) pfnwpEntryField(hwnd, EM_SETSEL, MPFROM2SHORT(4, 4), NULL); return mresult; } switch (usMsg) { case WM_SETFOCUS: pfnwpEntryField(hwnd, usMsg, mp1, mp2); if (SHORT1FROMMP(mp2)) pfnwpEntryField(hwnd, EM_SETINSERTMODE, MPFROMSHORT(FALSE), (MPARAM)NULL); return MPVOID; case WM_CHAR: fsKeyFlags = SHORT1FROMMP(mp1); /* key flags */ if (!(fsKeyFlags & KC_KEYUP)) { usSelect = (USHORT)WinSendMsg(hwnd, EM_QUERYSEL, MPVOID, MPVOID); if (fsKeyFlags & KC_VIRTUALKEY) { switch(SHORT2FROMMP(mp2)) { case VK_UP: case VK_DOWN: break; case VK_LEFT: if (usSelect == 3) pfnwpEntryField(hwnd, usMsg, mp1, mp2); return pfnwpEntryField(hwnd, usMsg, mp1, mp2); break; case VK_RIGHT: if (usSelect == 4) { return MPVOID; } if (usSelect == 1) pfnwpEntryField(hwnd, usMsg, mp1, mp2); return pfnwpEntryField(hwnd, usMsg, mp1, mp2); break; case VK_DELETE: case VK_BACKSPACE: case VK_INSERT: return MPVOID; case VK_SPACE: switch (usSelect) { case 0: /* Hours most significant digit */ if (bTwelveHourFormat) { return pfnwpEntryField(hwnd, usMsg, mp1, mp2); } default: return MPVOID; } default: return pfnwpEntryField(hwnd, usMsg, mp1, mp2); break; } } else { if (fsKeyFlags & KC_CHAR) { bValid = FALSE; WinQueryWindowText(hwnd, sizeof(uchHourMinutes), uchHourMinutes); usChr1 = (UCHAR)CHAR1FROMMP(mp2); switch (usSelect) { case 0: /* Hours most significant digit */ if (bTwelveHourFormat) { if ((usChr1 > '1') || (usChr1 < '0')) { return MPVOID; } else { pfnwpEntryField(hwnd, usMsg, mp1, mp2); bValid = TRUE; } } else { if ((usChr1 > '2') || (usChr1 < '0')) { return MPVOID; } else { pfnwpEntryField(hwnd, usMsg, mp1, mp2); bValid = TRUE; } } if (bValid) { uchHourMinutes[0] = usChr1; uchHourMinutes[1] = '0'; WinSetWindowText(hwnd, uchHourMinutes); pfnwpEntryField(hwnd, EM_SETSEL, MPFROM2SHORT(1,1),(PLONG)NULL); } return MPVOID; break; case 1: if (bTwelveHourFormat) { if ((uchHourMinutes[0] == '0') || (uchHourMinutes[0] == ' ')) { if ((usChr1 > '9') || (usChr1 < '0')) { return MPVOID; } else { pfnwpEntryField(hwnd, usMsg, mp1, mp2); bValid = TRUE; } } else { /* probably 1 */ if ((usChr1 > '2') || (usChr1 < '0')) { return MPVOID; } else { pfnwpEntryField(hwnd, usMsg, mp1, mp2); bValid = TRUE; } } } else { if (uchHourMinutes[0] < '2') { if ((usChr1 > '9') || (usChr1 < '0')) { return MPVOID; } else { pfnwpEntryField(hwnd, usMsg, mp1, mp2); bValid = TRUE; } } else { if ((usChr1 > '4') || (usChr1 < '0')) { return MPVOID; } else { pfnwpEntryField(hwnd, usMsg, mp1, mp2); bValid = TRUE; } } } /* Fill the entry field as if a time separator is in also */ if (bValid) { mp2 = (MPARAM)(((ULONG)mp2 & 0xffffff00) | szTimeSep[0]); return pfnwpEntryField(hwnd, usMsg, mp1, mp2); } break; case 3: /* minutes left digit, 0-5 */ if ((usChr1 > '5') || (usChr1 < '0')) { return MPVOID; } else return pfnwpEntryField(hwnd, usMsg, mp1, mp2); break; case 4: /*minutes right digit, 0-9*/ if ((usChr1 > '9') || (usChr1 < '0')) { return MPVOID; } else { pfnwpEntryField(hwnd, usMsg, mp1, mp2); return pfnwpEntryField(hwnd, EM_SETSEL, MPFROM2SHORT(4,4), MPVOID); } break; } } } } default: return pfnwpEntryField(hwnd, usMsg, mp1, mp2); } }