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  *                                  Local                                     *
  20  *============================================================================*/
  21
  22 /**
  23  * @cond LOCAL
  24  */
  25
  26 typedef enum
  27 {
  28    ECORE_WINCE_KEY_MASK_LSHIFT = 1 << 0,
  29    ECORE_WINCE_KEY_MASK_RSHIFT = 1 << 1,
  30    ECORE_WINCE_KEY_MASK_LCONTROL = 1 << 2,
  31    ECORE_WINCE_KEY_MASK_RCONTROL = 1 << 3,
  32    ECORE_WINCE_KEY_MASK_LMENU = 1 << 4,
  33    ECORE_WINCE_KEY_MASK_RMENU = 1 << 5
  34 } Ecore_Wince_Key_Mask;
  35
  36 static Ecore_WinCE_Window  *_ecore_wince_mouse_down_last_window = NULL;
  37 static Ecore_WinCE_Window  *_ecore_wince_mouse_down_last_last_window = NULL;
  38 static long                 _ecore_wince_mouse_down_last_time = 0;
  39 static long                 _ecore_wince_mouse_down_last_last_time = 0;
  40 static int                  _ecore_wince_mouse_down_did_triple = 0;
  41 static int                  _ecore_wince_mouse_up_count = 0;
  42 static Ecore_Wince_Key_Mask _ecore_wince_key_mask = 0;
  43
  44 static void
  45 _ecore_wince_event_free_key_down(void *data __UNUSED__,
  46                                  void *ev)
  47 {
  48    Ecore_Event_Key *e;
  49
  50    e = ev;
  51    if (e->keyname) free((char *)e->keyname);
  52    if (e->key) free((char *)e->key);
  53    if (e->string) free((char *)e->string);
  54    free(e);
  55 }
  56
  57 static void
  58 _ecore_wince_event_free_key_up(void *data __UNUSED__,
  59                                void *ev)
  60 {
  61    Ecore_Event_Key *e;
  62
  63    e = ev;
  64    if (e->keyname) free((char *)e->keyname);
  65    if (e->key) free((char *)e->key);
  66    if (e->string) free((char *)e->string);
  67    free(e);
  68 }
  69
  70 static int
  71 _ecore_wince_event_keystroke_get(int       key,
  72                                  Eina_Bool is_down,
  73                                  char    **keyname,
  74                                  char    **keysymbol,
  75                                  char    **keycompose)
  76 {
  77   char *kn;
  78   char *ks;
  79   char *kc;
  80   int previous_key_state;
  81
  82   previous_key_state = msg->data_param & 0x40000000;
  83
  84   *keyname = NULL;
  85   *keysymbol = NULL;
  86   *keycompose = NULL;
  87
  88    switch (key)
  89      {
  90        /* Keystroke */
  91      case VK_PRIOR:
  92        kn = "Prior";
  93        ks = "Prior";
  94        kc = "Prior";
  95        break;
  96      case VK_NEXT:
  97        kn = "Next";
  98        ks = "Next";
  99        kc = "Next";
 100        break;
 101      case VK_END:
 102        kn = "End";
 103        ks = "End";
 104        kc = "End";
 105        break;
 106      case VK_HOME:
 107        kn = "Home";
 108        ks = "Home";
 109        kc = "Home";
 110        break;
 111      case VK_LEFT:
 112        kn = "Left";
 113        ks = "Left";
 114        kc = "Left";
 115        break;
 116      case VK_UP:
 117        kn = "Up";
 118        ks = "Up";
 119        kc = "Up";
 120        break;
 121      case VK_RIGHT:
 122        kn = "Right";
 123        ks = "Right";
 124        kc = "Right";
 125        break;
 126      case VK_DOWN:
 127        kn = "Down";
 128        ks = "Down";
 129        kc = "Down";
 130        break;
 131      case VK_INSERT:
 132        kn = "Insert";
 133        ks = "Insert";
 134        kc = "Insert";
 135        break;
 136      case VK_DELETE:
 137        kn = "Delete";
 138        ks = "Delete";
 139        kc = "Delete";
 140        break;
 141      case VK_F1:
 142        kn = "F1";
 143        ks = "F1";
 144        kc = "";
 145        break;
 146      case VK_F2:
 147        kn = "F2";
 148        ks = "F2";
 149        kc = "";
 150        break;
 151      case VK_F3:
 152        kn = "F3";
 153        ks = "F3";
 154        kc = "";
 155        break;
 156      case VK_F4:
 157        kn = "F4";
 158        ks = "F4";
 159        kc = "";
 160        break;
 161      case VK_F5:
 162        kn = "F5";
 163        ks = "F5";
 164        kc = "";
 165        break;
 166      case VK_F6:
 167        kn = "F6";
 168        ks = "F6";
 169        kc = "";
 170        break;
 171      case VK_F7:
 172        kn = "F7";
 173        ks = "F7";
 174        kc = "";
 175        break;
 176      case VK_F8:
 177        kn = "F8";
 178        ks = "F8";
 179        kc = "";
 180        break;
 181      case VK_F9:
 182        kn = "F9";
 183        ks = "F9";
 184        kc = "";
 185        break;
 186      case VK_F10:
 187        kn = "F10";
 188        ks = "F10";
 189        kc = "";
 190        break;
 191      case VK_F11:
 192        kn = "F11";
 193        ks = "F11";
 194        kc = "";
 195        break;
 196      case VK_F12:
 197        kn = "F12";
 198        ks = "F12";
 199        kc = "";
 200        break;
 201      case VK_F13:
 202        kn = "F13";
 203        ks = "F13";
 204        kc = "";
 205        break;
 206      case VK_F14:
 207        kn = "F14";
 208        ks = "F14";
 209        kc = "";
 210        break;
 211      case VK_F15:
 212        kn = "F15";
 213        ks = "F15";
 214        kc = "";
 215        break;
 216      case VK_F16:
 217        kn = "F16";
 218        ks = "F16";
 219        kc = "";
 220        break;
 221      case VK_F17:
 222        kn = "F17";
 223        ks = "F17";
 224        kc = "";
 225        break;
 226      case VK_F18:
 227        kn = "F18";
 228        ks = "F18";
 229        kc = "";
 230        break;
 231      case VK_F19:
 232        kn = "F19";
 233        ks = "F19";
 234        kc = "";
 235        break;
 236      case VK_F20:
 237        /*
 238        * VK_F20 indicates that an arrow key came from a rocker.
 239        * This can safely be ignored.
 240        */
 241        return 0;
 242      case VK_F21:
 243        /*
 244        * VK_F21 indicates that an arrow key came from a directional
 245        * pad. This can safely be ignored.
 246        */
 247        return 0;
 248      case VK_F22:
 249        kn = "F22";
 250        ks = "F22";
 251        kc = "";
 252        break;
 253      case VK_F23:
 254        /*
 255        * Sent with VK_RETURN when doing an action (usually the middle
 256        * button on a directional pad. This can safely be ignored.
 257        */
 258        return 0;
 259      case VK_F24:
 260        kn = "F24";
 261        ks = "F24";
 262        kc = "";
 263        break;
 264      case VK_APPS:
 265        kn = "Application";
 266        ks = "Application";
 267        kc = "";
 268        break;
 269      case VK_SHIFT:
 270        {
 271           SHORT res;
 272
 273           if (is_down)
 274             {
 275                if (previous_key_state) return 0;
 276                res = GetKeyState(VK_LSHIFT);
 277                if (res & 0x8000)
 278                  {
 279                     _ecore_wince_key_mask |= ECORE_WINCE_KEY_MASK_LSHIFT;
 280                     kn = "Shift_L";
 281                     ks = "Shift_L";
 282                     kc = "";
 283                  }
 284                res = GetKeyState(VK_RSHIFT);
 285                if (res & 0x8000)
 286                  {
 287                     _ecore_wince_key_mask |= ECORE_WINCE_KEY_MASK_RSHIFT;
 288                     kn = "Shift_R";
 289                     ks = "Shift_R";
 290                     kc = "";
 291                  }
 292             }
 293           else /* is_up */
 294             {
 295                res = GetKeyState(VK_LSHIFT);
 296                if (!(res & 0x8000) &&
 297                    (_ecore_wince_key_mask & ECORE_WINCE_KEY_MASK_LSHIFT))
 298                  {
 299                     kn = "Shift_L";
 300                     ks = "Shift_L";
 301                     kc = "";
 302                     _ecore_wince_key_mask &= ~ECORE_WINCE_KEY_MASK_LSHIFT;
 303                  }
 304                res = GetKeyState(VK_RSHIFT);
 305                if (!(res & 0x8000) &&
 306                    (_ecore_wince_key_mask & ECORE_WINCE_KEY_MASK_RSHIFT))
 307                  {
 308                     kn = "Shift_R";
 309                     ks = "Shift_R";
 310                     kc = "";
 311                     _ecore_wince_key_mask &= ~ECORE_WINCE_KEY_MASK_RSHIFT;
 312                  }
 313             }
 314           break;
 315        }
 316      case VK_CONTROL:
 317        {
 318           SHORT res;
 319
 320           if (is_down)
 321             {
 322                if (previous_key_state) return 0;
 323                res = GetKeyState(VK_LCONTROL);
 324                if (res & 0x8000)
 325                  {
 326                     _ecore_wince_key_mask |= ECORE_WINCE_KEY_MASK_LCONTROL;
 327                     kn = "Control_L";
 328                     ks = "Control_L";
 329                     kc = "";
 330                     break;
 331                  }
 332                res = GetKeyState(VK_RCONTROL);
 333                if (res & 0x8000)
 334                  {
 335                     _ecore_wince_key_mask |= ECORE_WINCE_KEY_MASK_RCONTROL;
 336                     kn = "Control_R";
 337                     ks = "Control_R";
 338                     kc = "";
 339                     break;
 340                  }
 341             }
 342           else /* is_up */
 343             {
 344                res = GetKeyState(VK_LCONTROL);
 345                if (!(res & 0x8000) &&
 346                    (_ecore_wince_key_mask & ECORE_WINCE_KEY_MASK_LCONTROL))
 347                  {
 348                     kn = "Control_L";
 349                     ks = "Control_L";
 350                     kc = "";
 351                     _ecore_wince_key_mask &= ~ECORE_WINCE_KEY_MASK_LCONTROL;
 352                     break;
 353                  }
 354                res = GetKeyState(VK_RCONTROL);
 355                if (!(res & 0x8000) &&
 356                    (_ecore_wince_key_mask & ECORE_WINCE_KEY_MASK_RCONTROL))
 357                  {
 358                     kn = "Control_R";
 359                     ks = "Control_R";
 360                     kc = "";
 361                     _ecore_wince_key_mask &= ~ECORE_WINCE_KEY_MASK_RCONTROL;
 362                     break;
 363                  }
 364             }
 365           break;
 366        }
 367      case VK_MENU:
 368        {
 369           SHORT res;
 370
 371           if (is_down)
 372             {
 373                if (previous_key_state) return 0;
 374                res = GetKeyState(VK_LMENU);
 375                if (res & 0x8000)
 376                  {
 377                     _ecore_wince_key_mask |= ECORE_WINCE_KEY_MASK_LMENU;
 378                     kn = "Alt_L";
 379                     ks = "Alt_L";
 380                     kc = "";
 381                  }
 382                res = GetKeyState(VK_RMENU);
 383                if (res & 0x8000)
 384                  {
 385                     _ecore_wince_key_mask |= ECORE_WINCE_KEY_MASK_RMENU;
 386                     kn = "Alt_R";
 387                     ks = "Alt_R";
 388                     kc = "";
 389                  }
 390             }
 391           else /* is_up */
 392             {
 393                res = GetKeyState(VK_LMENU);
 394                if (!(res & 0x8000) &&
 395                    (_ecore_wince_key_mask & ECORE_WINCE_KEY_MASK_LMENU))
 396                  {
 397                     kn = "Alt_L";
 398                     ks = "Alt_L";
 399                     kc = "";
 400                     _ecore_wince_key_mask &= ~ECORE_WINCE_KEY_MASK_LMENU;
 401                  }
 402                res = GetKeyState(VK_RMENU);
 403                if (!(res & 0x8000) &&
 404                    (_ecore_wince_key_mask & ECORE_WINCE_KEY_MASK_RMENU))
 405                  {
 406                     kn = "Alt_R";
 407                     ks = "Alt_R";
 408                     kc = "";
 409                     _ecore_wince_key_mask &= ~ECORE_WINCE_KEY_MASK_RMENU;
 410                  }
 411             }
 412           break;
 413        }
 414      case VK_LWIN:
 415        {
 416           if (is_down)
 417             {
 418                if (previous_key_state) return 0;
 419                kn = "Super_L";
 420                ks = "Super_L";
 421                kc = "";
 422                *modifiers |= ECORE_EVENT_MODIFIER_WIN;
 423             }
 424           else /* is_up */
 425             {
 426                kn = "Super_L";
 427                ks = "Super_L";
 428                kc = "";
 429                *modifiers &= ~ECORE_EVENT_MODIFIER_WIN;
 430             }
 431           break;
 432        }
 433      case VK_RWIN:
 434        {
 435           if (is_down)
 436             {
 437                if (previous_key_state) return 0;
 438                kn = "Super_R";
 439                ks = "Super_R";
 440                kc = "";
 441                *modifiers |= ECORE_EVENT_MODIFIER_WIN;
 442             }
 443           else /* is_up */
 444             {
 445                kn = "Super_R";
 446                ks = "Super_R";
 447                kc = "";
 448                *modifiers &= ~ECORE_EVENT_MODIFIER_WIN;
 449             }
 450           break;
 451        }
 452      default:
 453        /* other non keystroke characters */
 454        return 0;
 455      }
 456    *keyname = strdup(kn);
 457    if (!*keyname) return 0;
 458    *keysymbol = strdup(ks);
 459    if (!*keysymbol)
 460      {
 461         free(*keyname);
 462         *keyname = NULL;
 463         return 0;
 464      }
 465    *keycompose = strdup(kc);
 466    if (!*keycompose)
 467      {
 468         free(*keyname);
 469         free(*keysymbol);
 470         *keyname = NULL;
 471         *keysymbol = NULL;
 472         return 0;
 473      }
 474
 475    return 1;
 476 }
 477
 478 static int
 479 _ecore_wince_event_char_get(int    key,
 480                             char **keyname,
 481                             char **keysymbol,
 482                             char **keycompose)
 483 {
 484   char kn[32];
 485   char ks[32];
 486   char kc[32];
 487
 488   *keyname = NULL;
 489   *keysymbol = NULL;
 490   *keycompose = NULL;
 491
 492    /* check control charaters such as ^a(key:1), ^z(key:26) */
 493    if ((key > 0) && (key < 27) &&
 494        ((GetKeyState(VK_CONTROL) & 0x8000) ||
 495         (GetKeyState(VK_CONTROL) & 0x8000))) key += 96;
 496
 497    switch (key)
 498      {
 499      case VK_APP3:
 500      case VK_BACK:
 501        strncpy(kn, "BackSpace", 32);
 502        strncpy(ks, "BackSpace", 32);
 503        strncpy(kc, "BackSpace", 32);
 504        break;
 505      case VK_APP4:
 506      case VK_TAB:
 507        strncpy(kn, "Tab", 32);
 508        strncpy(ks, "Tab", 32);
 509        strncpy(kc, "Tab", 32);
 510        break;
 511      case VK_APP5:
 512      case 0x0a:
 513        /* Line feed (Shift + Enter) */
 514        strncpy(kn, "LineFeed", 32);
 515        strncpy(ks, "LineFeed", 32);
 516        strncpy(kc, "LineFeed", 32);
 517        break;
 518      case VK_APP2:
 519      case VK_RETURN:
 520        strncpy(kn, "Return", 32);
 521        strncpy(ks, "Return", 32);
 522        strncpy(kc, "Return", 32);
 523        break;
 524      case VK_APP1:
 525      case VK_ESCAPE:
 526        strncpy(kn, "Escape", 32);
 527        strncpy(ks, "Escape", 32);
 528        strncpy(kc, "Escape", 32);
 529        break;
 530      case VK_SPACE:
 531        strncpy(kn, "space", 32);
 532        strncpy(ks, "space", 32);
 533        strncpy(kc, " ", 32);
 534        break;
 535      default:
 536        /* displayable characters */
 537        printf (" * key : %d\n", key);
 538        kn[0] = (TCHAR)key;
 539        kn[1] = '\0';
 540        ks[0] = (TCHAR)key;
 541        ks[1] = '\0';
 542        kc[0] = (TCHAR)key;
 543        kc[1] = '\0';
 544        break;
 545      }
 546    *keyname = strdup(kn);
 547    if (!*keyname) return 0;
 548    *keysymbol = strdup(ks);
 549    if (!*keysymbol)
 550      {
 551         free(*keyname);
 552         *keyname = NULL;
 553         return 0;
 554      }
 555    *keycompose = strdup(kc);
 556    if (!*keycompose)
 557      {
 558         free(*keyname);
 559         free(*keysymbol);
 560         *keyname = NULL;
 561         *keysymbol = NULL;
 562         return 0;
 563      }
 564
 565    return 1;
 566 }
 567
 568 /**
 569  * @endcond
 570  */
 571
 572
 573 /*============================================================================*
 574  *                                 Global                                     *
 575  *============================================================================*/
 576
 577 void
 578 _ecore_wince_event_handle_key_press(Ecore_WinCE_Callback_Data *msg,
 579                                     int                        is_keystroke)
 580 {
 581    Ecore_Event_Key *e;
 582
 583    INF("key pressed");
 584
 585    e = (Ecore_Event_Key *)malloc(sizeof(Ecore_Event_Key));
 586    if (!e) return;
 587
 588    if (is_keystroke)
 589      {
 590         if (!_ecore_wince_event_keystroke_get(LOWORD(msg->window_param),
 591                                               EINA_TRUE,
 592                                               (char **)&e->keyname,
 593                                               (char **)&e->key,
 594                                               (char **)&e->string))
 595           {
 596              free(e);
 597              return;
 598           }
 599      }
 600    else
 601      {
 602         if (!_ecore_wince_event_char_get(LOWORD(msg->window_param),
 603                                          (char **)&e->keyname,
 604                                          (char **)&e->key,
 605                                          (char **)&e->string))
 606           {
 607              free(e);
 608              return;
 609           }
 610      }
 611
 612    e->window = (Ecore_Window)GetWindowLong(msg->window, GWL_USERDATA);
 613    e->event_window = e->window;
 614    if (!e->window)
 615      {
 616         free(e);
 617         return;
 618      }
 619    e->timestamp = msg->time;
 620
 621    _ecore_wince_event_last_time = e->timestamp;
 622
 623    ecore_event_add(ECORE_EVENT_KEY_DOWN, e, _ecore_wince_event_free_key_down, NULL);
 624 }
 625
 626 void
 627 _ecore_wince_event_handle_key_release(Ecore_WinCE_Callback_Data *msg,
 628                                       int                        is_keystroke)
 629 {
 630    Ecore_Event_Key *e;
 631
 632    INF("key released");
 633
 634    e = (Ecore_Event_Key *)calloc(1, sizeof(Ecore_Event_Key));
 635    if (!e) return;
 636
 637    if (is_keystroke)
 638      {
 639         if (!_ecore_wince_event_keystroke_get(LOWORD(msg->window_param),
 640                                               EINA_FALSE,
 641                                               (char **)&e->keyname,
 642                                               (char **)&e->key,
 643                                               (char **)&e->string))
 644           {
 645              free(e);
 646              return;
 647           }
 648      }
 649    else
 650      {
 651         if (!_ecore_wince_event_char_get(LOWORD(msg->window_param),
 652                                          (char **)&e->keyname,
 653                                          (char **)&e->key,
 654                                          (char **)&e->string))
 655           {
 656              free(e);
 657              return;
 658           }
 659      }
 660
 661    e->window = (Ecore_Window)GetWindowLong(msg->window, GWL_USERDATA);
 662    e->event_window = e->window;
 663    if (!e->window)
 664      {
 665         free(e);
 666         return;
 667      }
 668    e->timestamp = msg->time;
 669
 670    _ecore_wince_event_last_time = e->timestamp;
 671
 672    ecore_event_add(ECORE_EVENT_KEY_UP, e, _ecore_wince_event_free_key_up, NULL);
 673 }
 674
 675 void
 676 _ecore_wince_event_handle_button_press(Ecore_WinCE_Callback_Data *msg,
 677                                        int                        button)
 678 {
 679    Ecore_WinCE_Window *window;
 680
 681    INF("mouse button pressed");
 682
 683    window = (Ecore_WinCE_Window *)GetWindowLong(msg->window, GWL_USERDATA);
 684
 685    {
 686       Ecore_Event_Mouse_Move *e;
 687
 688       e = (Ecore_Event_Mouse_Move *)calloc(1, sizeof(Ecore_Event_Mouse_Move));
 689       if (!e) return;
 690
 691       e->window = (Ecore_Window)window;
 692       e->event_window = e->window;
 693       e->x = LOWORD(msg->data_param);
 694       e->y = HIWORD(msg->data_param);
 695       e->timestamp = msg->time;
 696
 697       _ecore_wince_event_last_time = e->timestamp;
 698       _ecore_wince_event_last_window = (Ecore_WinCE_Window *)e->window;
 699
 700       ecore_event_add(ECORE_EVENT_MOUSE_MOVE, e, NULL, NULL);
 701    }
 702
 703    {
 704       Ecore_Event_Mouse_Button *e;
 705
 706       if (_ecore_wince_mouse_down_did_triple)
 707         {
 708            _ecore_wince_mouse_down_last_window = NULL;
 709            _ecore_wince_mouse_down_last_last_window = NULL;
 710            _ecore_wince_mouse_down_last_time = 0;
 711            _ecore_wince_mouse_down_last_last_time = 0;
 712         }
 713
 714       e = (Ecore_Event_Mouse_Button *)calloc(1, sizeof(Ecore_Event_Mouse_Button));
 715       if (!e) return;
 716
 717       e->window = (Ecore_Window)window;
 718       e->event_window = e->window;
 719       e->buttons = button;
 720       e->x = LOWORD(msg->data_param);
 721       e->y = HIWORD(msg->data_param);
 722       e->timestamp = msg->time;
 723
 724       if (((e->timestamp - _ecore_wince_mouse_down_last_time) <= (long)(1000 * _ecore_wince_double_click_time)) &&
 725           (e->window == (Ecore_Window)_ecore_wince_mouse_down_last_window))
 726         e->double_click = 1;
 727
 728       if (((e->timestamp - _ecore_wince_mouse_down_last_last_time) <= (long)(2 * 1000 * _ecore_wince_double_click_time)) &&
 729           (e->window == (Ecore_Window)_ecore_wince_mouse_down_last_window) &&
 730           (e->window == (Ecore_Window)_ecore_wince_mouse_down_last_last_window))
 731         {
 732            e->triple_click = 1;
 733            _ecore_wince_mouse_down_did_triple = 1;
 734         }
 735       else
 736         _ecore_wince_mouse_down_did_triple = 0;
 737
 738       if (!e->double_click && !e->triple_click)
 739         _ecore_wince_mouse_up_count = 0;
 740
 741       _ecore_wince_event_last_time = e->timestamp;
 742       _ecore_wince_event_last_window = (Ecore_WinCE_Window *)e->window;
 743
 744       if (!_ecore_wince_mouse_down_did_triple)
 745         {
 746            _ecore_wince_mouse_down_last_last_window = _ecore_wince_mouse_down_last_window;
 747            _ecore_wince_mouse_down_last_window = (Ecore_WinCE_Window *)e->window;
 748            _ecore_wince_mouse_down_last_last_time = _ecore_wince_mouse_down_last_time;
 749            _ecore_wince_mouse_down_last_time = e->timestamp;
 750         }
 751
 752       ecore_event_add(ECORE_EVENT_MOUSE_BUTTON_DOWN, e, NULL, NULL);
 753    }
 754 }
 755
 756 void
 757 _ecore_wince_event_handle_button_release(Ecore_WinCE_Callback_Data *msg,
 758                                          int                        button)
 759 {
 760    Ecore_WinCE_Window *window;
 761
 762    INF("mouse button released");
 763
 764    window = (void *)GetWindowLong(msg->window, GWL_USERDATA);
 765
 766    {
 767       Ecore_Event_Mouse_Move *e;
 768
 769       e = (Ecore_Event_Mouse_Move *)calloc(1, sizeof(Ecore_Event_Mouse_Move));
 770       if (!e) return;
 771
 772       e->window = (Ecore_Window)window;
 773       e->event_window = e->window;
 774       e->x = LOWORD(msg->data_param);
 775       e->y = HIWORD(msg->data_param);
 776       e->timestamp = msg->time;
 777
 778       _ecore_wince_event_last_time = e->timestamp;
 779       _ecore_wince_event_last_window = (Ecore_WinCE_Window *)e->window;
 780
 781       ecore_event_add(ECORE_EVENT_MOUSE_MOVE, e, NULL, NULL);
 782    }
 783
 784    {
 785       Ecore_Event_Mouse_Button *e;
 786
 787       e = (Ecore_Event_Mouse_Button *)calloc(1, sizeof(Ecore_Event_Mouse_Button));
 788       if (!e) return;
 789
 790       e->window = (Ecore_Window)window;
 791       e->event_window = e->window;
 792       e->buttons = button;
 793       e->x = LOWORD(msg->data_param);
 794       e->y = HIWORD(msg->data_param);
 795       e->timestamp = msg->time;
 796
 797       _ecore_wince_mouse_up_count++;
 798
 799       if ((_ecore_wince_mouse_up_count >= 2) &&
 800           ((e->timestamp - _ecore_wince_mouse_down_last_time) <= (long)(1000 * _ecore_wince_double_click_time)) &&
 801           (e->window == (Ecore_Window)_ecore_wince_mouse_down_last_window))
 802         e->double_click = 1;
 803
 804       if ((_ecore_wince_mouse_up_count >= 3) &&
 805           ((e->timestamp - _ecore_wince_mouse_down_last_last_time) <= (long)(2 * 1000 * _ecore_wince_double_click_time)) &&
 806           (e->window == (Ecore_Window)_ecore_wince_mouse_down_last_window) &&
 807           (e->window == (Ecore_Window)_ecore_wince_mouse_down_last_last_window))
 808         e->triple_click = 1;
 809
 810       _ecore_wince_event_last_time = e->timestamp;
 811       _ecore_wince_event_last_window = (Ecore_WinCE_Window *)e->window;
 812
 813       ecore_event_add(ECORE_EVENT_MOUSE_BUTTON_UP, e, NULL, NULL);
 814    }
 815 }
 816
 817 void
 818 _ecore_wince_event_handle_motion_notify(Ecore_WinCE_Callback_Data *msg)
 819 {
 820    Ecore_Event_Mouse_Move *e;
 821
 822    INF("mouse moved");
 823
 824    e = (Ecore_Event_Mouse_Move *)calloc(1, sizeof(Ecore_Event_Mouse_Move));
 825    if (!e) return;
 826
 827    e->window = (Ecore_Window)GetWindowLong(msg->window, GWL_USERDATA);
 828    e->event_window = e->window;
 829    e->x = LOWORD(msg->data_param);
 830    e->y = HIWORD(msg->data_param);
 831    e->timestamp = msg->time;
 832
 833    ecore_event_add(ECORE_EVENT_MOUSE_MOVE, e, NULL, NULL);
 834 }
 835
 836 void
 837 _ecore_wince_event_handle_enter_notify(Ecore_WinCE_Callback_Data *msg)
 838 {
 839    Ecore_WinCE_Window *window;
 840
 841    INF("mouse in");
 842
 843    window = (void *)GetWindowLong(msg->window, GWL_USERDATA);
 844
 845    {
 846       Ecore_Event_Mouse_Move *e;
 847
 848       e = (Ecore_Event_Mouse_Move *)calloc(1, sizeof(Ecore_Event_Mouse_Move));
 849       if (!e) return;
 850
 851       e->window = (Ecore_Window)window;
 852       e->event_window = e->window;
 853       e->x = msg->x;
 854       e->y = msg->y;
 855       e->timestamp = msg->time;
 856
 857       _ecore_wince_event_last_time = e->timestamp;
 858       _ecore_wince_event_last_window = (Ecore_WinCE_Window *)e->window;
 859
 860       ecore_event_add(ECORE_EVENT_MOUSE_MOVE, e, NULL, NULL);
 861    }
 862
 863    {
 864       Ecore_WinCE_Event_Mouse_In *e;
 865
 866       e = (Ecore_WinCE_Event_Mouse_In *)calloc(1, sizeof(Ecore_WinCE_Event_Mouse_In));
 867       if (!e) return;
 868
 869       e->window = window;
 870       e->x = msg->x;
 871       e->y = msg->y;
 872       e->time = msg->time;
 873
 874       _ecore_wince_event_last_time = e->time;
 875
 876       ecore_event_add(ECORE_WINCE_EVENT_MOUSE_IN, e, NULL, NULL);
 877    }
 878 }
 879
 880 void
 881 _ecore_wince_event_handle_leave_notify(Ecore_WinCE_Callback_Data *msg)
 882 {
 883    Ecore_WinCE_Window *window;
 884
 885    INF("mouse out");
 886
 887    window = (void *)GetWindowLong(msg->window, GWL_USERDATA);
 888
 889    {
 890       Ecore_Event_Mouse_Move *e;
 891
 892       e = (Ecore_Event_Mouse_Move *)calloc(1, sizeof(Ecore_Event_Mouse_Move));
 893       if (!e) return;
 894
 895       e->window = (Ecore_Window)window;
 896       e->event_window = e->window;
 897       e->x = msg->x;
 898       e->y = msg->y;
 899       e->timestamp = msg->time;
 900
 901       _ecore_wince_event_last_time = e->timestamp;
 902       _ecore_wince_event_last_window = (Ecore_WinCE_Window *)e->window;
 903
 904       ecore_event_add(ECORE_EVENT_MOUSE_MOVE, e, NULL, NULL);
 905    }
 906
 907    {
 908       Ecore_WinCE_Event_Mouse_Out *e;
 909
 910       e = (Ecore_WinCE_Event_Mouse_Out *)calloc(1, sizeof(Ecore_WinCE_Event_Mouse_Out));
 911       if (!e) return;
 912
 913       e->window = window;
 914       e->x = msg->x;
 915       e->y = msg->y;
 916       e->time = msg->time;
 917
 918       _ecore_wince_event_last_time = e->time;
 919
 920       ecore_event_add(ECORE_WINCE_EVENT_MOUSE_OUT, e, NULL, NULL);
 921    }
 922 }
 923
 924 void
 925 _ecore_wince_event_handle_focus_in(Ecore_WinCE_Callback_Data *msg)
 926 {
 927    Ecore_WinCE_Event_Window_Focus_In *e;
 928    Ecore_WinCE_Window                *window;
 929
 930    INF("focus in");
 931
 932    e = (Ecore_WinCE_Event_Window_Focus_In *)calloc(1, sizeof(Ecore_WinCE_Event_Window_Focus_In));
 933    if (!e) return;
 934
 935    window = (void *)GetWindowLong(msg->window, GWL_USERDATA);
 936    if (!e->window)
 937      {
 938         free(e);
 939         return;
 940      }
 941
 942    if (window->resume_cb)
 943      window->resume_cb(window->backend);
 944
 945    e->window = window;
 946
 947    e->time = _ecore_wince_event_last_time;
 948    _ecore_wince_event_last_time = e->time;
 949
 950    ecore_event_add(ECORE_WINCE_EVENT_WINDOW_FOCUS_IN, e, NULL, NULL);
 951 }
 952
 953 void
 954 _ecore_wince_event_handle_focus_out(Ecore_WinCE_Callback_Data *msg)
 955 {
 956    Ecore_WinCE_Event_Window_Focus_Out *e;
 957    Ecore_WinCE_Window                 *window;
 958
 959    INF("focus out");
 960
 961    e = (Ecore_WinCE_Event_Window_Focus_Out *)calloc(1, sizeof(Ecore_WinCE_Event_Window_Focus_Out));
 962    if (!e) return;
 963
 964    window = (void *)GetWindowLong(msg->window, GWL_USERDATA);
 965    if (!e->window)
 966      {
 967         free(e);
 968         return;
 969      }
 970    if (window->suspend_cb)
 971      window->suspend_cb(window->backend);
 972
 973    e->window = window;
 974
 975    e->time = _ecore_wince_event_last_time;
 976    _ecore_wince_event_last_time = e->time;
 977
 978    ecore_event_add(ECORE_WINCE_EVENT_WINDOW_FOCUS_OUT, e, NULL, NULL);
 979 }
 980
 981 void
 982 _ecore_wince_event_handle_expose(Ecore_WinCE_Callback_Data *msg)
 983 {
 984    Ecore_WinCE_Event_Window_Damage *e;
 985
 986    INF("window expose");
 987
 988    e = (Ecore_WinCE_Event_Window_Damage *)calloc(1, sizeof(Ecore_WinCE_Event_Window_Damage));
 989    if (!e) return;
 990
 991    e->window = (void *)GetWindowLong(msg->window, GWL_USERDATA);
 992    if (!e->window)
 993      {
 994         free(e);
 995         return;
 996      }
 997
 998    e->x = msg->update.left;
 999    e->y = msg->update.top;
1000    e->width = msg->update.right - msg->update.left;
1001    e->height = msg->update.bottom - msg->update.top;
1002    INF("window expose size: %dx%d", e->width, e->height);
1003
1004    e->time = _ecore_wince_event_last_time;
1005
1006    ecore_event_add(ECORE_WINCE_EVENT_WINDOW_DAMAGE, e, NULL, NULL);
1007 }
1008
1009 void
1010 _ecore_wince_event_handle_create_notify(Ecore_WinCE_Callback_Data *msg)
1011 {
1012    Ecore_WinCE_Event_Window_Create *e;
1013
1014    INF("window create notify");
1015
1016    e = calloc(1, sizeof(Ecore_WinCE_Event_Window_Create));
1017    if (!e) return;
1018
1019    e->window = (void *)GetWindowLong(msg->window, GWL_USERDATA);
1020    if (!e->window)
1021      {
1022         free(e);
1023         return;
1024      }
1025
1026    e->time = _ecore_wince_event_last_time;
1027
1028    ecore_event_add(ECORE_WINCE_EVENT_WINDOW_CREATE, e, NULL, NULL);
1029 }
1030
1031 void
1032 _ecore_wince_event_handle_destroy_notify(Ecore_WinCE_Callback_Data *msg)
1033 {
1034    Ecore_WinCE_Event_Window_Destroy *e;
1035
1036    INF("window destroy notify");
1037
1038    e = calloc(1, sizeof(Ecore_WinCE_Event_Window_Destroy));
1039    if (!e) return;
1040
1041    e->window = (void *)GetWindowLong(msg->window, GWL_USERDATA);
1042    if (!e->window)
1043      {
1044         free(e);
1045         return;
1046      }
1047
1048    e->time = _ecore_wince_event_last_time;
1049 /*    if (e->window == _ecore_wince_event_last_window) _ecore_wince_event_last_window = NULL; */
1050
1051    ecore_event_add(ECORE_WINCE_EVENT_WINDOW_DESTROY, e, NULL, NULL);
1052 }
1053
1054 void
1055 _ecore_wince_event_handle_map_notify(Ecore_WinCE_Callback_Data *msg)
1056 {
1057    Ecore_WinCE_Event_Window_Show *e;
1058
1059    INF("window map notify");
1060
1061    e = calloc(1, sizeof(Ecore_WinCE_Event_Window_Show));
1062    if (!e) return;
1063
1064    e->window = (void *)GetWindowLong(msg->window, GWL_USERDATA);
1065    if (!e->window)
1066      {
1067         free(e);
1068         return;
1069      }
1070
1071    e->time = _ecore_wince_event_last_time;
1072
1073    ecore_event_add(ECORE_WINCE_EVENT_WINDOW_SHOW, e, NULL, NULL);
1074 }
1075
1076 void
1077 _ecore_wince_event_handle_unmap_notify(Ecore_WinCE_Callback_Data *msg)
1078 {
1079    Ecore_WinCE_Event_Window_Hide *e;
1080
1081    INF("window unmap notify");
1082
1083    e = calloc(1, sizeof(Ecore_WinCE_Event_Window_Hide));
1084    if (!e) return;
1085
1086    e->window = (void *)GetWindowLong(msg->window, GWL_USERDATA);
1087    if (!e->window)
1088      {
1089         free(e);
1090         return;
1091      }
1092
1093    e->time = _ecore_wince_event_last_time;
1094
1095    ecore_event_add(ECORE_WINCE_EVENT_WINDOW_HIDE, e, NULL, NULL);
1096 }
1097
1098 void
1099 _ecore_wince_event_handle_delete_request(Ecore_WinCE_Callback_Data *msg)
1100 {
1101    Ecore_WinCE_Event_Window_Delete_Request *e;
1102
1103    INF("window delete request");
1104
1105    e = calloc(1, sizeof(Ecore_WinCE_Event_Window_Delete_Request));
1106    if (!e) return;
1107
1108    e->window = (void *)GetWindowLong(msg->window, GWL_USERDATA);
1109    if (!e->window)
1110      {
1111         free(e);
1112         return;
1113      }
1114
1115    e->time = _ecore_wince_event_last_time;
1116
1117    ecore_event_add(ECORE_WINCE_EVENT_WINDOW_DELETE_REQUEST, e, NULL, NULL);
1118 }
1119
1120 /*============================================================================*
1121  *                                   API                                      *
1122  *============================================================================*/
1123