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);
}
}
