src/lib/ecore_wince/ecore_wince_event.c

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