src/lib/ecore_wince/ecore_wince_event.c

   1 #ifdef HAVE_CONFIG_H
   2 # include <config.h>
   3 #endif
   4
   5 #include <stdlib.h>
   6
   7 #define WIN32_LEAN_AND_MEAN
   8 #include <windows.h>
   9 #undef WIN32_LEAN_AND_MEAN
  10
  11 #include <Eina.h>
  12 #include <Ecore.h>
  13 #include <Ecore_Input.h>
  14
  15 #include "Ecore_WinCE.h"
  16 #include "ecore_wince_private.h"
  17
  18
  19 /***** Private declarations *****/
  20
  21 static Ecore_WinCE_Window *_ecore_wince_mouse_down_last_window = NULL;
  22 static Ecore_WinCE_Window *_ecore_wince_mouse_down_last_last_window = NULL;
  23 static long                _ecore_wince_mouse_down_last_time = 0;
  24 static long                _ecore_wince_mouse_down_last_last_time = 0;
  25 static int                 _ecore_wince_mouse_down_did_triple = 0;
  26 static int                 _ecore_wince_mouse_up_count = 0;
  27
  28
  29 static void _ecore_wince_event_free_key_down(void *data,
  30                                              void *ev);
  31
  32 static void _ecore_wince_event_free_key_up(void *data,
  33                                            void *ev);
  34
  35 static int  _ecore_wince_event_keystroke_get(int    key,
  36                                              char **keyname,
  37                                              char **keysymbol,
  38                                              char **keycompose);
  39
  40 static int  _ecore_wince_event_char_get(int    key,
  41                                         char **keyname,
  42                                         char **keysymbol,
  43                                         char **keycompose);
  44
  45
  46 /***** Global functions *****/
  47
  48 void
  49 _ecore_wince_event_handle_key_press(Ecore_WinCE_Callback_Data *msg,
  50                                     int                        is_keystroke)
  51 {
  52    Ecore_Event_Key *e;
  53
  54    INF("key pressed");
  55
  56    e = (Ecore_Event_Key *)malloc(sizeof(Ecore_Event_Key));
  57    if (!e) return;
  58
  59    if (is_keystroke)
  60      {
  61         if (!_ecore_wince_event_keystroke_get(LOWORD(msg->window_param),
  62                                               (char **)&e->keyname,
  63                                               (char **)&e->key,
  64                                               (char **)&e->string))
  65           {
  66              free(e);
  67              return;
  68           }
  69      }
  70    else
  71      {
  72         if (!_ecore_wince_event_char_get(LOWORD(msg->window_param),
  73                                          (char **)&e->keyname,
  74                                          (char **)&e->key,
  75                                          (char **)&e->string))
  76           {
  77              free(e);
  78              return;
  79           }
  80      }
  81
  82    e->window = (Ecore_Window)GetWindowLong(msg->window, GWL_USERDATA);
  83    if (!e->window)
  84      {
  85         free(e);
  86         return;
  87      }
  88    e->timestamp = msg->time;
  89
  90    _ecore_wince_event_last_time = e->timestamp;
  91
  92    ecore_event_add(ECORE_EVENT_KEY_DOWN, e, _ecore_wince_event_free_key_down, NULL);
  93 }
  94
  95 void
  96 _ecore_wince_event_handle_key_release(Ecore_WinCE_Callback_Data *msg,
  97                                       int                        is_keystroke)
  98 {
  99    Ecore_Event_Key *e;
 100
 101    INF("key released");
 102
 103    e = (Ecore_Event_Key *)calloc(1, sizeof(Ecore_Event_Key));
 104    if (!e) return;
 105
 106    if (is_keystroke)
 107      {
 108         if (!_ecore_wince_event_keystroke_get(LOWORD(msg->window_param),
 109                                               (char **)&e->keyname,
 110                                               (char **)&e->key,
 111                                               (char **)&e->string))
 112           {
 113              free(e);
 114              return;
 115           }
 116      }
 117    else
 118      {
 119         if (!_ecore_wince_event_char_get(LOWORD(msg->window_param),
 120                                          (char **)&e->keyname,
 121                                          (char **)&e->key,
 122                                          (char **)&e->string))
 123           {
 124              free(e);
 125              return;
 126           }
 127      }
 128
 129    e->window = (Ecore_Window)GetWindowLong(msg->window, GWL_USERDATA);
 130    if (!e->window)
 131      {
 132         free(e);
 133         return;
 134      }
 135    e->timestamp = msg->time;
 136
 137    _ecore_wince_event_last_time = e->timestamp;
 138
 139    ecore_event_add(ECORE_EVENT_KEY_UP, e, _ecore_wince_event_free_key_up, NULL);
 140 }
 141
 142 void
 143 _ecore_wince_event_handle_button_press(Ecore_WinCE_Callback_Data *msg,
 144                                        int                        button)
 145 {
 146    Ecore_WinCE_Window *window;
 147
 148    INF("mouse button pressed");
 149
 150    window = (Ecore_WinCE_Window *)GetWindowLong(msg->window, GWL_USERDATA);
 151
 152    {
 153       Ecore_Event_Mouse_Move *e;
 154
 155       e = (Ecore_Event_Mouse_Move *)calloc(1, sizeof(Ecore_Event_Mouse_Move));
 156       if (!e) return;
 157
 158       e->window = (Ecore_Window)window;
 159       e->x = LOWORD(msg->data_param);
 160       e->y = HIWORD(msg->data_param);
 161       e->timestamp = msg->time;
 162
 163       _ecore_wince_event_last_time = e->timestamp;
 164       _ecore_wince_event_last_window = (Ecore_WinCE_Window *)e->window;
 165
 166       ecore_event_add(ECORE_EVENT_MOUSE_MOVE, e, NULL, NULL);
 167    }
 168
 169    {
 170       Ecore_Event_Mouse_Button *e;
 171
 172       if (_ecore_wince_mouse_down_did_triple)
 173         {
 174            _ecore_wince_mouse_down_last_window = NULL;
 175            _ecore_wince_mouse_down_last_last_window = NULL;
 176            _ecore_wince_mouse_down_last_time = 0;
 177            _ecore_wince_mouse_down_last_last_time = 0;
 178         }
 179
 180       e = (Ecore_Event_Mouse_Button *)calloc(1, sizeof(Ecore_Event_Mouse_Button));
 181       if (!e) return;
 182
 183       e->window = (Ecore_Window)window;
 184       e->buttons = button;
 185       e->x = LOWORD(msg->data_param);
 186       e->y = HIWORD(msg->data_param);
 187       e->timestamp = msg->time;
 188
 189       if (((e->timestamp - _ecore_wince_mouse_down_last_time) <= (long)(1000 * _ecore_wince_double_click_time)) &&
 190           (e->window == (Ecore_Window)_ecore_wince_mouse_down_last_window))
 191         e->double_click = 1;
 192
 193       if (((e->timestamp - _ecore_wince_mouse_down_last_last_time) <= (long)(2 * 1000 * _ecore_wince_double_click_time)) &&
 194           (e->window == (Ecore_Window)_ecore_wince_mouse_down_last_window) &&
 195           (e->window == (Ecore_Window)_ecore_wince_mouse_down_last_last_window))
 196         {
 197            e->triple_click = 1;
 198            _ecore_wince_mouse_down_did_triple = 1;
 199         }
 200       else
 201         _ecore_wince_mouse_down_did_triple = 0;
 202
 203       if (!e->double_click && !e->triple_click)
 204         _ecore_wince_mouse_up_count = 0;
 205
 206       _ecore_wince_event_last_time = e->timestamp;
 207       _ecore_wince_event_last_window = (Ecore_WinCE_Window *)e->window;
 208
 209       if (!_ecore_wince_mouse_down_did_triple)
 210         {
 211            _ecore_wince_mouse_down_last_last_window = _ecore_wince_mouse_down_last_window;
 212            _ecore_wince_mouse_down_last_window = (Ecore_WinCE_Window *)e->window;
 213            _ecore_wince_mouse_down_last_last_time = _ecore_wince_mouse_down_last_time;
 214            _ecore_wince_mouse_down_last_time = e->timestamp;
 215         }
 216
 217       ecore_event_add(ECORE_EVENT_MOUSE_BUTTON_DOWN, e, NULL, NULL);
 218    }
 219 }
 220
 221 void
 222 _ecore_wince_event_handle_button_release(Ecore_WinCE_Callback_Data *msg,
 223                                          int                        button)
 224 {
 225    Ecore_WinCE_Window *window;
 226
 227    INF("mouse button released");
 228
 229    window = (void *)GetWindowLong(msg->window, GWL_USERDATA);
 230
 231    {
 232       Ecore_Event_Mouse_Move *e;
 233
 234       e = (Ecore_Event_Mouse_Move *)calloc(1, sizeof(Ecore_Event_Mouse_Move));
 235       if (!e) return;
 236
 237       e->window = (Ecore_Window)window;
 238       e->x = LOWORD(msg->data_param);
 239       e->y = HIWORD(msg->data_param);
 240       e->timestamp = msg->time;
 241
 242       _ecore_wince_event_last_time = e->timestamp;
 243       _ecore_wince_event_last_window = (Ecore_WinCE_Window *)e->window;
 244
 245       ecore_event_add(ECORE_EVENT_MOUSE_MOVE, e, NULL, NULL);
 246    }
 247
 248    {
 249       Ecore_Event_Mouse_Button *e;
 250
 251       e = (Ecore_Event_Mouse_Button *)calloc(1, sizeof(Ecore_Event_Mouse_Button));
 252       if (!e) return;
 253
 254       e->window = (Ecore_Window)window;
 255       e->buttons = button;
 256       e->x = LOWORD(msg->data_param);
 257       e->y = HIWORD(msg->data_param);
 258       e->timestamp = msg->time;
 259
 260       _ecore_wince_mouse_up_count++;
 261
 262       if ((_ecore_wince_mouse_up_count >= 2) &&
 263           ((e->timestamp - _ecore_wince_mouse_down_last_time) <= (long)(1000 * _ecore_wince_double_click_time)) &&
 264           (e->window == (Ecore_Window)_ecore_wince_mouse_down_last_window))
 265         e->double_click = 1;
 266
 267       if ((_ecore_wince_mouse_up_count >= 3) &&
 268           ((e->timestamp - _ecore_wince_mouse_down_last_last_time) <= (long)(2 * 1000 * _ecore_wince_double_click_time)) &&
 269           (e->window == (Ecore_Window)_ecore_wince_mouse_down_last_window) &&
 270           (e->window == (Ecore_Window)_ecore_wince_mouse_down_last_last_window))
 271         e->triple_click = 1;
 272
 273       _ecore_wince_event_last_time = e->timestamp;
 274       _ecore_wince_event_last_window = (Ecore_WinCE_Window *)e->window;
 275
 276       ecore_event_add(ECORE_EVENT_MOUSE_BUTTON_UP, e, NULL, NULL);
 277    }
 278 }
 279
 280 void
 281 _ecore_wince_event_handle_motion_notify(Ecore_WinCE_Callback_Data *msg)
 282 {
 283    Ecore_Event_Mouse_Move *e;
 284
 285    INF("mouse moved");
 286
 287    e = (Ecore_Event_Mouse_Move *)calloc(1, sizeof(Ecore_Event_Mouse_Move));
 288    if (!e) return;
 289
 290    e->window = (Ecore_Window)GetWindowLong(msg->window, GWL_USERDATA);
 291    e->x = LOWORD(msg->data_param);
 292    e->y = HIWORD(msg->data_param);
 293    e->timestamp = msg->time;
 294
 295    ecore_event_add(ECORE_EVENT_MOUSE_MOVE, e, NULL, NULL);
 296 }
 297
 298 void
 299 _ecore_wince_event_handle_enter_notify(Ecore_WinCE_Callback_Data *msg)
 300 {
 301    Ecore_WinCE_Window *window;
 302
 303    INF("mouse in");
 304
 305    window = (void *)GetWindowLong(msg->window, GWL_USERDATA);
 306
 307    {
 308       Ecore_Event_Mouse_Move *e;
 309
 310       e = (Ecore_Event_Mouse_Move *)calloc(1, sizeof(Ecore_Event_Mouse_Move));
 311       if (!e) return;
 312
 313       e->window = (Ecore_Window)window;
 314       e->x = msg->x;
 315       e->y = msg->y;
 316       e->timestamp = msg->time;
 317
 318       _ecore_wince_event_last_time = e->timestamp;
 319       _ecore_wince_event_last_window = (Ecore_WinCE_Window *)e->window;
 320
 321       ecore_event_add(ECORE_EVENT_MOUSE_MOVE, e, NULL, NULL);
 322    }
 323
 324    {
 325       Ecore_WinCE_Event_Mouse_In *e;
 326
 327       e = (Ecore_WinCE_Event_Mouse_In *)calloc(1, sizeof(Ecore_WinCE_Event_Mouse_In));
 328       if (!e) return;
 329
 330       e->window = window;
 331       e->x = msg->x;
 332       e->y = msg->y;
 333       e->time = msg->time;
 334
 335       _ecore_wince_event_last_time = e->time;
 336
 337       ecore_event_add(ECORE_WINCE_EVENT_MOUSE_IN, e, NULL, NULL);
 338    }
 339 }
 340
 341 void
 342 _ecore_wince_event_handle_leave_notify(Ecore_WinCE_Callback_Data *msg)
 343 {
 344    Ecore_WinCE_Window *window;
 345
 346    INF("mouse out");
 347
 348    window = (void *)GetWindowLong(msg->window, GWL_USERDATA);
 349
 350    {
 351       Ecore_Event_Mouse_Move *e;
 352
 353       e = (Ecore_Event_Mouse_Move *)calloc(1, sizeof(Ecore_Event_Mouse_Move));
 354       if (!e) return;
 355
 356       e->window = (Ecore_Window)window;
 357       e->x = msg->x;
 358       e->y = msg->y;
 359       e->timestamp = msg->time;
 360
 361       _ecore_wince_event_last_time = e->timestamp;
 362       _ecore_wince_event_last_window = (Ecore_WinCE_Window *)e->window;
 363
 364       ecore_event_add(ECORE_EVENT_MOUSE_MOVE, e, NULL, NULL);
 365    }
 366
 367    {
 368       Ecore_WinCE_Event_Mouse_Out *e;
 369
 370       e = (Ecore_WinCE_Event_Mouse_Out *)calloc(1, sizeof(Ecore_WinCE_Event_Mouse_Out));
 371       if (!e) return;
 372
 373       e->window = window;
 374       e->x = msg->x;
 375       e->y = msg->y;
 376       e->time = msg->time;
 377
 378       _ecore_wince_event_last_time = e->time;
 379
 380       ecore_event_add(ECORE_WINCE_EVENT_MOUSE_OUT, e, NULL, NULL);
 381    }
 382 }
 383
 384 void
 385 _ecore_wince_event_handle_focus_in(Ecore_WinCE_Callback_Data *msg)
 386 {
 387    Ecore_WinCE_Event_Window_Focus_In *e;
 388    struct _Ecore_WinCE_Window        *window;
 389
 390    INF("focus in");
 391
 392    e = (Ecore_WinCE_Event_Window_Focus_In *)calloc(1, sizeof(Ecore_WinCE_Event_Window_Focus_In));
 393    if (!e) return;
 394
 395    window = (void *)GetWindowLong(msg->window, GWL_USERDATA);
 396    if (!e->window)
 397      {
 398         free(e);
 399         return;
 400      }
 401
 402    if (window->resume)
 403      window->resume(window->backend);
 404
 405    e->window = window;
 406
 407    e->time = _ecore_wince_event_last_time;
 408    _ecore_wince_event_last_time = e->time;
 409
 410    ecore_event_add(ECORE_WINCE_EVENT_WINDOW_FOCUS_IN, e, NULL, NULL);
 411 }
 412
 413 void
 414 _ecore_wince_event_handle_focus_out(Ecore_WinCE_Callback_Data *msg)
 415 {
 416    Ecore_WinCE_Event_Window_Focus_Out *e;
 417    struct _Ecore_WinCE_Window         *window;
 418
 419    INF("focus out");
 420
 421    e = (Ecore_WinCE_Event_Window_Focus_Out *)calloc(1, sizeof(Ecore_WinCE_Event_Window_Focus_Out));
 422    if (!e) return;
 423
 424    window = (void *)GetWindowLong(msg->window, GWL_USERDATA);
 425    if (!e->window)
 426      {
 427         free(e);
 428         return;
 429      }
 430    if (window->suspend)
 431      window->suspend(window->backend);
 432
 433    e->window = window;
 434
 435    e->time = _ecore_wince_event_last_time;
 436    _ecore_wince_event_last_time = e->time;
 437
 438    ecore_event_add(ECORE_WINCE_EVENT_WINDOW_FOCUS_OUT, e, NULL, NULL);
 439 }
 440
 441 void
 442 _ecore_wince_event_handle_expose(Ecore_WinCE_Callback_Data *msg)
 443 {
 444    Ecore_WinCE_Event_Window_Damage *e;
 445
 446    INF("window expose");
 447
 448    e = (Ecore_WinCE_Event_Window_Damage *)calloc(1, sizeof(Ecore_WinCE_Event_Window_Damage));
 449    if (!e) return;
 450
 451    e->window = (void *)GetWindowLong(msg->window, GWL_USERDATA);
 452    if (!e->window)
 453      {
 454         free(e);
 455         return;
 456      }
 457
 458    e->x = msg->update.left;
 459    e->y = msg->update.top;
 460    e->width = msg->update.right - msg->update.left;
 461    e->height = msg->update.bottom - msg->update.top;
 462    INF("window expose size: %dx%d", e->width, e->height);
 463
 464    e->time = _ecore_wince_event_last_time;
 465
 466    ecore_event_add(ECORE_WINCE_EVENT_WINDOW_DAMAGE, e, NULL, NULL);
 467 }
 468
 469 void
 470 _ecore_wince_event_handle_create_notify(Ecore_WinCE_Callback_Data *msg)
 471 {
 472    Ecore_WinCE_Event_Window_Create *e;
 473
 474    INF("window create notify");
 475
 476    e = calloc(1, sizeof(Ecore_WinCE_Event_Window_Create));
 477    if (!e) return;
 478
 479    e->window = (void *)GetWindowLong(msg->window, GWL_USERDATA);
 480    if (!e->window)
 481      {
 482         free(e);
 483         return;
 484      }
 485
 486    e->time = _ecore_wince_event_last_time;
 487
 488    ecore_event_add(ECORE_WINCE_EVENT_WINDOW_CREATE, e, NULL, NULL);
 489 }
 490
 491 void
 492 _ecore_wince_event_handle_destroy_notify(Ecore_WinCE_Callback_Data *msg)
 493 {
 494    Ecore_WinCE_Event_Window_Destroy *e;
 495
 496    INF("window destroy notify");
 497
 498    e = calloc(1, sizeof(Ecore_WinCE_Event_Window_Destroy));
 499    if (!e) return;
 500
 501    e->window = (void *)GetWindowLong(msg->window, GWL_USERDATA);
 502    if (!e->window)
 503      {
 504         free(e);
 505         return;
 506      }
 507
 508    e->time = _ecore_wince_event_last_time;
 509 /*    if (e->window == _ecore_wince_event_last_window) _ecore_wince_event_last_window = NULL; */
 510
 511    ecore_event_add(ECORE_WINCE_EVENT_WINDOW_DESTROY, e, NULL, NULL);
 512 }
 513
 514 void
 515 _ecore_wince_event_handle_map_notify(Ecore_WinCE_Callback_Data *msg)
 516 {
 517    Ecore_WinCE_Event_Window_Show *e;
 518
 519    INF("window map notify");
 520
 521    e = calloc(1, sizeof(Ecore_WinCE_Event_Window_Show));
 522    if (!e) return;
 523
 524    e->window = (void *)GetWindowLong(msg->window, GWL_USERDATA);
 525    if (!e->window)
 526      {
 527         free(e);
 528         return;
 529      }
 530
 531    e->time = _ecore_wince_event_last_time;
 532
 533    ecore_event_add(ECORE_WINCE_EVENT_WINDOW_SHOW, e, NULL, NULL);
 534 }
 535
 536 void
 537 _ecore_wince_event_handle_unmap_notify(Ecore_WinCE_Callback_Data *msg)
 538 {
 539    Ecore_WinCE_Event_Window_Hide *e;
 540
 541    INF("window unmap notify");
 542
 543    e = calloc(1, sizeof(Ecore_WinCE_Event_Window_Hide));
 544    if (!e) return;
 545
 546    e->window = (void *)GetWindowLong(msg->window, GWL_USERDATA);
 547    if (!e->window)
 548      {
 549         free(e);
 550         return;
 551      }
 552
 553    e->time = _ecore_wince_event_last_time;
 554
 555    ecore_event_add(ECORE_WINCE_EVENT_WINDOW_HIDE, e, NULL, NULL);
 556 }
 557
 558 void
 559 _ecore_wince_event_handle_delete_request(Ecore_WinCE_Callback_Data *msg)
 560 {
 561    Ecore_WinCE_Event_Window_Delete_Request *e;
 562
 563    INF("window delete request");
 564
 565    e = calloc(1, sizeof(Ecore_WinCE_Event_Window_Delete_Request));
 566    if (!e) return;
 567
 568    e->window = (void *)GetWindowLong(msg->window, GWL_USERDATA);
 569    if (!e->window)
 570      {
 571         free(e);
 572         return;
 573      }
 574
 575    e->time = _ecore_wince_event_last_time;
 576
 577    ecore_event_add(ECORE_WINCE_EVENT_WINDOW_DELETE_REQUEST, e, NULL, NULL);
 578 }
 579
 580
 581 /***** Private functions definitions *****/
 582
 583 static void
 584 _ecore_wince_event_free_key_down(void *data __UNUSED__,
 585                                  void *ev)
 586 {
 587    Ecore_Event_Key *e;
 588
 589    e = ev;
 590    if (e->keyname) free((char *)e->keyname);
 591    if (e->key) free((char *)e->key);
 592    if (e->string) free((char *)e->string);
 593    free(e);
 594 }
 595
 596 static void
 597 _ecore_wince_event_free_key_up(void *data __UNUSED__,
 598                                void *ev)
 599 {
 600    Ecore_Event_Key *e;
 601
 602    e = ev;
 603    if (e->keyname) free((char *)e->keyname);
 604    if (e->key) free((char *)e->key);
 605    if (e->string) free((char *)e->string);
 606    free(e);
 607 }
 608
 609 static int
 610 _ecore_wince_event_keystroke_get(int    key,
 611                                  char **keyname,
 612                                  char **keysymbol,
 613                                  char **keycompose)
 614 {
 615   char *kn;
 616   char *ks;
 617   char *kc;
 618
 619   *keyname = NULL;
 620   *keysymbol = NULL;
 621   *keycompose = NULL;
 622
 623    switch (key)
 624      {
 625        /* Keystroke */
 626      case VK_PRIOR:
 627        kn = "Prior";
 628        ks = "Prior";
 629        kc = "Prior";
 630        break;
 631      case VK_NEXT:
 632        kn = "Next";
 633        ks = "Next";
 634        kc = "Next";
 635        break;
 636      case VK_END:
 637        kn = "End";
 638        ks = "End";
 639        kc = "End";
 640        break;
 641      case VK_HOME:
 642        kn = "Home";
 643        ks = "Home";
 644        kc = "Home";
 645        break;
 646      case VK_LEFT:
 647        kn = "Left";
 648        ks = "Left";
 649        kc = "Left";
 650        break;
 651      case VK_UP:
 652        kn = "Up";
 653        ks = "Up";
 654        kc = "Up";
 655        break;
 656      case VK_RIGHT:
 657        kn = "Right";
 658        ks = "Right";
 659        kc = "Right";
 660        break;
 661      case VK_DOWN:
 662        kn = "Down";
 663        ks = "Down";
 664        kc = "Down";
 665        break;
 666      case VK_INSERT:
 667        kn = "Insert";
 668        ks = "Insert";
 669        kc = "Insert";
 670        break;
 671      case VK_DELETE:
 672        kn = "Delete";
 673        ks = "Delete";
 674        kc = "Delete";
 675        break;
 676      case VK_F1:
 677        kn = "F1";
 678        ks = "F1";
 679        kc = "";
 680        break;
 681      case VK_F2:
 682        kn = "F2";
 683        ks = "F2";
 684        kc = "";
 685        break;
 686      case VK_F3:
 687        kn = "F3";
 688        ks = "F3";
 689        kc = "";
 690        break;
 691      case VK_F4:
 692        kn = "F4";
 693        ks = "F4";
 694        kc = "";
 695        break;
 696      case VK_F5:
 697        kn = "F5";
 698        ks = "F5";
 699        kc = "";
 700        break;
 701      case VK_F6:
 702        kn = "F6";
 703        ks = "F6";
 704        kc = "";
 705        break;
 706      case VK_F7:
 707        kn = "F7";
 708        ks = "F7";
 709        kc = "";
 710        break;
 711      case VK_F8:
 712        kn = "F8";
 713        ks = "F8";
 714        kc = "";
 715        break;
 716      case VK_F9:
 717        kn = "F9";
 718        ks = "F9";
 719        kc = "";
 720        break;
 721      case VK_F10:
 722        kn = "F10";
 723        ks = "F10";
 724        kc = "";
 725        break;
 726      case VK_F11:
 727        kn = "F11";
 728        ks = "F11";
 729        kc = "";
 730        break;
 731      case VK_F12:
 732        kn = "F12";
 733        ks = "F12";
 734        kc = "";
 735        break;
 736      case VK_F13:
 737        kn = "F13";
 738        ks = "F13";
 739        kc = "";
 740        break;
 741      case VK_F14:
 742        kn = "F14";
 743        ks = "F14";
 744        kc = "";
 745        break;
 746      case VK_F15:
 747        kn = "F15";
 748        ks = "F15";
 749        kc = "";
 750        break;
 751      case VK_F16:
 752        kn = "F16";
 753        ks = "F16";
 754        kc = "";
 755        break;
 756      case VK_F17:
 757        kn = "F17";
 758        ks = "F17";
 759        kc = "";
 760        break;
 761      case VK_F18:
 762        kn = "F18";
 763        ks = "F18";
 764        kc = "";
 765        break;
 766      case VK_F19:
 767        kn = "F19";
 768        ks = "F19";
 769        kc = "";
 770        break;
 771      case VK_F20:
 772        /*
 773        * VK_F20 indicates that an arrow key came from a rocker.
 774        * This can safely be ignored.
 775        */
 776        return 0;
 777      case VK_F21:
 778        /*
 779        * VK_F21 indicates that an arrow key came from a directional
 780        * pad. This can safely be ignored.
 781        */
 782        return 0;
 783      case VK_F22:
 784        kn = "F22";
 785        ks = "F22";
 786        kc = "";
 787        break;
 788      case VK_F23:
 789        /*
 790        * Sent with VK_RETURN when doing an action (usually the middle
 791        * button on a directional pad. This can safely be ignored.
 792        */
 793        return 0;
 794      case VK_F24:
 795        kn = "F24";
 796        ks = "F24";
 797        kc = "";
 798        break;
 799      case VK_APPS:
 800        kn = "Application";
 801        ks = "Application";
 802        kc = "";
 803        break;
 804      case VK_MENU:
 805        kn = "Menu";
 806        ks = "Menu";
 807        kc = "";
 808        break;
 809      default:
 810        /* other non keystroke characters */
 811        return 0;
 812      }
 813    *keyname = strdup(kn);
 814    if (!*keyname) return 0;
 815    *keysymbol = strdup(ks);
 816    if (!*keysymbol)
 817      {
 818         free(*keyname);
 819         *keyname = NULL;
 820         return 0;
 821      }
 822    *keycompose = strdup(kc);
 823    if (!*keycompose)
 824      {
 825         free(*keyname);
 826         free(*keysymbol);
 827         *keyname = NULL;
 828         *keysymbol = NULL;
 829         return 0;
 830      }
 831
 832    return 1;
 833 }
 834
 835 static int
 836 _ecore_wince_event_char_get(int    key,
 837                             char **keyname,
 838                             char **keysymbol,
 839                             char **keycompose)
 840 {
 841   char kn[32];
 842   char ks[32];
 843   char kc[32];
 844
 845   *keyname = NULL;
 846   *keysymbol = NULL;
 847   *keycompose = NULL;
 848
 849    switch (key)
 850      {
 851      case VK_APP3:
 852      case VK_BACK:
 853        strncpy(kn, "BackSpace", 32);
 854        strncpy(ks, "BackSpace", 32);
 855        strncpy(kc, "BackSpace", 32);
 856        break;
 857      case VK_APP4:
 858      case VK_TAB:
 859        strncpy(kn, "Tab", 32);
 860        strncpy(ks, "Tab", 32);
 861        strncpy(kc, "Tab", 32);
 862        break;
 863      case VK_APP5:
 864      case 0x0a:
 865        /* Line feed (Shift + Enter) */
 866        strncpy(kn, "LineFeed", 32);
 867        strncpy(ks, "LineFeed", 32);
 868        strncpy(kc, "LineFeed", 32);
 869        break;
 870      case VK_APP2:
 871      case VK_RETURN:
 872        strncpy(kn, "Return", 32);
 873        strncpy(ks, "Return", 32);
 874        strncpy(kc, "Return", 32);
 875        break;
 876      case VK_APP1:
 877      case VK_ESCAPE:
 878        strncpy(kn, "Escape", 32);
 879        strncpy(ks, "Escape", 32);
 880        strncpy(kc, "Escape", 32);
 881        break;
 882      default:
 883        /* displayable characters */
 884        printf (" * key : %d\n", key);
 885        kn[0] = (TCHAR)key;
 886        kn[1] = '\0';
 887        ks[0] = (TCHAR)key;
 888        ks[1] = '\0';
 889        kc[0] = (TCHAR)key;
 890        kc[1] = '\0';
 891        break;
 892      }
 893    *keyname = strdup(kn);
 894    if (!*keyname) return 0;
 895    *keysymbol = strdup(ks);
 896    if (!*keysymbol)
 897      {
 898         free(*keyname);
 899         *keyname = NULL;
 900         return 0;
 901      }
 902    *keycompose = strdup(kc);
 903    if (!*keycompose)
 904      {
 905         free(*keyname);
 906         free(*keysymbol);
 907         *keyname = NULL;
 908         *keysymbol = NULL;
 909         return 0;
 910      }
 911
 912    return 1;
 913 }