client/DirectFB/df_event.c

   1 /**
   2  * FreeRDP: A Remote Desktop Protocol Client
   3  * DirectFB Event Handling
   4  *
   5  * Copyright 2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *     http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  */
  19
  20 #include <freerdp/kbd/kbd.h>
  21 #include <freerdp/kbd/vkcodes.h>
  22
  23 #include "df_event.h"
  24
  25 static uint8 keymap[256];
  26 static uint8 functionmap[128];
  27
  28 void df_keyboard_init()
  29 {
  30         memset(keymap, 0, sizeof(keymap));
  31
  32         /* Map DirectFB keycodes to Virtual Key Codes */
  33
  34         keymap[DIKI_A - DIKI_UNKNOWN] = VK_KEY_A;
  35         keymap[DIKI_B - DIKI_UNKNOWN] = VK_KEY_B;
  36         keymap[DIKI_C - DIKI_UNKNOWN] = VK_KEY_C;
  37         keymap[DIKI_D - DIKI_UNKNOWN] = VK_KEY_D;
  38         keymap[DIKI_E - DIKI_UNKNOWN] = VK_KEY_E;
  39         keymap[DIKI_F - DIKI_UNKNOWN] = VK_KEY_F;
  40         keymap[DIKI_G - DIKI_UNKNOWN] = VK_KEY_G;
  41         keymap[DIKI_H - DIKI_UNKNOWN] = VK_KEY_H;
  42         keymap[DIKI_I - DIKI_UNKNOWN] = VK_KEY_I;
  43         keymap[DIKI_J - DIKI_UNKNOWN] = VK_KEY_J;
  44         keymap[DIKI_K - DIKI_UNKNOWN] = VK_KEY_K;
  45         keymap[DIKI_L - DIKI_UNKNOWN] = VK_KEY_L;
  46         keymap[DIKI_M - DIKI_UNKNOWN] = VK_KEY_M;
  47         keymap[DIKI_N - DIKI_UNKNOWN] = VK_KEY_N;
  48         keymap[DIKI_O - DIKI_UNKNOWN] = VK_KEY_O;
  49         keymap[DIKI_P - DIKI_UNKNOWN] = VK_KEY_P;
  50         keymap[DIKI_Q - DIKI_UNKNOWN] = VK_KEY_Q;
  51         keymap[DIKI_R - DIKI_UNKNOWN] = VK_KEY_R;
  52         keymap[DIKI_S - DIKI_UNKNOWN] = VK_KEY_S;
  53         keymap[DIKI_T - DIKI_UNKNOWN] = VK_KEY_T;
  54         keymap[DIKI_U - DIKI_UNKNOWN] = VK_KEY_U;
  55         keymap[DIKI_V - DIKI_UNKNOWN] = VK_KEY_V;
  56         keymap[DIKI_W - DIKI_UNKNOWN] = VK_KEY_W;
  57         keymap[DIKI_X - DIKI_UNKNOWN] = VK_KEY_X;
  58         keymap[DIKI_Y - DIKI_UNKNOWN] = VK_KEY_Y;
  59         keymap[DIKI_Z - DIKI_UNKNOWN] = VK_KEY_Z;
  60
  61         keymap[DIKI_0 - DIKI_UNKNOWN] = VK_KEY_0;
  62         keymap[DIKI_1 - DIKI_UNKNOWN] = VK_KEY_1;
  63         keymap[DIKI_2 - DIKI_UNKNOWN] = VK_KEY_2;
  64         keymap[DIKI_3 - DIKI_UNKNOWN] = VK_KEY_3;
  65         keymap[DIKI_4 - DIKI_UNKNOWN] = VK_KEY_4;
  66         keymap[DIKI_5 - DIKI_UNKNOWN] = VK_KEY_5;
  67         keymap[DIKI_6 - DIKI_UNKNOWN] = VK_KEY_6;
  68         keymap[DIKI_7 - DIKI_UNKNOWN] = VK_KEY_7;
  69         keymap[DIKI_8 - DIKI_UNKNOWN] = VK_KEY_8;
  70         keymap[DIKI_9 - DIKI_UNKNOWN] = VK_KEY_9;
  71
  72         keymap[DIKI_F1 - DIKI_UNKNOWN] = VK_F1;
  73         keymap[DIKI_F2 - DIKI_UNKNOWN] = VK_F2;
  74         keymap[DIKI_F3 - DIKI_UNKNOWN] = VK_F3;
  75         keymap[DIKI_F4 - DIKI_UNKNOWN] = VK_F4;
  76         keymap[DIKI_F5 - DIKI_UNKNOWN] = VK_F5;
  77         keymap[DIKI_F6 - DIKI_UNKNOWN] = VK_F6;
  78         keymap[DIKI_F7 - DIKI_UNKNOWN] = VK_F7;
  79         keymap[DIKI_F8 - DIKI_UNKNOWN] = VK_F8;
  80         keymap[DIKI_F9 - DIKI_UNKNOWN] = VK_F9;
  81         keymap[DIKI_F10 - DIKI_UNKNOWN] = VK_F10;
  82         keymap[DIKI_F11 - DIKI_UNKNOWN] = VK_F11;
  83         keymap[DIKI_F12 - DIKI_UNKNOWN] = VK_F12;
  84
  85         keymap[DIKI_COMMA - DIKI_UNKNOWN] = VK_OEM_COMMA;
  86         keymap[DIKI_PERIOD - DIKI_UNKNOWN] = VK_OEM_PERIOD;
  87         keymap[DIKI_MINUS_SIGN - DIKI_UNKNOWN] = VK_OEM_MINUS;
  88         keymap[DIKI_EQUALS_SIGN - DIKI_UNKNOWN] = VK_OEM_PLUS;
  89
  90         keymap[DIKI_ESCAPE - DIKI_UNKNOWN] = VK_ESCAPE;
  91         keymap[DIKI_LEFT - DIKI_UNKNOWN] = VK_LEFT;
  92         keymap[DIKI_RIGHT - DIKI_UNKNOWN] = VK_RIGHT;
  93         keymap[DIKI_UP - DIKI_UNKNOWN] = VK_UP;
  94         keymap[DIKI_DOWN - DIKI_UNKNOWN] = VK_DOWN;
  95         keymap[DIKI_CONTROL_L - DIKI_UNKNOWN] = VK_LCONTROL;
  96         keymap[DIKI_CONTROL_R - DIKI_UNKNOWN] = VK_RCONTROL;
  97         keymap[DIKI_SHIFT_L - DIKI_UNKNOWN] = VK_LSHIFT;
  98         keymap[DIKI_SHIFT_R - DIKI_UNKNOWN] = VK_RSHIFT;
  99         keymap[DIKI_ALT_L - DIKI_UNKNOWN] = VK_LMENU;
 100         keymap[DIKI_ALT_R - DIKI_UNKNOWN] = VK_RMENU;
 101         keymap[DIKI_TAB - DIKI_UNKNOWN] = VK_TAB;
 102         keymap[DIKI_ENTER - DIKI_UNKNOWN] = VK_RETURN;
 103         keymap[DIKI_SPACE - DIKI_UNKNOWN] = VK_SPACE;
 104         keymap[DIKI_BACKSPACE - DIKI_UNKNOWN] = VK_BACK;
 105         keymap[DIKI_INSERT - DIKI_UNKNOWN] = VK_INSERT;
 106         keymap[DIKI_DELETE - DIKI_UNKNOWN] = VK_DELETE;
 107         keymap[DIKI_HOME - DIKI_UNKNOWN] = VK_HOME;
 108         keymap[DIKI_END - DIKI_UNKNOWN] = VK_END;
 109         keymap[DIKI_PAGE_UP - DIKI_UNKNOWN] = VK_PRIOR;
 110         keymap[DIKI_PAGE_DOWN - DIKI_UNKNOWN] = VK_NEXT;
 111         keymap[DIKI_CAPS_LOCK - DIKI_UNKNOWN] = VK_CAPITAL;
 112         keymap[DIKI_NUM_LOCK - DIKI_UNKNOWN] = VK_NUMLOCK;
 113         keymap[DIKI_SCROLL_LOCK - DIKI_UNKNOWN] = VK_SCROLL;
 114         keymap[DIKI_PRINT - DIKI_UNKNOWN] = VK_PRINT;
 115         keymap[DIKI_PAUSE - DIKI_UNKNOWN] = VK_PAUSE;
 116         keymap[DIKI_KP_DIV - DIKI_UNKNOWN] = VK_DIVIDE;
 117         keymap[DIKI_KP_MULT - DIKI_UNKNOWN] = VK_MULTIPLY;
 118         keymap[DIKI_KP_MINUS - DIKI_UNKNOWN] = VK_SUBTRACT;
 119         keymap[DIKI_KP_PLUS - DIKI_UNKNOWN] = VK_ADD;
 120         keymap[DIKI_KP_ENTER - DIKI_UNKNOWN] = VK_RETURN;
 121         keymap[DIKI_KP_DECIMAL - DIKI_UNKNOWN] = VK_DECIMAL;
 122
 123         keymap[DIKI_QUOTE_LEFT - DIKI_UNKNOWN] = VK_OEM_3;
 124         keymap[DIKI_BRACKET_LEFT - DIKI_UNKNOWN] = VK_OEM_4;
 125         keymap[DIKI_BRACKET_RIGHT - DIKI_UNKNOWN] = VK_OEM_6;
 126         keymap[DIKI_BACKSLASH - DIKI_UNKNOWN] = VK_OEM_5;
 127         keymap[DIKI_SEMICOLON - DIKI_UNKNOWN] = VK_OEM_1;
 128         keymap[DIKI_QUOTE_RIGHT - DIKI_UNKNOWN] = VK_OEM_7;
 129         keymap[DIKI_COMMA - DIKI_UNKNOWN] = VK_OEM_COMMA;
 130         keymap[DIKI_PERIOD - DIKI_UNKNOWN] = VK_OEM_PERIOD;
 131         keymap[DIKI_SLASH - DIKI_UNKNOWN] = VK_OEM_2;
 132
 133         keymap[DIKI_LESS_SIGN - DIKI_UNKNOWN] = 0;
 134
 135         keymap[DIKI_KP_0 - DIKI_UNKNOWN] = VK_NUMPAD0;
 136         keymap[DIKI_KP_1 - DIKI_UNKNOWN] = VK_NUMPAD1;
 137         keymap[DIKI_KP_2 - DIKI_UNKNOWN] = VK_NUMPAD2;
 138         keymap[DIKI_KP_3 - DIKI_UNKNOWN] = VK_NUMPAD3;
 139         keymap[DIKI_KP_4 - DIKI_UNKNOWN] = VK_NUMPAD4;
 140         keymap[DIKI_KP_5 - DIKI_UNKNOWN] = VK_NUMPAD5;
 141         keymap[DIKI_KP_6 - DIKI_UNKNOWN] = VK_NUMPAD6;
 142         keymap[DIKI_KP_7 - DIKI_UNKNOWN] = VK_NUMPAD7;
 143         keymap[DIKI_KP_8 - DIKI_UNKNOWN] = VK_NUMPAD8;
 144         keymap[DIKI_KP_9 - DIKI_UNKNOWN] = VK_NUMPAD9;
 145
 146         keymap[DIKI_META_L - DIKI_UNKNOWN] = VK_LWIN;
 147         keymap[DIKI_META_R - DIKI_UNKNOWN] = VK_RWIN;
 148         keymap[DIKI_SUPER_L - DIKI_UNKNOWN] = VK_APPS;
 149
 150
 151         memset(functionmap, 0, sizeof(functionmap));
 152
 153         functionmap[DFB_FUNCTION_KEY(23) - DFB_FUNCTION_KEY(0)] = VK_HANGUL;
 154         functionmap[DFB_FUNCTION_KEY(24) - DFB_FUNCTION_KEY(0)] = VK_HANJA;
 155
 156 }
 157
 158 void df_send_mouse_button_event(rdpInput* input, boolean down, uint32 button, uint16 x, uint16 y)
 159 {
 160         uint16 flags;
 161
 162         flags = (down) ? PTR_FLAGS_DOWN : 0;
 163
 164         if (button == DIBI_LEFT)
 165                 flags |= PTR_FLAGS_BUTTON1;
 166         else if (button == DIBI_RIGHT)
 167                 flags |= PTR_FLAGS_BUTTON2;
 168         else if (button == DIBI_MIDDLE)
 169                 flags |= PTR_FLAGS_BUTTON3;
 170
 171         if (flags != 0)
 172                 input->MouseEvent(input, flags, x, y);
 173 }
 174
 175 void df_send_mouse_motion_event(rdpInput* input, uint16 x, uint16 y)
 176 {
 177         input->MouseEvent(input, PTR_FLAGS_MOVE, x, y);
 178 }
 179
 180 void df_send_mouse_wheel_event(rdpInput* input, sint16 axisrel, uint16 x, uint16 y)
 181 {
 182         uint16 flags = PTR_FLAGS_WHEEL;
 183
 184         if (axisrel < 0)
 185                 flags |= 0x0078;
 186         else
 187                 flags |= PTR_FLAGS_WHEEL_NEGATIVE | 0x0088;
 188
 189         input->MouseEvent(input, flags, x, y);
 190 }
 191
 192 void df_send_keyboard_event(rdpInput* input, boolean down, uint8 keycode, uint8 function)
 193 {
 194         uint16 flags;
 195         uint8 vkcode;
 196         uint8 scancode;
 197         boolean extended;
 198
 199         if (keycode)
 200                 vkcode = keymap[keycode];
 201         else if (function)
 202                 vkcode = functionmap[function];
 203         else
 204                 return;
 205
 206         scancode = freerdp_kbd_get_scancode_by_virtualkey(vkcode, &extended);
 207
 208         flags = (extended) ? KBD_FLAGS_EXTENDED : 0;
 209         flags |= (down) ? KBD_FLAGS_DOWN : KBD_FLAGS_RELEASE;
 210
 211         input->KeyboardEvent(input, flags, scancode);
 212 }
 213
 214 boolean df_event_process(freerdp* instance, DFBEvent* event)
 215 {
 216         int flags;
 217         rdpGdi* gdi;
 218         dfInfo* dfi;
 219         int pointer_x;
 220         int pointer_y;
 221         DFBInputEvent* input_event;
 222
 223         gdi = instance->context->gdi;
 224         dfi = ((dfContext*) instance->context)->dfi;
 225
 226         dfi->layer->GetCursorPosition(dfi->layer, &pointer_x, &pointer_y);
 227
 228         if (event->clazz == DFEC_INPUT)
 229         {
 230                 flags = 0;
 231                 input_event = (DFBInputEvent*) event;
 232
 233                 switch (input_event->type)
 234                 {
 235                         case DIET_AXISMOTION:
 236
 237                                 if (pointer_x > (gdi->width - 1))
 238                                         pointer_x = gdi->width - 1;
 239
 240                                 if (pointer_y > (gdi->height - 1))
 241                                         pointer_y = gdi->height - 1;
 242
 243                                 if (input_event->axis == DIAI_Z)
 244                                 {
 245                                         df_send_mouse_wheel_event(instance->input, input_event->axisrel, pointer_x, pointer_y);
 246                                 }
 247                                 else
 248                                 {
 249                                         df_send_mouse_motion_event(instance->input, pointer_x, pointer_y);
 250                                 }
 251                                 break;
 252
 253                         case DIET_BUTTONPRESS:
 254                                 df_send_mouse_button_event(instance->input, true, input_event->button, pointer_x, pointer_y);
 255                                 break;
 256
 257                         case DIET_BUTTONRELEASE:
 258                                 df_send_mouse_button_event(instance->input, false, input_event->button, pointer_x, pointer_y);
 259                                 break;
 260
 261                         case DIET_KEYPRESS:
 262                                 df_send_keyboard_event(instance->input, true, input_event->key_id - DIKI_UNKNOWN, input_event->key_symbol - DFB_FUNCTION_KEY(0));
 263                                 break;
 264
 265                         case DIET_KEYRELEASE:
 266                                 df_send_keyboard_event(instance->input, false, input_event->key_id - DIKI_UNKNOWN, input_event->key_symbol - DFB_FUNCTION_KEY(0));
 267                                 break;
 268
 269                         case DIET_UNKNOWN:
 270                                 break;
 271                 }
 272         }
 273
 274         return true;
 275 }