void MifarePlusSpringCardCommandsSL1::loadKey(std::shared_ptr<Location> location, std::shared_ptr<Key> key, MifarePlusKeyType keytype)
{
if (keytype == KT_KEY_CRYPTO1_A)
MifarePCSCCommands::loadKey(location, ConvertKey(key), KT_KEY_A);
else
MifarePCSCCommands::loadKey(location, ConvertKey(key), KT_KEY_B);
}
STATIC ULONG SingleString_HandleEvent(struct IClass *cl, Object *obj, struct MUIP_HandleEvent *msg)
{
if (msg->imsg && msg->imsg->Class == IDCMP_RAWKEY)
{
UWORD code;
if (msg->imsg->Code == CURSORUP)
{
set(obj,MUIA_SingleString_Event, MUIV_SingleString_Event_CursorUp);
return MUI_EventHandlerRC_Eat;
}
if (msg->imsg->Code == CURSORDOWN)
{
set(obj,MUIA_SingleString_Event, MUIV_SingleString_Event_CursorDown);
return MUI_EventHandlerRC_Eat;
}
code = ConvertKey(msg->imsg);
if (code == '\b')
{
if (xget(obj,MUIA_String_BufferPos) == 0)
{
set(obj,MUIA_SingleString_Event, MUIV_SingleString_Event_ContentsToPrevLine);
return MUI_EventHandlerRC_Eat;
}
}
}
return 0;
}
bool KeyBindConfig::WriteToFile( const std::string path, const char* data )
{
std::ofstream write;
std::string txt;
write.open(path);
for (unsigned int i = 0; i < KEY_CAP; i++)
{
//Find the key string
if(ConvertKey(txt, data[i]))
write<<txt;
else
write<<data[i];
write<<"="<<GetCommand(i);
if(i+1 < KEY_CAP)
write<<"\n";
}
write.close();
return true;
}
void RenderWidget::keyReleaseEvent(QKeyEvent* event)
{
he::io::IKeyboard* keyboard(CONTROLS->getKeyboard(getHandle()));
if (event->isAutoRepeat() == false)
{
he::io::Key key(ConvertKey(event->key()));
if (key != he::io::Key_Unknown)
keyboard->KeyReleased(key);
}
QWidget::keyReleaseEvent(event);
}
void RenderWidget::keyPressEvent(QKeyEvent* event)
{
he::io::IKeyboard* keyboard(CONTROLS->getKeyboard(getHandle()));
if (event->isAutoRepeat() == false)
{
he::io::Key key(ConvertKey(event->key()));
if (key != he::io::Key_Unknown)
keyboard->KeyPressed(key);
}
if (event->text().size() > 0)
{
keyboard->TextEntered(event->text().toUtf8().data());
}
QWidget::keyPressEvent(event);
}
LRESULT kGUISystemMINGW::Event(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
int wmId, wmEvent;
PAINTSTRUCT ps;
HDC hdc;
int key;
int newtick,deltatick;
// printf("in Event...!\n");
// fflush(stdout);
switch (message)
{
case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
// Parse the menu selections:
// printf("Done Event...!\n");
// fflush(stdout);
return DefWindowProc(hWnd, message, wParam, lParam);
break;
case WM_PAINT:
// Get the Windows update region
// printf("Wait...!\n");
// fflush(stdout);
// while(kGUI::GetInDraw()==true || kGUI::GetInThread()==true);
// printf("Done Wait...!\n");
// fflush(stdout);
// kGUI::SetInDraw(true);
GetUpdateRect(hWnd, &m_UpdateWinRect, FALSE);
hdc = BeginPaint(hWnd, &ps);
Draw(hWnd,m_UpdateWinRect.left,m_UpdateWinRect.right,m_UpdateWinRect.top,m_UpdateWinRect.bottom);
EndPaint(hWnd, &ps);
// kGUI::SetInDraw(false);
break;
case WM_TIMER:
newtick=GetTickCount();
deltatick=newtick-m_lasttickcount;
if(deltatick<0)
deltatick=0;
m_lasttickcount=newtick;
#if DEBUGPRINT
kGUI::Trace("Delta tick=%d\n",deltatick);
#endif
kGUI::Tick(deltatick);
if(GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT))
kGUI::SetKeyShift(true);
else
kGUI::SetKeyShift(false);
if(GetAsyncKeyState(VK_CONTROL))
kGUI::SetKeyControl(true);
else
kGUI::SetKeyControl(false);
if(kGUI::GetTempMouse()>=0)
{
int t=kGUI::GetTempMouse();
kGUI::SetTempMouse(t-1);
if(!t)
kGUI::SetMouseCursor(MOUSECURSOR_DEFAULT);
}
if(kGUI::GetMouseCursor()!=MOUSECURSOR_DEFAULT) /* if not default arrow */
kGUI::ChangeMouse();
// printf("Calling Input!\n");
// fflush(stdout);
kGUI::UpdateInput();
// printf("Done Calling Input!\n");
// fflush(stdout);
m_mousewheeldelta=0;
// printf("Wait...!\n");
// fflush(stdout);
// while(kGUI::GetInDraw()==true || kGUI::GetInThread()==true);
// printf("Done Wait...!\n");
// fflush(stdout);
// kGUI::SetInDraw(true);
Draw(hWnd,0,0,0,0);
// kGUI::SetInDraw(false);
/* is the application shutting down? */
if(kGUI::IsAppClosed()==true)
DestroyWindow(hWnd);
else
SetTimer(hWnd, 0, 1000 / FRAMES_PER_SECOND, NULL);
break;
case WM_DESTROY:
/* sometimes this event get's called more than once, so allow only once! */
if(m_waskilled==false)
{
m_waskilled=true;
AppClose();
kGUI::Close();
PostQuitMessage(0);
WSACleanup();
}
break;
case WM_MOUSEWHEEL:
//values are incrments of 120
m_mousewheeldelta = GET_WHEEL_DELTA_WPARAM(wParam)/120;
// m_mousewheeldelta = ( int ) ( ( short ) HIWORD( wParam ) )/120;
kGUI::SetMouse(m_mousex,m_mousey,m_mousewheeldelta,m_mouseleftbutton,m_mouserightbutton);
break;
case WM_LBUTTONDOWN:
case WM_LBUTTONUP:
case WM_RBUTTONDOWN:
case WM_RBUTTONUP:
case WM_MOUSEMOVE:
if(kGUI::GetMouseCursor()!=MOUSECURSOR_DEFAULT) /* if not default arrow */
kGUI::ChangeMouse();
m_mousex=GET_X_LPARAM(lParam);
m_mousey=GET_Y_LPARAM(lParam);
m_mouseleftbutton=(wParam&MK_LBUTTON)!=0;
m_mouserightbutton=(wParam&MK_RBUTTON)!=0;
/* this tells windows to keep updating me even if the mouse is moved off of */
/* my window area */
if(m_mouseleftbutton || m_mouserightbutton)
SetCapture(hWnd);
else
ReleaseCapture();
kGUI::SetMouse(m_mousex,m_mousey,m_mousewheeldelta,m_mouseleftbutton,m_mouserightbutton);
kGUI::Tick(0);
kGUI::UpdateInput();
// printf("Done Event...!\n");
// fflush(stdout);
return DefWindowProc(hWnd, message, wParam, lParam);
break;
case WM_CHAR:
key=(int)wParam;
switch(key)
{
case 1: //'ctrl-a'
key=GUIKEY_SELECTALL;
break;
case 3: //'ctrl-c'
key=GUIKEY_COPY;
break;
case 6: //'ctrl-f'
key=GUIKEY_FIND;
break;
case 22: //'ctrl-v'
key=GUIKEY_PASTE;
break;
case 24: //'ctrl-x'
key=GUIKEY_CUT;
break;
case 26: //'ctrl-z'
key=GUIKEY_UNDO;
break;
case 187: //'ctrl +'
key=GUIKEY_CTRL_PLUS;
break;
case 189: //'ctrl -'
key=GUIKEY_CTRL_MINUS;
break;
case VK_BACK:
key=GUIKEY_BACKSPACE;
break;
case VK_RETURN:
key=GUIKEY_RETURN;
break;
case VK_TAB:
if(GetAsyncKeyState(VK_LSHIFT) || GetAsyncKeyState(VK_RSHIFT))
key=GUIKEY_SHIFTTAB;
else
key=GUIKEY_TAB;
break;
case VK_ESCAPE:
key=GUIKEY_ESC;
break;
case VK_SHIFT:
case VK_CONTROL:
key=0;
break;
}
if(key)
kGUI::KeyPressed(key);
break;
case WM_KEYDOWN:
key=ConvertKey((int)wParam,0);
if(key)
kGUI::KeyPressed(key);
key=ConvertKey((int)wParam,(int)wParam);
if(key)
kGUI::SetKeyState(key,true);
break;
case WM_KEYUP:
key=ConvertKey((int)wParam,(int)wParam);
if(key)
kGUI::SetKeyState(key,false);
break;
default:
// printf("Done Event...!\n");
// fflush(stdout);
return DefWindowProc(hWnd, message, wParam, lParam);
break;
}
// printf("Done Event...!\n");
// fflush(stdout);
return 0;
}
static MRESULT EXPENTRY WndProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 )
{
vout_display_t * vd = WinQueryWindowPtr( hwnd, 0 );
MRESULT result = ( MRESULT )TRUE;
if ( !vd )
return WinDefWindowProc( hwnd, msg, mp1, mp2 );
vout_display_sys_t * sys = vd->sys;
RECTL rcl;
SWP swp;
if ( sys->is_mouse_hidden &&
((msg >= WM_MOUSEFIRST && msg <= WM_MOUSELAST) ||
(msg >= WM_EXTMOUSEFIRST && msg <= WM_EXTMOUSELAST) ||
msg == WM_MOUSELEAVE))
{
WinShowPointer(HWND_DESKTOP, TRUE);
sys->is_mouse_hidden = false;
}
switch( msg )
{
/* the user wants to close the window */
case WM_CLOSE:
vout_display_SendEventClose(vd);
result = 0;
break;
case WM_MOUSEMOVE :
{
SHORT i_mouse_x = SHORT1FROMMP( mp1 );
SHORT i_mouse_y = SHORT2FROMMP( mp1 );
RECTL movie_rect;
int i_movie_width, i_movie_height;
int i_src_width, i_src_height;
/* Get a current movie area */
kvaAdjustDstRect( &sys->kvas.rclSrcRect, &movie_rect );
i_movie_width = movie_rect.xRight - movie_rect.xLeft;
i_movie_height = movie_rect.yTop - movie_rect.yBottom;
i_src_width = sys->kvas.rclSrcRect.xRight -
sys->kvas.rclSrcRect.xLeft;
i_src_height = sys->kvas.rclSrcRect.yBottom -
sys->kvas.rclSrcRect.yTop;
int x = ( i_mouse_x - movie_rect.xLeft ) *
i_src_width / i_movie_width +
sys->kvas.rclSrcRect.xLeft;
int y = ( i_mouse_y - movie_rect.yBottom ) *
i_src_height / i_movie_height;
/* Invert Y coordinate and add y offset */
y = ( i_src_height - y ) + sys->kvas.rclSrcRect.yTop;;
vout_display_SendEventMouseMoved(vd, x, y);
result = WinDefWindowProc( hwnd, msg, mp1,mp2 );
break;
}
case WM_BUTTON1DOWN :
MousePressed( vd, hwnd, MOUSE_BUTTON_LEFT );
break;
case WM_BUTTON2DOWN :
MousePressed( vd, hwnd, MOUSE_BUTTON_RIGHT );
break;
case WM_BUTTON3DOWN :
MousePressed( vd, hwnd, MOUSE_BUTTON_CENTER );
break;
case WM_BUTTON1UP :
MouseReleased( vd, MOUSE_BUTTON_LEFT );
break;
case WM_BUTTON2UP :
MouseReleased( vd, MOUSE_BUTTON_RIGHT );
break;
case WM_BUTTON3UP :
MouseReleased( vd, MOUSE_BUTTON_CENTER );
break;
case WM_BUTTON1DBLCLK :
vout_display_SendEventMouseDoubleClick(vd);
break;
case WM_TRANSLATEACCEL :
/* We have no accelerator table at all */
result = ( MRESULT )FALSE;
break;
case WM_CHAR :
{
USHORT i_flags = SHORT1FROMMP( mp1 );
USHORT i_ch = SHORT1FROMMP( mp2 );
USHORT i_vk = SHORT2FROMMP( mp2 );
int i_key = 0;
/* If embedded window, let the parent process keys */
if( sys->parent_window )
{
WinPostMsg( sys->parent, msg, mp1, mp2 );
break;
}
if( !( i_flags & KC_KEYUP ))
{
if( i_flags & KC_VIRTUALKEY )
/* convert the key if possible */
i_key = ConvertKey( i_vk );
else if(( i_flags & KC_CHAR ) && !HIBYTE( i_ch ))
i_key = tolower( i_ch );
if( i_key )
{
if( i_flags & KC_SHIFT )
i_key |= KEY_MODIFIER_SHIFT;
if( i_flags & KC_CTRL )
i_key |= KEY_MODIFIER_CTRL;
if( i_flags & KC_ALT )
i_key |= KEY_MODIFIER_ALT;
vout_display_SendEventKey(vd, i_key);
}
}
break;
}
/* Process Manage() call */
case WM_VLC_MANAGE :
break;
/* Fullscreen change */
case WM_VLC_FULLSCREEN_CHANGE :
if( LONGFROMMP( mp1 ))
{
WinQueryWindowPos( sys->frame, &swp );
sys->client_rect.xLeft = swp.x;
sys->client_rect.yBottom = swp.y;
sys->client_rect.xRight = sys->client_rect.xLeft + swp.cx;
sys->client_rect.yTop = sys->client_rect.yBottom + swp.cy;
WinCalcFrameRect( sys->frame, &sys->client_rect, TRUE );
rcl.xLeft = 0;
rcl.yBottom = 0;
rcl.xRight = sys->i_screen_width;
rcl.yTop = sys->i_screen_height;
}
else
rcl = sys->client_rect;
WinCalcFrameRect( sys->frame, &rcl, FALSE );
WinSetWindowPos( sys->frame, HWND_TOP,
rcl.xLeft, rcl.yBottom,
rcl.xRight - rcl.xLeft, rcl.yTop - rcl.yBottom,
SWP_MOVE | SWP_SIZE | SWP_ZORDER | SWP_SHOW |
SWP_ACTIVATE );
break;
/* Size change */
case WM_VLC_SIZE_CHANGE :
rcl.xLeft = 0;
rcl.yBottom = 0;
rcl.xRight = LONGFROMMP( mp1 );
rcl.yTop = LONGFROMMP( mp2 );
WinCalcFrameRect( sys->frame, &rcl, FALSE );
WinSetWindowPos( sys->frame, NULLHANDLE,
0, 0,
rcl.xRight - rcl.xLeft, rcl.yTop - rcl.yBottom,
SWP_SIZE );
WinQueryWindowPos( sys->frame, &swp );
sys->client_rect.xLeft = swp.x;
sys->client_rect.yBottom = swp.y;
sys->client_rect.xRight = sys->client_rect.xLeft + swp.cx;
sys->client_rect.yTop = sys->client_rect.yBottom + swp.cy;
WinCalcFrameRect( sys->frame, &sys->client_rect, TRUE );
break;
default :
return WinDefWindowProc( hwnd, msg, mp1, mp2 );
}
/* If embedded window, we need to change our window size according to a
* parent window size */
if( sys->parent_window )
{
WinQueryWindowRect( sys->parent, &rcl );
if( rcl.xLeft != sys->parent_rect.xLeft ||
rcl.yBottom != sys->parent_rect.yBottom ||
rcl.xRight != sys->parent_rect.xRight ||
rcl.yTop != sys->parent_rect.yTop)
{
sys->parent_rect = rcl;
WinCalcFrameRect( sys->frame, &rcl, FALSE );
WinSetWindowPos( sys->frame, NULLHANDLE,
rcl.xLeft, rcl.yBottom,
rcl.xRight - rcl.xLeft, rcl.yTop - rcl.yBottom,
SWP_SIZE | SWP_MOVE );
}
}
return result;
}
void SdlManager::ProcessEvent(const SDL_Event& event)
{
switch(event.type)
{
case SDL_KEYDOWN:
case SDL_KEYUP:
{
Event e;
e.device = Event::deviceKeyboard;
e.keyboard.type = event.type == SDL_KEYDOWN ? Event::Keyboard::typeKeyDown : Event::Keyboard::typeKeyUp;
e.keyboard.key = ConvertKey(event.key.keysym.sym);
AddEvent(e);
}
break;
case SDL_TEXTINPUT:
for(auto i = utf8::unchecked::iterator<const char*>(event.text.text); *i.base(); ++i)
{
Event e;
e.device = Event::deviceKeyboard;
e.keyboard.type = Event::Keyboard::typeCharacter;
e.keyboard.character = *i;
AddEvent(e);
}
break;
case SDL_MOUSEMOTION:
// raw move event
{
Event e;
e.device = Event::deviceMouse;
e.mouse.type = Event::Mouse::typeRawMove;
e.mouse.rawMoveX = event.motion.xrel;
e.mouse.rawMoveY = event.motion.yrel;
e.mouse.rawMoveZ = 0;
AddEvent(e);
}
// cursor move event
{
Event e;
e.device = Event::deviceMouse;
e.mouse.type = Event::Mouse::typeCursorMove;
e.mouse.cursorX = (int)(event.motion.x * widthScale);
e.mouse.cursorY = (int)(event.motion.y * heightScale);
AddEvent(e);
}
break;
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
{
Event e;
e.device = Event::deviceMouse;
e.mouse.type = event.type == SDL_MOUSEBUTTONDOWN ? Event::Mouse::typeButtonDown : Event::Mouse::typeButtonUp;
bool ok = true;
switch(event.button.button)
{
case SDL_BUTTON_LEFT:
e.mouse.button = Event::Mouse::buttonLeft;
break;
case SDL_BUTTON_MIDDLE:
e.mouse.button = Event::Mouse::buttonMiddle;
break;
case SDL_BUTTON_RIGHT:
e.mouse.button = Event::Mouse::buttonRight;
break;
default:
ok = false;
break;
}
if(ok)
AddEvent(e);
}
break;
case SDL_CONTROLLERDEVICEADDED:
// device added event
{
// open controller
SDL_GameController* sdlController = SDL_GameControllerOpen(event.cdevice.which);
if(sdlController)
{
ptr<SdlController> controller = NEW(SdlController(sdlController));
{
CriticalCode criticalCode(criticalSection);
controllers[controller->GetControllerId()] = controller;
}
Event e;
e.device = Event::deviceController;
e.controller.type = Event::Controller::typeDeviceAdded;
e.controller.device = controller->GetControllerId();
AddEvent(e);
}
}
break;
case SDL_CONTROLLERDEVICEREMOVED:
// device removed event
{
// try to find controller by id, and remove it from map
ptr<SdlController> controller;
{
CriticalCode criticalCode(criticalSection);
decltype(controllers)::const_iterator i = controllers.find(event.cdevice.which);
if(i != controllers.end())
{
controller = i->second;
controllers.erase(i);
}
}
// if it's found
if(controller)
{
// close controller
controller->Close();
controller = nullptr;
// emit event
Event e;
e.device = Event::deviceController;
e.controller.type = Event::Controller::typeDeviceRemoved;
e.controller.device = event.cdevice.which;
AddEvent(e);
}
}
break;
case SDL_CONTROLLERBUTTONDOWN:
case SDL_CONTROLLERBUTTONUP:
// controller button down/up event
{
Event::Controller::Button button;
bool ok = true;
switch(event.cbutton.button)
{
#define B(a, b) case SDL_CONTROLLER_BUTTON_##a: button = Event::Controller::button##b; break
B(A, A);
B(B, B);
B(X, X);
B(Y, Y);
B(BACK, Back);
B(GUIDE, Guide);
B(START, Start);
B(LEFTSTICK, LeftStick);
B(RIGHTSTICK, RightStick);
B(LEFTSHOULDER, LeftShoulder);
B(RIGHTSHOULDER, RightShoulder);
B(DPAD_UP, DPadUp);
B(DPAD_DOWN, DPadDown);
B(DPAD_LEFT, DPadLeft);
B(DPAD_RIGHT, DPadRight);
#undef B
default: ok = false; break;
}
if(ok)
{
Event e;
e.device = Event::deviceController;
e.controller.type = event.type == SDL_CONTROLLERBUTTONDOWN ? Event::Controller::typeButtonDown : Event::Controller::typeButtonUp;
e.controller.device = event.cbutton.which;
e.controller.button = button;
AddEvent(e);
}
}
break;
case SDL_CONTROLLERAXISMOTION:
// controller axis motion event
{
Event::Controller::Axis axis;
bool ok = true;
switch(event.caxis.axis)
{
#define A(a, b) case SDL_CONTROLLER_AXIS_##a: axis = Event::Controller::axis##b; break
A(LEFTX, LeftX);
A(LEFTY, LeftY);
A(RIGHTX, RightX);
A(RIGHTY, RightY);
A(TRIGGERLEFT, TriggerLeft);
A(TRIGGERRIGHT, TriggerRight);
#undef A
default: ok = false; break;
}
if(ok)
{
Event e;
e.device = Event::deviceController;
e.controller.type = Event::Controller::typeAxisMotion;
e.controller.device = event.caxis.which;
e.controller.axis = axis;
e.controller.axisValue = event.caxis.value;
AddEvent(e);
}
}
break;
}
}
