USHORT kbdKeyTranslate( PQMSG pQmsg )
{
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( ucScancode < 54 )
{
BOOL shiftOn = ( fsFlags & KC_SHIFT ) ? TRUE : FALSE;
UCHAR uch = kbdKeyTransTable[ ucScancode ][ shiftOn ];
if( uch != 0 )
{
uch = ( shiftOn ^ isCapsLockOn()) ? toupper( uch ) : tolower( uch );
usCh = MAKEUSHORT( uch, 0 );
//pQmsg->mp1 = MPFROMSH2CH( fsFlags, ucRepeat, ucScancode );
pQmsg->mp2 = MPFROM2SHORT( usCh, usVk );
}
}
return usCh;
}
MRESULT khs_umStoreKeyInfo( HWND hwnd, MPARAM mp1, MPARAM mp2 )
{
PKHSCD pkhscd = WinQueryWindowPtr( hwnd, 0 );
USHORT fsFlags = SHORT1FROMMP( mp1 );
UCHAR ucRepeat = CHAR3FROMMP( mp1 );
UCHAR ucScancode = CHAR4FROMMP( mp1 );
USHORT usCh = SHORT1FROMMP( mp2 );
USHORT usVk = SHORT2FROMMP( mp2 );
fprintf( pkhscd->fp, "fl : %04X, rp : %02d, sc : %02X, ch : %02X, vk : %02X\n",
fsFlags, ucRepeat, ucScancode, usCh, usVk );
fflush( pkhscd->fp );
return 0;
}
// Все переменные - внешние.
VOID ApplierKbdInputHook( HAB Application, PQMSG Message, PBYTE Discarding )
{
// Запоминаем значения в окне ввода пароля.
if( Applier.Settings.Script_after_Logon ) if( Applier.RTSettings.Logon_in_process )
{
// Следим за нажатиями на клавиши.
if( Message->msg == WM_CHAR )
{
// Смотрим, какая клавиша нажата.
BYTE Scan_code = CHAR4FROMMP( Message->mp1 );
SHORT State = SHORT1FROMMP( Message->mp1 );
// Если идет отжатие клавиши:
if( State & KC_KEYUP )
{
// Проверяем клавишу.
BYTE Latin_key = 0;
if( Scan_code != 0 )
if( !( State & KC_CTRL ) ) if( !( State & KC_ALT ) )
Latin_key = 1;
// Если это латинская клавиша:
if( Latin_key )
{
// Узнаем окно рамки.
HWND Frame_window = QueryFrameWindow( Message->hwnd );
// Если оно есть в списке отслеживаемых окон:
for( INT Count = APPLIER_MONITORING_LOGON_WINDOWS - 1; Count >= 0; Count -- )
if( Applier.RTDlgMemory.Logon_windows[ Count ].Window == Frame_window )
{
// Посылаем в очередь сообщение WM_MARK. Когда оно будет получено, окно подготовит значение в поле ввода.
HMQ Message_queue = WinQueryWindowULong( Frame_window, QWL_HMQ );
WinPostQueueMsg( Message_queue, WM_MARK, (MPARAM) MRK_LOGON_VALUES, (MPARAM) Frame_window );
break;
}
}
}
}
}
// Возврат.
return;
}
BOOL EXPENTRY WinHookProc(HAB hab,PQMSG pqmsg,USHORT usRemove )
{
loaded = TRUE;
if ((pqmsg->msg == WM_CHAR) && /* character message */
!(SHORT1FROMMP(pqmsg->mp1) & KC_KEYUP) && /* key down */
(SHORT1FROMMP(pqmsg->mp1) & KC_SCANCODE) && /* valid scan code */
(CHAR4FROMMP(pqmsg->mp1) == 83) && /* . and del on numpad */
(SHORT1FROMMP(pqmsg->mp2) != ',') && /* just make sure we
haven't already
processed it */
(WinGetKeyState(HWND_DESKTOP,VK_NUMLOCK))) /* numlock on */
{
WinPostMsg(pqmsg->hwnd,WM_CHAR,pqmsg->mp1,MPFROM2SHORT(',',SHORT2FROMMP(pqmsg->mp2)));
return(TRUE);
}
return(FALSE);
}
// Message - сообщение.
// Возвращаемое значение: 1, если можно, 0, если нельзя.
BYTE Clicker_PermissionForClicking( PQMSG Message )
{
// Смотрим, какая клавиша нажата.
BYTE Scan_code = CHAR4FROMMP( Message->mp1 );
SHORT State = SHORT1FROMMP( Message->mp1 );
// Смотрим, как установлены биты в State.
if( !( State & KC_KEYUP ) ) return 0;
if( !( State & KC_LONEKEY ) ) return 0;
// Проверяем приложение.
BYTE Permission = 0;
// Узнаем окно рамки.
HWND Frame_window = QueryFrameWindow( Message->hwnd );
// Узнаем имя приложения, создавшего окно.
CHAR Exe_name[ SIZE_OF_NAME ] = ""; GetDetectedExeName( Frame_window, Exe_name );
// Если его удалось определить:
if( Exe_name[ 0 ] != 0 )
{
// Если это окно IRC - надо воспроизвести звук.
if( Clicker.Settings.Keyboard_echo_for_IRC )
if( WindowIsUsedTo( DO_INTERNET_CHAT, Frame_window ) )
Permission = 1;
// Если это окно ICQ - надо воспроизвести звук.
if( Clicker.Settings.Keyboard_echo_for_ICQ )
if( WindowIsUsedTo( DO_CONTACT_PEOPLE, Frame_window ) )
Permission = 1;
}
// Возврат.
return Permission;
}
/**************************************************************************
*
* FUNCTION NAME: ProcessKeyDialog
*
* DESCRIPTION:
*
*
* INPUT PARAMETERS:
* None.
*
* OUTPUT PARAMETERS:
* None.
*
**************************************************************************/
MRESULT EXPENTRY ProcessKeyDialog (HWND hwnd,
ULONG msg,
MPARAM mp1,
MPARAM mp2)
{
USHORT usScanCode;
static ULONG ulButton = UP_TEXT_ID;
static KEYDEFS stLocalDefs;
static PUSHORT pusKeyDef;
switch (msg)
{
case WM_INITDLG :
/* Store the current key settings */
stLocalDefs = gstKeyDefs;
pusKeyDef = &(stLocalDefs.usUpKey);
/* Set the text for each field in the dialog box */
WinSetDlgItemText (hwnd, UP_TEXT_ID,
szScanCode[stLocalDefs.usUpKey]);
WinSetDlgItemText (hwnd, DOWN_TEXT_ID,
szScanCode[stLocalDefs.usDownKey]);
WinSetDlgItemText (hwnd, TURN_TEXT_ID,
szScanCode[stLocalDefs.usTurnKey]);
WinSetDlgItemText (hwnd, THRUST_TEXT_ID,
szScanCode[stLocalDefs.usThrustKey]);
WinSetDlgItemText (hwnd, FIRE_TEXT_ID,
szScanCode[stLocalDefs.usFireKey]);
WinSetDlgItemText (hwnd, SMART_TEXT_ID,
szScanCode[stLocalDefs.usSmartKey]);
WinSetDlgItemText (hwnd, HYPER_TEXT_ID,
szScanCode[stLocalDefs.usHyperKey]);
/* Set the UP button to the clicked state */
WinPostMsg (WinWindowFromID (hwnd , UP_ID), BM_CLICK,
MPFROMSHORT (TRUE), MPVOID);
/* Set the appropriate button toggle */
if (stLocalDefs.fTurnThrust)
{
WinPostMsg (WinWindowFromID (hwnd , TURN_THRUST_ID), BM_CLICK,
MPFROMSHORT (TRUE), MPVOID);
WinSetDlgItemText (hwnd, TURN_ID, "Turn");
WinSetDlgItemText (hwnd, THRUST_ID, "Thrust");
}
else
{
WinPostMsg (WinWindowFromID (hwnd , LEFT_RIGHT_ID), BM_CLICK,
MPFROMSHORT (TRUE), MPVOID);
WinSetDlgItemText (hwnd, TURN_ID, "Left");
WinSetDlgItemText (hwnd, THRUST_ID, "Right");
}
/* Center the dialog box in the frame window of the parent */
CenterDialog (hwnd);
return (0);
case WM_COMMAND :
switch (SHORT1FROMMP (mp1))
{
case DID_OK:
/* Save the key selections in the global list and save them */
gstKeyDefs = stLocalDefs;
WinDismissDlg (hwnd, DID_OK);
return (0);
case DID_CANCEL:
/* Dismiss the dialog without saving the values */
WinDismissDlg (hwnd, DID_CANCEL);
return (0);
case DID_HELP:
/* Display the keys help panel */
WinSendMsg (hwndHelpInstance, HM_DISPLAY_HELP,
MPFROM2SHORT(PANEL_KEYS, NULL),
MPFROMSHORT(HM_RESOURCEID));
return (0);
}
break;
case WM_CONTROL :
switch (SHORT1FROMMP (mp1))
{
case UP_ID:
ulButton = UP_TEXT_ID;
pusKeyDef = &(stLocalDefs.usUpKey);
break;
case DOWN_ID:
ulButton = DOWN_TEXT_ID;
pusKeyDef = &(stLocalDefs.usDownKey);
break;
case TURN_ID:
ulButton = TURN_TEXT_ID;
pusKeyDef = &(stLocalDefs.usTurnKey);
break;
case THRUST_ID:
ulButton = THRUST_TEXT_ID;
pusKeyDef = &(stLocalDefs.usThrustKey);
break;
case FIRE_ID:
ulButton = FIRE_TEXT_ID;
pusKeyDef = &(stLocalDefs.usFireKey);
break;
case SMART_ID:
ulButton = SMART_TEXT_ID;
pusKeyDef = &(stLocalDefs.usSmartKey);
break;
case HYPER_ID:
ulButton = HYPER_TEXT_ID;
pusKeyDef = &(stLocalDefs.usHyperKey);
break;
case TURN_THRUST_ID:
WinSetDlgItemText (hwnd, TURN_ID, "Turn");
WinSetDlgItemText (hwnd, THRUST_ID, "Thrust");
stLocalDefs.fTurnThrust = TRUE;
break;
case LEFT_RIGHT_ID:
WinSetDlgItemText (hwnd, TURN_ID, "Left");
WinSetDlgItemText (hwnd, THRUST_ID, "Right");
stLocalDefs.fTurnThrust = FALSE;
break;
default:
break;
}
/* Take the focus away from the radiobuttons */
WinSetFocus (HWND_DESKTOP, WinWindowFromID (hwnd, UP_TEXT_ID));
break;
case WM_CHAR :
/* Get the scancode and store it in the appropriate place in array */
if (!(SHORT1FROMMP(mp1) & KC_KEYUP))
{
usScanCode = CHAR4FROMMP(mp1);
WinSetDlgItemText (hwnd, ulButton, szScanCode[usScanCode]);
*pusKeyDef = usScanCode;
}
return (0);
default:
break;
}
return (WinDefDlgProc (hwnd, msg, mp1, mp2));
}
static MRESULT EXPENTRY pm_keyset(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
static int set1 = TRUE;
static int id = 0;
switch (msg) {
case WM_INITDLG:
{
int j1, j2;
resources_get_int("JoyDevice1", &j1);
resources_get_int("JoyDevice2", &j2);
WinSendMsg(hwnd, WM_KPROCESS, (void*)!!((j1 | j2) & JOYDEV_KEYSET1), (void*)!!((j1 | j2) & JOYDEV_KEYSET2));
}
break;
case WM_CONTROL:
{
int ctrl = SHORT1FROMMP(mp1);
switch (ctrl) {
case RB_SET1:
case RB_SET2:
if (!(ctrl == RB_SET1 && set1) && !(ctrl == RB_SET2 && !set1)) {
set1 = !set1;
WinSendMsg(hwnd, WM_KENABLECTRL, 0, 0);
WinSendMsg(hwnd, WM_KFILLSPB, 0, 0);
}
break;
case SPB_N:
case SPB_NE:
case SPB_E:
case SPB_SE:
case SPB_S:
case SPB_SW:
case SPB_W:
case SPB_NW:
case SPB_FIRE:
if (SHORT2FROMMP(mp1) == SPBN_SETFOCUS) {
id = ctrl;
}
break;
}
break;
}
case WM_KPROCESS:
if (((int)mp1 ^ (int)mp2) & 1) {
set1 = (int)mp1;
}
WinCheckButton(hwnd, set1 ? RB_SET1 : RB_SET2, 1);
WinEnableControl(hwnd, RB_SET1, (ULONG)mp1);
WinEnableControl(hwnd, RB_SET2, (ULONG)mp2);
WinSendMsg(hwnd, WM_KENABLECTRL, (void*)(!mp1 && !mp2), NULL);
WinSendMsg(hwnd, WM_KFILLSPB, 0, 0);
break;
case WM_TRANSLATEACCEL:
if (id >= SPB_N && id <= SPB_FIRE) {
//
// Returning FALSE and using WM_CHAR doesn't work
// for all keys - I don't know why
//
SetKeyVal(hwnd, id, set1, CHAR4FROMMP(((QMSG*)mp1)->mp1));
return FALSE;
}
break;
case WM_SETKEY:
{
ULONG state1 = mp1 ? 1 : 0;
ULONG state2 = mp2 ? 1 : 0;
WinEnableControl(hwnd, RB_SET1, state1);
WinEnableControl(hwnd, RB_SET2, state2);
WinSendMsg(hwnd, WM_KPROCESS, (void*)state1, (void*)state2);
}
break;
case WM_KENABLECTRL:
WinEnableControl(hwnd, SPB_N, mp1 ? 0 : 1);
WinEnableControl(hwnd, SPB_E, mp1 ? 0 : 1);
WinEnableControl(hwnd, SPB_S, mp1 ? 0 : 1);
WinEnableControl(hwnd, SPB_W, mp1 ? 0 : 1);
WinEnableControl(hwnd, SPB_NE, mp1 ? 0 : 1);
WinEnableControl(hwnd, SPB_SE, mp1 ? 0 : 1);
WinEnableControl(hwnd, SPB_SW, mp1 ? 0 : 1);
WinEnableControl(hwnd, SPB_NW, mp1 ? 0 : 1);
WinEnableControl(hwnd, SPB_FIRE, mp1 ? 0 : 1);
return FALSE;
case WM_KFILLSPB:
UpdateKeyVal(hwnd, SPB_N, set1);
UpdateKeyVal(hwnd, SPB_E, set1);
UpdateKeyVal(hwnd, SPB_S, set1);
UpdateKeyVal(hwnd, SPB_W, set1);
UpdateKeyVal(hwnd, SPB_NE, set1);
UpdateKeyVal(hwnd, SPB_SE, set1);
UpdateKeyVal(hwnd, SPB_SW, set1);
UpdateKeyVal(hwnd, SPB_NW, set1);
UpdateKeyVal(hwnd, SPB_FIRE, set1);
return FALSE;
}
return WinDefDlgProc (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;
}
MRESULT hia_wmChar(HWND hwnd,MPARAM mp1,MPARAM mp2)
{
USHORT fsFlags = SHORT1FROMMP(mp1);
UCHAR ucVkey = CHAR3FROMMP(mp2);
UCHAR ucChar = CHAR1FROMMP(mp2);
UCHAR ucScancode = CHAR4FROMMP(mp1);
HIA *hia = WinQueryWindowPtr(hwnd,WINWORD_INSTANCE);
USHORT ckey;
// printf("HIA:: WM_CHAR\n");
if (fsFlags & KC_KEYUP) return 0L;
if( hia->isHanjaKey != NULL )
{
if( hia->isHanjaKey( fsFlags, ucScancode, ucVkey, ucChar ))
{
if( hia->inbuf->newpos != HIABUF_NONE )
{
HANCHAR hch = SHORT1FROMMR( WinSendMsg( hwnd, HIAM_QUERYWORKINGHCH, 0, 0 ));
HANCHAR hj;
hj = hjselDlg( HWND_DESKTOP, hia->responseTo->hwnd, NULLHANDLE, hch );
if( hj != HCH_SINGLE_SPACE )
hch = hj;
WinSendMsg( hwnd, HIAM_CANCELBUF, 0, 0 );
HIA_NotifyToConnected(hia,HIAN_COMPO_COMPLETE,MPFROMSHORT(hch));
HIA_NotifyToConnected(hia,HIAN_INSERTHCH,MPFROMSHORT(hch));
//WinSendMsg( hwnd, HIAM_COMPLETEHCH, 0, 0 );
//HIA_NotifyToConnected( hia, HIAN_HGHJCONVERT, MPFROMLONG( TRUE ));
}
else
HIA_NotifyToConnected( hia, HIAN_HGHJCONVERT, 0);
return MRFROMLONG( TRUE );
}
}
if( hia->isSpecialCharKey != NULL )
{
if( hia->isSpecialCharKey( fsFlags, ucScancode, ucVkey, ucChar ))
{
SCSELINFO scselInfo = { -1, -1, -1 };
WinSendMsg( hwnd, HIAM_COMPLETEHCH, 0, 0 );
scselDlg( HWND_DESKTOP, hia->responseTo->hwnd, NULLHANDLE, &scselInfo );
if( scselInfo.hch != HCH_SINGLE_SPACE )
{
HIA_NotifyToConnected(hia,HIAN_COMPO_COMPLETE,MPFROMSHORT(scselInfo.hch));
HIA_NotifyToConnected(hia,HIAN_INSERTHCH,MPFROMSHORT(scselInfo.hch));
}
return MRFROMLONG( TRUE );
}
}
if (fsFlags & KC_VIRTUALKEY)
{
switch (ucVkey) {
case VK_SPACE:
WinSendMsg(hwnd,HIAM_COMPLETEHCH,0L,0L);
if (FKC_SHIFTONLY(fsFlags))
WinSendMsg(hwnd,HIAM_CHANGEHANMODE,0L,0L);
else if (FKC_CTRLONLY(fsFlags))
WinSendMsg(hwnd,HIAM_CHANGEKBDTYPE,0L,0L);
else if (FKC_NONE(fsFlags))
HIA_NotifyToConnected(hia,HIAN_INSERTHCH,MPFROM2SHORT(' ',0));
return MRFROMLONG(TRUE); // consumed
break;
case VK_TAB:
WinSendMsg(hwnd,HIAM_COMPLETEHCH,0L,0L);
if (FKC_NONE(fsFlags))
{
HIA_NotifyToConnected(hia,HIAN_INSERTHCH,MPFROM2SHORT('\t',0));
return MPFROMLONG(TRUE); // consumed
} else {
return MPFROMLONG(FALSE);
}
break;
case VK_HOME:
case VK_END:
case VK_LEFT:
case VK_UP:
case VK_DOWN:
case VK_PAGEUP:
case VK_PAGEDOWN:
case VK_PAGEDOWN + 0x90:
case VK_DELETE:
if ((fsFlags & KC_CHAR) && (FKC_NONE(fsFlags))) break; // considering keypad
if (hia->inbuf->newpos != HIABUF_NONE)
WinSendMsg(hwnd,HIAM_COMPLETEHCH,0L,0L);
return MPFROMLONG(FALSE);
break;
case VK_ENTER:
case VK_NEWLINE:
if (hia->inbuf->newpos != HIABUF_NONE)
WinSendMsg(hwnd,HIAM_COMPLETEHCH,0L,0L);
return MPFROMLONG(FALSE); // not consumed
break;
case VK_RIGHT:
if ((fsFlags & KC_CHAR) && (FKC_NONE(fsFlags))) break; // considering keypad
if (hia->inbuf->newpos != HIABUF_NONE)
{
WinSendMsg(hwnd,HIAM_COMPLETEHCH,0L,0L);
return MRFROMLONG(TRUE);
} else {
return MRFROMLONG(FALSE); // NOT consumed
}
break;
case VK_BACKSPACE:
if (hia->inbuf->newpos != HIABUF_NONE)
{
WinSendMsg(hwnd,HIAM_CANCELKEY,0L,0L);
return MRFROMLONG(TRUE);
} else {
return MRFROMLONG(FALSE);
}
break;
case VK_INSERT:
if ((fsFlags & KC_CHAR) && (FKC_NONE(fsFlags))) break; // considering keypad
if (hia->inbuf->newpos != HIABUF_NONE)
WinSendMsg(hwnd,HIAM_COMPLETEHCH,0L,0L);
if (FKC_NONE(fsFlags))
{
WinSendMsg(hwnd,HIAM_CHANGEINSERTMODE,0L,0L);
return MRFROMLONG(TRUE);
} else {
return MRFROMLONG(FALSE);
}
break;
case VK_ESC :
WinSendMsg(hwnd,HIAM_CANCELBUF,0L,0L);
return FALSE;
case VK_SHIFT :
case VK_CTRL :
case VK_ALT :
return FALSE;
} // switch
WinSendMsg( hwnd, HIAM_COMPLETEHCH, 0, 0 );
return FALSE;
} // Virtualkey
if(( fsFlags & ( KC_CTRL | KC_ALT )) || (ucChar < 32) || (ucChar > 127))
{
WinSendMsg( hwnd, HIAM_COMPLETEHCH, 0, 0 );
return FALSE;
}
if (hia->hanmode == HCH_ENG)
{
HIA_NotifyToConnected(hia,HIAN_INSERTHCH,MPFROM2SHORT(ucChar,0));
return MRFROMLONG(TRUE);
}
if ((hia_iskeypadkey(ucScancode))&&(fsFlags & KC_CHAR))
{
WinSendMsg(hwnd,HIAM_COMPLETEHCH,0L,0L);
HIA_NotifyToConnected(hia,HIAN_INSERTHCH,MPFROM2SHORT(ucChar,0));
return MRFROMLONG(TRUE);
}
ucChar = hia_transkey( fsFlags, ucScancode, ucChar );
if (WinGetKeyState(HWND_DESKTOP,VK_CAPSLOCK))
{
if (fsFlags & KC_SHIFT)
{
ucChar = toupper(ucChar);
} else {
ucChar = tolower(ucChar);
}
}
ckey = hia_convertkey(hia->kbdtype,ucChar);
{
HANCHAR completedHch;
HANCHAR workingHch;
if (ckey & 0x80) // if hangul key
{
ULONG oldbufState = hia->inbuf->newpos;
if (hia->kbdtype == HAN_KBD_2)
completedHch = HIAAutomata2(hia,ckey);
else
completedHch = HIAAutomata3(hia,ckey);
workingHch = SHORT1FROMMR(WinSendMsg(hwnd,HIAM_QUERYWORKINGHCH,0L,0L));
if (completedHch) // if hch completed
{
HIA_NotifyToConnected(hia,HIAN_COMPO_COMPLETE,MPFROM2SHORT(completedHch,workingHch));
HIA_NotifyToConnected(hia,HIAN_INSERTHCH,MPFROM2SHORT(completedHch,workingHch));
if (workingHch) // begin composition of new hch
HIA_NotifyToConnected(hia,HIAN_COMPO_BEGIN,MPFROM2SHORT(completedHch,workingHch));
} else { // if hch not completed
if (workingHch) // if exist composing hch
if (oldbufState)
HIA_NotifyToConnected(hia,HIAN_COMPO_STEP,
MPFROM2SHORT(0,workingHch));
else
HIA_NotifyToConnected(hia,HIAN_COMPO_BEGIN,
MPFROM2SHORT(0,workingHch));
}
return MRFROMLONG(TRUE); // consumed
} else { // !@#$%^&*() ,etc
WinSendMsg(hwnd,HIAM_COMPLETEHCH,0L,0L);
HIA_NotifyToConnected(hia,HIAN_INSERTHCH,
MPFROM2SHORT(ckey,0));
return MRFROMLONG(TRUE); // consumed
}
}
return MRFROMLONG(FALSE); // not consumed
}
MRESULT EXPENTRY icqFrameWindow(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
switch(msg)
{
case WM_DDE_INITIATEACK:
return (MRESULT) icqDDEInitiateAck(hwnd, (HWND)mp1, (PDDEINIT)mp2);
case WM_DDE_DATA:
DBGMessage("WM_DDE_DATA");
icqDDEData(hwnd, (PDDESTRUCT) mp2);
break;
case WM_CLOSE:
DBGMessage("WM_CLOSE");
close(hwnd);
break;
case WM_CREATE:
icqskin_cfgWindow(hwnd,ICQFRAME,0);
break;
case WM_DESTROY:
destroy(hwnd);
break;
case WM_ERASEBACKGROUND:
erase(hwnd,(HPS) mp1, (PRECTL) mp2);
break;
case WM_SIZE:
resize(hwnd,SHORT1FROMMP(mp2),SHORT2FROMMP(mp2));
broadcast(hwnd,WMICQ_AUTOSIZE,0,0);
break;
case WM_PAINT:
paint(hwnd);
break;
case WM_SETICON:
WinSendMsg(WinQueryWindow(hwnd,QW_PARENT),msg,mp1,mp2);
break;
case WM_COMMAND:
action(hwnd,SHORT1FROMMP(mp1), SHORT1FROMMP(mp2));
break;
case WM_PRESPARAMCHANGED:
ppchanged(hwnd,LONGFROMMP(mp1));
break;
case WM_SETWINDOWPARAMS:
return setparm(hwnd, PVOIDFROMMP(mp1), mp2);
case WMICQ_SETNAME:
// strncpy( ((ICQFRAME *) WinQueryWindowPtr(hwnd,0))->name, (const char *) mp1, 19);
((ICQFRAME *) WinQueryWindowPtr(hwnd,0))->name = (const char *) mp1;
break;
case WMICQ_SETICQHANDLE:
DBGTracex(mp1);
((ICQFRAME *) WinQueryWindowPtr(hwnd,0))->icq = (HICQ) mp1;
break;
case WMICQ_GETICQHANDLE:
return (MRESULT) ((ICQFRAME *) WinQueryWindowPtr(hwnd,0))->icq;
case WMICQ_SETBUTTONTBL:
setbuttons(hwnd,(const struct icqButtonTable *) mp1, (int) mp2);
break;
case WMICQ_QUERYPALLETE:
return (MRESULT) ((ICQFRAME *) WinQueryWindowPtr(hwnd,0))->pal;
case WMICQ_EVENT: // MP1 = type,code,user MP2 = parm
event(hwnd,CHAR3FROMMP(mp1),CHAR4FROMMP(mp1),SHORT1FROMMP(mp1),(ULONG) mp2);
break;
case WMICQ_SELECTPAL:
icqskin_loadPallete( (HPS) mp1, 0, ((ICQFRAME *) WinQueryWindowPtr(hwnd,0))->pal);
break;
case 0x041E:
return WinDefWindowProc(hwnd, msg, mp1, mp2);
case 0x041F:
return WinDefWindowProc(hwnd, msg, mp1, mp2);
case WM_BEGINDRAG:
return beginDrag(hwnd, (POINTS *) &mp1);
case WM_ENDDRAG:
return endDrag(hwnd);
case WM_TIMER:
timer(hwnd);
break;
#ifdef SKINNED_GUI
case WMICQ_QUERYBGIMAGE:
return (MRESULT) ((ICQFRAME *) WinQueryWindowPtr(hwnd,0))->bg;
#else
case WMICQ_QUERYBGIMAGE:
return (MRESULT) NO_IMAGE;
#endif
case WM_OWNERPOSCHANGE:
DBGMessage("WM_OWNERPOSCHANGE");
return WinDefWindowProc(hwnd,msg,mp1,mp2);
case WM_MOUSEMOVE:
if(WinQueryCapture(HWND_DESKTOP) == hwnd);
saveMouse(hwnd,SHORT1FROMMP(mp1),SHORT2FROMMP(mp1));
return WinDefWindowProc(hwnd,msg,mp1,mp2);
case WMICQ_CLEAR:
clearSkin( (ICQFRAME *) WinQueryWindowPtr(hwnd,0));
break;
case WMICQ_LOADSKIN:
loadSkin(hwnd,(const char *) mp1, (SKINFILESECTION *) mp2);
break;
case WMICQ_SKINCHILDS:
loadSkin4Childs(hwnd,(const char *) mp1, (SKINFILESECTION *) mp2);
break;
case WMICQ_RESTORE:
restoreWindow(hwnd,(const char *) mp1,SHORT1FROMMP(mp2),SHORT2FROMMP(mp2));
break;
case WMICQ_STORE:
storeWindow(hwnd,(const char *) mp1);
break;
case WMICQ_CONFIGURE:
configure(hwnd,(int) mp1);
break;
case WMICQ_SETMSGCHILD:
createchild(hwnd, (const MSGCHILD *) mp1, SHORT1FROMMP(mp2));
break;
case WMICQ_SKINELEMENT:
skinElement(hwnd,(HWND) mp1, (const char **) mp2);
break;
case WMICQ_DRAWCONTENTS:
break;
case WMICQ_AUTOSIZE:
autoSize(hwnd);
break;
case WMICQ_SIZEBUTTONS:
return (MRESULT) sizeButtonBar(hwnd,SHORT1FROMMP(mp1),SHORT2FROMMP(mp1),(const USHORT *) mp2);
case WMICQ_INVALIDATE:
DBGMessage("WMICQ_INVALIDATE");
WinInvalidateRect(hwnd,NULL,TRUE);
break;
/*---[ SysTray ]--------------------------------------------*/
case WM_BUTTON2CLICK | 0x2000:
icqShowPopupMenu(((ICQFRAME *) WinQueryWindowPtr(hwnd,0))->icq, 0, ICQMNU_MODES, 0, 0);
return (MRESULT) TRUE;
case WM_BUTTON1CLICK | 0x2000:
openMessage(((ICQFRAME *) WinQueryWindowPtr(hwnd,0))->icq);
return (MRESULT) TRUE;
case WM_TRAYEXIT: // When tray exits/crashes, it posts WM_TRAYEXIT (0xCD20) to all tray windows.
icqDisableSysTray(((ICQFRAME *) WinQueryWindowPtr(hwnd,0))->icq);
return (MRESULT) TRUE;
/*---[ Default window processing ]--------------------------*/
default:
return WinDefWindowProc(hwnd,msg,mp1,mp2);
}
return 0;
}
ULONG HEOptions(HWND hwnd)
{
HWND hwndDlg;
ULONG TextFormat = (ULONG) WinSendMsg(hwndHMLE,HMLM_QUERYTEXTFORMAT,0L,0L);
ULONG HanType = (ULONG) WinSendMsg(hwndHMLE,HMLM_QUERYHANTYPE,0L,0L);
ULONG ulrc = ( ULONG ) WinSendMsg( hwndHMLE, HMLM_QUERYWRAP, 0, 0 );
//int old_eoltype = TextFormat;
//int old_hantype = HanType;
BOOL wordWrap = CHAR3FROMMP( ulrc );
BOOL wordProtect = CHAR4FROMMP( ulrc );
int wordWrapSize = SHORT1FROMMR( ulrc );
CHAR size[ 10 ];
hwndDlg = WinLoadDlg(HWND_DESKTOP,hwnd,&WinDefDlgProc,NULLHANDLE,IDD_OPTIONS,NULL);
if (TextFormat==HMLE_EOL_CRLF)
WinSendMsg(WinWindowFromID(hwndDlg,IDB_TF_CRLF),BM_SETCHECK,MPFROMLONG(1L),0L);
else
WinSendMsg(WinWindowFromID(hwndDlg,IDB_TF_LF),BM_SETCHECK,MPFROMLONG(1L),0L);
if (HanType==HMLE_HAN_KS)
WinSendMsg(WinWindowFromID(hwndDlg,IDB_HT_KS),BM_SETCHECK,MPFROMLONG(1L),0L);
else
WinSendMsg(WinWindowFromID(hwndDlg,IDB_HT_SY),BM_SETCHECK,MPFROMLONG(1L),0L);
WinSendMsg( WinWindowFromID( hwndDlg, IDB_WORDWRAP ), BM_SETCHECK,
MPFROMLONG( SHORT1FROMMR( wordWrap )), 0 );
_itoa( wordWrapSize, size, 10 );
WinSetWindowText( WinWindowFromID( hwndDlg, IDEF_WORDWRAP_SIZE ), size );
//WinSetFocus(HWND_DESKTOP,hwndDlg);
ulrc = WinProcessDlg(hwndDlg);
if (ulrc == DID_OK)
{
TextFormat = (ULONG) WinSendMsg(WinWindowFromID(hwndDlg,IDB_TF_CRLF),BM_QUERYCHECKINDEX,0L,0L);
HanType = (ULONG) WinSendMsg(WinWindowFromID(hwndDlg,IDB_HT_KS),BM_QUERYCHECKINDEX,0L,0L);
if (TextFormat == 1)
{
WinSendMsg(hwndHMLE,HMLM_SETTEXTFORMAT,MPFROMLONG(HMLE_EOL_CRLF),0L);
WinPostMsg(hwndStatbar,STATBAR_USERM_SETEOLTYPE,MPFROMLONG(HMLE_EOL_CRLF),0L);
} else {
WinSendMsg(hwndHMLE,HMLM_SETTEXTFORMAT,MPFROMLONG(HMLE_EOL_LF),0L);
WinPostMsg(hwndStatbar,STATBAR_USERM_SETEOLTYPE,MPFROMLONG(HMLE_EOL_LF),0L);
}
if (HanType == 1)
{
WinSendMsg(hwndHMLE,HMLM_SETHANTYPE,MPFROMLONG(HMLE_HAN_KS),0L);
WinPostMsg(hwndStatbar,STATBAR_USERM_SETHANTYPE,MPFROMLONG(HMLE_HAN_KS),0L);
} else {
WinSendMsg(hwndHMLE,HMLM_SETHANTYPE,MPFROMLONG(HMLE_HAN_SY),0L);
WinPostMsg(hwndStatbar,STATBAR_USERM_SETHANTYPE,MPFROMLONG(HMLE_HAN_SY),0L);
}
wordWrap = ( BOOL )WinSendDlgItemMsg( hwndDlg, IDB_WORDWRAP, BM_QUERYCHECK, 0, 0 );
WinQueryWindowText( WinWindowFromID( hwndDlg, IDEF_WORDWRAP_SIZE ), sizeof( size ), size );
wordWrapSize = atoi( size );
if(( wordWrapSize != 0 ) && ( wordWrapSize < MIN_WORDWRAP_SIZE ))
wordWrapSize = MIN_WORDWRAP_SIZE;
WinSendMsg( hwndHMLE, HMLM_SETWRAP, MPFROM2SHORT( wordWrap, wordProtect ), MPFROMSHORT( wordWrapSize ));
}
WinDestroyWindow(hwndDlg);
return 0L;
}
MRESULT EXPENTRY FlyWndProc (HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
SIZEL sizl;
int rc, key, mou_r, mou_c, mou_ev, new_vio_rows, new_vio_cols;
int deltaX, deltaY, pix_rows, pix_cols, new_x0, new_y0;
static int mou_c1=-1, mou_r1=-1;
struct _item *L;
HWND hwndMenu;
SWP swp;
QMSG *qmsg;
USHORT vk, fl;
switch (msg)
{
case WM_CREATE:
hdc = WinOpenWindowDC (hwnd);
sizl.cx = sizl.cy = 0;
grab_video ();
hps = GpiCreatePS (hab, hdc, &sizl, PU_PELS | GPIF_DEFAULT |
GPIT_MICRO | GPIA_ASSOC);
rc = VioCreatePS (&hvps, 80, 25, 0, 1, 0);
VioGetDeviceCellSize (&cyChar, &cxChar, hvps);
set_cursor (0);
VioSetCurType (pci, hvps);
release_video ();
DosPostEventSem (hev_VideoReady);
return 0;
case WM_MOUSEMOVE: mou_ev = MOUEV_MOVE; goto MOUSE;
case WM_BUTTON1CLICK: mou_ev = MOUEV_B1SC; goto MOUSE;
case WM_BUTTON1DBLCLK: mou_ev = MOUEV_B1DC; goto MOUSE;
case WM_BUTTON1MOTIONSTART: mou_ev = MOUEV_B1MS; goto MOUSE;
case WM_BUTTON1MOTIONEND: mou_ev = MOUEV_B1ME; goto MOUSE;
case WM_BUTTON1DOWN: mou_ev = MOUEV_B1DN; goto MOUSE;
case WM_BUTTON1UP: mou_ev = MOUEV_B1UP; goto MOUSE;
case WM_BUTTON2CLICK: mou_ev = MOUEV_B2SC; goto MOUSE;
case WM_BUTTON2DBLCLK: mou_ev = MOUEV_B2DC; goto MOUSE;
case WM_BUTTON2MOTIONSTART: mou_ev = MOUEV_B2MS; goto MOUSE;
case WM_BUTTON2MOTIONEND: mou_ev = MOUEV_B2ME; goto MOUSE;
case WM_BUTTON2DOWN: mou_ev = MOUEV_B2DN; goto MOUSE;
case WM_BUTTON2UP: mou_ev = MOUEV_B2UP; goto MOUSE;
case WM_BUTTON3DBLCLK: mou_ev = MOUEV_B3DC; goto MOUSE;
case WM_BUTTON3CLICK: mou_ev = MOUEV_B3SC; goto MOUSE;
case WM_BUTTON3MOTIONSTART: mou_ev = MOUEV_B3MS; goto MOUSE;
case WM_BUTTON3MOTIONEND: mou_ev = MOUEV_B3ME; goto MOUSE;
case WM_BUTTON3DOWN: mou_ev = MOUEV_B3DN; goto MOUSE;
case WM_BUTTON3UP: mou_ev = MOUEV_B3UP; goto MOUSE;
MOUSE:
if (fl_opt.mouse_active != TRUE) break;
mou_r = vio_rows - 1 - (SHORT2FROMMP (mp1)/cyChar);
mou_c = SHORT1FROMMP (mp1)/cxChar;
if (mou_r < 0 || mou_c < 0) break;
// prevent MOUEV_MOVE message with same coordinates
if (mou_ev == MOUEV_MOVE && mou_r == mou_r1 && mou_c == mou_c1) break;
mou_r1 = mou_r, mou_c1 = mou_c;
que_put (FMSG_BASE_MOUSE + FMSG_BASE_MOUSE_EVTYPE*mou_ev +
FMSG_BASE_MOUSE_X*mou_c + FMSG_BASE_MOUSE_Y*mou_r);
break;
case WM_PAINT:
WinBeginPaint (hwnd, hps, NULL);
grab_video ();
VioShowBuf (0, 2 * vio_rows * vio_cols, hvps);
release_video ();
WinEndPaint (hps);
return 0;
case WM_CHAR:
if (SHORT1FROMMP (mp1) & KC_KEYUP) return 0;
if (SHORT2FROMMP (mp2) == VK_SHIFT ||
SHORT2FROMMP (mp2) == VK_CTRL ||
SHORT2FROMMP (mp2) == VK_ALT) return 0;
key = pmkey2asvkey (SHORT2FROMMP(mp2), CHAR4FROMMP(mp1), SHORT1FROMMP(mp2),
CHAR3FROMMP(mp1), SHORT1FROMMP(mp1));
if (key != -1) que_put (key);
return 0;
case WM_TRANSLATEACCEL:
qmsg = (QMSG *)mp1;
vk = SHORT2FROMMP (qmsg->mp2);
fl = SHORT1FROMMP (qmsg->mp1) & (KC_ALT | KC_SHIFT | KC_CTRL | KC_KEYUP);
if (vk == VK_MENU || vk == VK_F1) return FALSE;
//if ((fl & KC_ALT) && vk >= VK_F1 && vk <= VK_F24) return FALSE;
break;
case WM_CLOSE:
que_put (FMSG_BASE_SYSTEM +
FMSG_BASE_SYSTEM_TYPE*SYSTEM_QUIT);
return 0;
case WM_SIZE:
if (cxChar != 0 && cyChar != 0)
{
pix_rows = SHORT2FROMMP (mp2);
pix_cols = SHORT1FROMMP (mp2);
new_vio_rows = pix_rows / cyChar;
new_vio_cols = pix_cols / cxChar;
if (new_vio_rows != vio_rows || new_vio_cols != vio_cols)
{
grab_video ();
VioAssociate (0, hvps);
VioDestroyPS (hvps);
rc = VioCreatePS (&hvps, new_vio_rows, new_vio_cols, 0, 1, 0);
VioSetDeviceCellSize (cyChar, cxChar, hvps);
VioGetDeviceCellSize (&cyChar, &cxChar, hvps);
rc = VioAssociate (hdc, hvps);
VioSetCurType (pci, hvps);
release_video ();
que_put (FMSG_BASE_SYSTEM + FMSG_BASE_SYSTEM_TYPE*SYSTEM_RESIZE +
FMSG_BASE_SYSTEM_INT2*new_vio_rows + FMSG_BASE_SYSTEM_INT1*new_vio_cols);
}
deltaX = new_vio_cols*cxChar - pix_cols;
deltaY = new_vio_rows*cyChar - pix_rows;
//if (deltaX != 0 || deltaY != 0)
if (abs(deltaX) > MAX_DELTA || abs(deltaY) > MAX_DELTA)
{
WinPostMsg (hwndFrame, WM_FLY_RESIZE,
MPFROM2SHORT (SHORTBASE+deltaX, SHORTBASE+deltaY), NULL);
}
}
WinDefAVioWindowProc (hwnd, msg, (ULONG)mp1, (ULONG)mp2);
return 0;
case WM_COMMAND:
que_put (FMSG_BASE_MENU + LOUSHORT (mp1));
break;
case WM_FLY_LOADMENU:
L = PVOIDFROMMP (mp1);
// obtain handle for window menu
hwndMenu = WinWindowFromID (WinQueryWindow (hwnd, QW_PARENT), FID_MENU);
fill_submenu (hwndMenu, L);
fly_active_menu = L;
break;
case WM_FLY_UNLOADMENU:
L = PVOIDFROMMP (mp1);
// obtain handle for window menu
hwndMenu = WinWindowFromID (WinQueryWindow (hwnd, QW_PARENT), FID_MENU);
empty_submenu (hwndMenu, L);
fly_active_menu = NULL;
break;
case WM_FLY_RESIZE:
deltaX = SHORT1FROMMP (mp1) - SHORTBASE;
deltaY = SHORT2FROMMP (mp1) - SHORTBASE;
rc = WinQueryWindowPos (hwndFrame, &swp);
rc = WinSetWindowPos (hwndFrame, 0, swp.x, swp.y-deltaY, swp.cx+deltaX, swp.cy+deltaY, SWP_SIZE|SWP_MOVE);
break;
case WM_FLY_MOVE_CANVAS:
new_x0 = SHORT1FROMMP (mp1) - SHORTBASE;
new_y0 = SHORT2FROMMP (mp1) - SHORTBASE;
rc = WinQueryWindowPos (hwndFrame, &swp);
WinSetWindowPos (hwndFrame, 0, new_x0, new_y0-swp.cy, 0, 0, SWP_MOVE);
//DosPostEventSem (hev_VideoReady);
break;
case WM_FLY_MENU_CHSTATUS:
hwndMenu = WinWindowFromID (WinQueryWindow (hwnd, QW_PARENT), FID_MENU);
WinEnableMenuItem (hwndMenu, SHORT1FROMMP(mp1), SHORT2FROMMP(mp1));
item_status_change++;
break;
case WM_FLY_MENU_CHSTATE:
hwndMenu = WinWindowFromID (WinQueryWindow (hwnd, QW_PARENT), FID_MENU);
WinSendMsg (hwndMenu, MM_SETITEMATTR, MPFROM2SHORT (SHORT1FROMMP(mp1), TRUE),
MPFROM2SHORT (MIA_CHECKED, SHORT2FROMMP(mp1) ? MIA_CHECKED : 0));
break;
case WM_DESTROY:
grab_video ();
VioAssociate (0, hvps);
VioDestroyPS (hvps);
GpiDestroyPS (hps);
release_video ();
que_put (FMSG_BASE_SYSTEM +
FMSG_BASE_SYSTEM_TYPE*SYSTEM_DIE);
return 0;
}
return WinDefWindowProc (hwnd, msg, mp1, mp2);
}
// Все переменные - внешние.
VOID RoomsKbdInputHook( HAB Application, PQMSG Message, PBYTE Discarding )
{
// Если надо добавить комнаты к рабочему столу:
if( Rooms.Settings.Create_Rooms )
{
// Переходим в другую комнату при нажатии на цифровые клавиши. Посылаем сообщение в поток и сбрасываем пришедшее сообщение.
if( Rooms.Settings.Switch_by_keyboard )
if( Message->msg == WM_CHAR )
{
// Смотрим, какая клавиша нажата.
BYTE Scan_code = CHAR4FROMMP( Message->mp1 );
SHORT State = SHORT1FROMMP( Message->mp1 );
// Если идет нажатие клавиши:
if( !( State & KC_KEYUP ) ) if( !( State & KC_PREVDOWN ) )
{
// Узнаем, в какую комнату надо перейти.
INT Room = 0;
// Должна быть нажата клавиша Shift и цифровая клавиша.
if( State & KC_SHIFT ) if( ShiftIsPressed() )
{
if( Scan_code == SC_NUM_5 ) Room = SHELL_ROOM;
if( Scan_code == SC_NUM_8 ) Room = NORTHERN_ROOM;
if( Scan_code == SC_NUM_4 ) Room = WESTERN_ROOM;
if( Scan_code == SC_NUM_6 ) Room = EASTERN_ROOM;
if( Scan_code == SC_NUM_2 ) Room = SOUTHERN_ROOM;
if( Scan_code == SC_NUM_7 || Scan_code == SC_NUM_9 ||
Scan_code == SC_NUM_1 || Scan_code == SC_NUM_3 ) Room = CURRENT_ROOM;
}
// Если вызвана заставка - действие выполнять не надо.
if( Room ) if( SystemIsLocked() ) { Room = 0; *Discarding = 1; }
// Если надо переключиться в другую комнату:
if( Room )
{
// Посылаем сообщение в поток.
if( Room != CURRENT_ROOM ) WinPostQueueMsg( Enhancer.Modules.Rooms->Message_queue, SM_GO_TO_ROOM, (MPARAM) Room, 0 );
// Сообщение должно быть сброшено.
*Discarding = 1;
}
}
}
// Добиваемся правильной работы потоков после перехода между комнатами.
if( Rooms.Settings.Synchronize_arranger_and_rooms )
{
// Если была нажата любая клавиша - считаем, что смена комнат завершена.
if( Message->msg == WM_CHAR )
{
// Смотрим, какая клавиша нажата.
BYTE Scan_code = CHAR4FROMMP( Message->mp1 );
SHORT State = SHORT1FROMMP( Message->mp1 );
// Если идет нажатие клавиши:
if( !( State & KC_KEYUP ) ) if( !( State & KC_PREVDOWN ) )
{
// Если эта клавиша не используется дл переключения между комнатами - смена комнат завершена.
if( Scan_code < SC_NUM_FIRST || Scan_code > SC_NUM_LAST )
Rooms.Settings.Synchronize_arranger_and_rooms = 0;
}
}
}
}
// Возврат.
return;
}
/*����������������������������������������������������������������������������*/
PSZ
MpFormat(MPARAM mpValue,
MP_FORMAT mpFormat,
PSZ pszWhere)
{
/**************************************************************************
* Local data
**************************************************************************/
CHAR szC1[32],
szC2[32],
szC3[32],
szC4[32];
/**************************************************************************
* Locate control data for this MP format specification
**************************************************************************/
PMPF_CONTROL pMPF = MpFind(mpFormat);
/**************************************************************************
* Process based on MP format specified
**************************************************************************/
switch(pMPF->mpMethod)
{
/**************************************************************************
* Format as one 32 bit value
**************************************************************************/
case As_32:
sprintf(pszWhere,
pMPF->pszFormat,
mpValue);
break;
/**************************************************************************
* Format as two 16 bit values
**************************************************************************/
case As_16_16:
MpFormat(mpValue, MP_32H, pszWhere);
strcat(pszWhere, ": ");
sprintf( pszWhere + strlen(pszWhere),
pMPF->pszFormat,
SHORT2FROMMP(mpValue),
SHORT1FROMMP(mpValue)
);
break;
/**************************************************************************
* Format as 16 bit and two 8 bit values
**************************************************************************/
case As_16_8_8:
MpFormat(mpValue, MP_32H, pszWhere);
strcat(pszWhere, ": ");
sprintf( pszWhere + strlen(pszWhere),
pMPF->pszFormat,
SHORT2FROMMP(mpValue),
CHAR2FROMMP(mpValue),
CHAR1FROMMP(mpValue)
);
break;
/**************************************************************************
* Format as 16 bit and two character values
**************************************************************************/
case As_16_C_C:
MpFormat(mpValue, MP_32H, pszWhere);
strcat(pszWhere, ": ");
sprintf( pszWhere + strlen(pszWhere),
pMPF->pszFormat,
SHORT2FROMMP(mpValue),
MpAsCharacter( CHAR2FROMMP(mpValue), szC1 ),
MpAsCharacter( CHAR1FROMMP(mpValue), szC2 )
);
break;
/**************************************************************************
* Format as two 8 bit and 16 bit values
**************************************************************************/
case As_8_8_16:
MpFormat(mpValue, MP_32H, pszWhere);
strcat(pszWhere, ": ");
sprintf( pszWhere + strlen(pszWhere),
pMPF->pszFormat,
CHAR4FROMMP(mpValue),
CHAR3FROMMP(mpValue),
SHORT1FROMMP(mpValue)
);
break;
/**************************************************************************
* Format as two character and 16 bit values
**************************************************************************/
case As_C_C_16:
MpFormat(mpValue, MP_32H, pszWhere);
strcat(pszWhere, ": ");
sprintf( pszWhere + strlen(pszWhere),
pMPF->pszFormat,
MpAsCharacter( CHAR4FROMMP(mpValue), szC1 ),
MpAsCharacter( CHAR3FROMMP(mpValue), szC2 ),
SHORT1FROMMP(mpValue)
);
break;
/**************************************************************************
* Format as four 8 bit values
**************************************************************************/
case As_8_8_8_8:
MpFormat(mpValue, MP_32H, pszWhere);
strcat(pszWhere, ": ");
sprintf( pszWhere + strlen(pszWhere),
pMPF->pszFormat,
CHAR4FROMMP(mpValue),
CHAR3FROMMP(mpValue),
CHAR2FROMMP(mpValue),
CHAR1FROMMP(mpValue)
);
break;
/**************************************************************************
* Format as four character values
**************************************************************************/
case As_C_C_C_C:
MpFormat(mpValue, MP_32H, pszWhere);
strcat(pszWhere, ": ");
sprintf( pszWhere + strlen(pszWhere),
pMPF->pszFormat,
MpAsCharacter( CHAR4FROMMP(mpValue), szC1 ),
MpAsCharacter( CHAR3FROMMP(mpValue), szC2 ),
MpAsCharacter( CHAR2FROMMP(mpValue), szC3 ),
MpAsCharacter( CHAR1FROMMP(mpValue), szC4 )
);
break;
}
/**************************************************************************
* Return where formatted MP text went
**************************************************************************/
return(pszWhere);
}
MRESULT EXPENTRY wndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
PGROPDATA pGrop = (PGROPDATA)WinQueryWindowULong( hwnd, 0 );
switch( msg )
{
case WM_ACTIVATE:
_wmActive( pGrop, (BOOL)mp1 );
break;
case WM_SETFOCUS:
if ( pGrop->stCallback.fnActive != NULL )
pGrop->stCallback.fnActive( pGrop, GROUP_ACTIVATE_FOCUS,
LONGFROMMP(mp2) );
break;
case WM_DESTROY:
break;
case WM_CLOSE:
/* if ( ( pGrop->stCallback.fnClose != NULL ) &&
!pGrop->stCallback.fnClose( pGrop ) )
return (MRESULT)FALSE;*/
if ( pGrop->fFullscreen && pGrop->fActive )
_setDesktop( pGrop );
_captureMouse( pGrop, FALSE );
break;
case WM_PAINT:
{
RECTL rctl;
HPS hps;
hps = WinBeginPaint( hwnd, 0, &rctl );
WinFillRect( hps, &rctl, CLR_BLACK );
WinEndPaint( hps );
if ( pGrop->fInternalResize )
debugCP( "WM_PAINT & fInternalResize" );
// else
pGrop->pVideoSys->fnUpdate( pGrop->pVSData, pGrop, 0, NULL );
}
return (MRESULT)FALSE;
case WM_SIZE:
if ( pGrop->lSkipWinResize > 0 )
{
pGrop->lSkipWinResize--;
break;
}
if ( !pGrop->fFullscreen && !pGrop->fInternalResize && pGrop->fActive &&
(pGrop->stUserMode.ulFlags & GROP_MODEFL_RESIZABLE) != 0 &&
pGrop->stCallback.fnSize != NULL )
pGrop->stCallback.fnSize( pGrop, SHORT1FROMMP(mp2), SHORT2FROMMP(mp2) );
break;
case WM_VRNENABLED:
_calcViewRect( pGrop, FALSE );
_setVisibleRegion( pGrop, TRUE );
return (MRESULT)TRUE;
case WM_VRNDISABLED:
_setVisibleRegion( pGrop, FALSE );
return (MRESULT)TRUE;
case WM_MOUSEMOVE:
if ( pGrop->lSkipMouseMove > 0 )
pGrop->lSkipMouseMove--;
else
{
if ( pGrop->fInternalResize )
debugCP( "WM_MOUSEMOVE & fInternalResize" );
_wmMouseMove( pGrop, SHORT1FROMMP(mp1), SHORT2FROMMP(mp1) );
}
return (MRESULT)FALSE;
case WM_BUTTON1DOWN:
case WM_BUTTON1DBLCLK:
_wmMouseButton( pGrop, 0, TRUE );
break;
case WM_BUTTON1UP:
_wmMouseButton( pGrop, 0, FALSE );
break;
case WM_BUTTON2DOWN:
case WM_BUTTON2DBLCLK:
_wmMouseButton( pGrop, 1, TRUE );
break;
case WM_BUTTON2UP:
_wmMouseButton( pGrop, 1, FALSE );
break;
case WM_BUTTON3DOWN:
case WM_BUTTON3DBLCLK:
_wmMouseButton( pGrop, 2, TRUE );
break;
case WM_BUTTON3UP:
_wmMouseButton( pGrop, 2, FALSE );
break;
case WM_TRANSLATEACCEL:
// ALT and acceleration keys not allowed (must be processed in WM_CHAR)
if ( mp1 == NULL || ((PQMSG)mp1)->msg != WM_CHAR )
break;
return (MRESULT)FALSE;
case WM_CHAR:
if ( pGrop->stCallback.fnKeyboard != NULL )
{
ULONG ulFlags = SHORT1FROMMP(mp1); // WM_CHAR flags
pGrop->stCallback.fnKeyboard(
pGrop, (ulFlags & KC_SCANCODE) == 0 ? 0 : CHAR4FROMMP(mp1),
(ulFlags & KC_CHAR) == 0 ? 0 : SHORT1FROMMP(mp2), ulFlags );
}
return (MRESULT)TRUE;
case WM_GROP_QUERY:
_wmGropQuery( pGrop, (PGROPQUERY)PVOIDFROMMP(mp1) );
return (MRESULT)TRUE;
}
return WinDefWindowProc( hwnd, msg, mp1, mp2 );
}
