ism/src/isf_message_queue.h

   1 /*
   2  * ISF(Input Service Framework)
   3  *
   4  * ISF is based on SCIM 1.4.7 and extended for supporting more mobile fitable.
   5  * Copyright (c) 2012-2016 Samsung Electronics Co., Ltd.
   6  *
   7  * Contact: Ji-hoon Lee <dalton.lee@samsung.com>, Jihoon Kim <jihoon48.kim@samsung.com>
   8  *
   9  * This library is free software; you can redistribute it and/or modify it under
  10  * the terms of the GNU Lesser General Public License as published by the
  11  * Free Software Foundation; either version 2.1 of the License, or (at your option)
  12  * any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful, but WITHOUT ANY
  15  * WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
  17  * License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public License
  20  * along with this library; if not, write to the Free Software Foundation, Inc., 51
  21  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22  *
  23  */
  24
  25 #ifndef __ISF_MESSAGE_QUEUE_H
  26 #define __ISF_MESSAGE_QUEUE_H
  27
  28 #define Uses_SCIM_TRANSACTION
  29 #define Uses_SCIM_TRANS_COMMANDS
  30 #define Uses_SCIM_HELPER
  31 #define Uses_SCIM_SOCKET
  32 #define Uses_SCIM_EVENT
  33 #define Uses_SCIM_BACKEND
  34 #define Uses_SCIM_IMENGINE_MODULE
  35
  36 #include <string.h>
  37 #include <unistd.h>
  38
  39 #include "scim_private.h"
  40 #include "scim.h"
  41 #include <scim_panel_common.h>
  42 #include "isf_query_utility.h"
  43 #include <dlog.h>
  44 #include "isf_debug.h"
  45
  46 #ifdef LOG_TAG
  47 # undef LOG_TAG
  48 #endif
  49 #define LOG_TAG             "ISF_MESSAGE_QUEUE"
  50
  51 namespace scim {
  52
  53 class MessageItem
  54 {
  55 public:
  56     MessageItem() : m_command(0) {}
  57     virtual ~MessageItem() {}
  58
  59     int& get_command_ref() { return m_command; }
  60 protected:
  61     int m_command;
  62 };
  63
  64 class MessageItemHelper : public MessageItem
  65 {
  66 public:
  67     MessageItemHelper() : m_ic(0) {}
  68     virtual ~MessageItemHelper() {}
  69
  70     uint32& get_ic_ref() { return m_ic; }
  71     String& get_ic_uuid_ref() { return m_ic_uuid; }
  72 protected:
  73     uint32 m_ic;
  74     String m_ic_uuid;
  75 };
  76
  77 /* SCIM_TRANS_CMD_EXIT */
  78 class MessageItemExit : public MessageItemHelper
  79 {
  80 };
  81
  82 /* SCIM_TRANS_CMD_RELOAD_CONFIG */
  83 class MessageItemReloadConfig : public MessageItemHelper
  84 {
  85 };
  86
  87 /* SCIM_TRANS_CMD_UPDATE_SCREEN */
  88 class MessageItemUpdateScreen : public MessageItemHelper
  89 {
  90 public:
  91     MessageItemUpdateScreen() : m_screen(0) {}
  92     virtual ~MessageItemUpdateScreen() {}
  93
  94     uint32& get_screen_ref() { return m_screen; }
  95 protected:
  96     uint32 m_screen;
  97 };
  98
  99 /* SCIM_TRANS_CMD_UPDATE_SPOT_LOCATION */
 100 class MessageItemUpdateSpotLocation : public MessageItemHelper
 101 {
 102 public:
 103     MessageItemUpdateSpotLocation() : m_x(0), m_y(0) {}
 104     virtual ~MessageItemUpdateSpotLocation() {}
 105
 106     uint32& get_x_ref() { return m_x; }
 107     uint32& get_y_ref() { return m_y; }
 108
 109 protected:
 110     uint32 m_x;
 111     uint32 m_y;
 112 };
 113
 114 /* ISM_TRANS_CMD_UPDATE_CURSOR_POSITION */
 115 class MessageItemUpdateCursorPosition : public MessageItemHelper
 116 {
 117 public:
 118     MessageItemUpdateCursorPosition() : m_cursor_pos(0) {}
 119     virtual ~MessageItemUpdateCursorPosition() {}
 120
 121     uint32& get_cursor_pos_ref() { return m_cursor_pos; }
 122 protected:
 123     uint32 m_cursor_pos;
 124 };
 125
 126 /* ISM_TRANS_CMD_UPDATE_SURROUNDING_TEXT */
 127 class MessageItemUpdateSurroundingText : public MessageItemHelper
 128 {
 129 public:
 130     MessageItemUpdateSurroundingText() : m_cursor(0) {}
 131     virtual ~MessageItemUpdateSurroundingText() {}
 132
 133     String& get_text_ref() { return m_text; }
 134     uint32& get_cursor_ref() { return m_cursor; }
 135 protected:
 136     String m_text;
 137     uint32 m_cursor;
 138 };
 139
 140 /* ISM_TRANS_CMD_UPDATE_SELECTION */
 141 class MessageItemUpdateSelection : public MessageItemHelper
 142 {
 143 public:
 144     MessageItemUpdateSelection() {}
 145     virtual ~MessageItemUpdateSelection() {}
 146
 147     String& get_text_ref() { return m_text; }
 148 protected:
 149     String m_text;
 150 };
 151
 152 /* SCIM_TRANS_CMD_TRIGGER_PROPERTY */
 153 class MessageItemTriggerProperty : public MessageItemHelper
 154 {
 155 public:
 156     MessageItemTriggerProperty() {}
 157     virtual ~MessageItemTriggerProperty() {}
 158
 159     String& get_property_ref() { return m_property; }
 160 protected:
 161     String m_property;
 162 };
 163
 164 /* SCIM_TRANS_CMD_HELPER_PROCESS_IMENGINE_EVENT */
 165 class MessageItemHelperProcessImengineEvent : public MessageItemHelper
 166 {
 167 public:
 168     MessageItemHelperProcessImengineEvent() {}
 169     virtual ~MessageItemHelperProcessImengineEvent() {}
 170
 171     Transaction& get_transaction_ref() { return m_trans; }
 172 protected:
 173     Transaction m_trans;
 174 };
 175
 176 /* SCIM_TRANS_CMD_HELPER_ATTACH_INPUT_CONTEXT */
 177 class MessageItemHelperAttachInputContext : public MessageItemHelper
 178 {
 179 };
 180
 181 /* SCIM_TRANS_CMD_HELPER_DETACH_INPUT_CONTEXT */
 182 class MessageItemHelperDetachInputContext : public MessageItemHelper
 183 {
 184 };
 185
 186 /* SCIM_TRANS_CMD_FOCUS_OUT */
 187 class MessageItemFocusOut : public MessageItemHelper
 188 {
 189 };
 190
 191 /* SCIM_TRANS_CMD_FOCUS_IN */
 192 class MessageItemFocusIn : public MessageItemHelper
 193 {
 194 };
 195
 196 /* ISM_TRANS_CMD_SHOW_ISE_PANEL */
 197 class MessageItemShowISEPanel : public MessageItemHelper
 198 {
 199 public:
 200     MessageItemShowISEPanel() : m_data(NULL), m_len(0) {}
 201     virtual ~MessageItemShowISEPanel() { if (m_data) delete[] m_data; m_data = NULL; }
 202
 203     char** get_data_ptr() { return &m_data; }
 204     size_t& get_len_ref() { return m_len; }
 205 protected:
 206     char* m_data;
 207     size_t m_len;
 208 };
 209
 210 /* ISM_TRANS_CMD_HIDE_ISE_PANEL */
 211 class MessageItemHideISEPanel : public MessageItemHelper
 212 {
 213 };
 214
 215 // ISM_TRANS_CMD_GET_ACTIVE_ISE_GEOMETRY
 216 class MessageItemGetActiveISEGeometry : public MessageItemHelper
 217 {
 218 };
 219
 220 /* ISM_TRANS_CMD_SET_ISE_MODE */
 221 class MessageItemSetISEMode : public MessageItemHelper
 222 {
 223 public:
 224     MessageItemSetISEMode() : m_mode(0) {}
 225     virtual ~MessageItemSetISEMode() {}
 226
 227     uint32& get_mode_ref() { return m_mode; }
 228 protected:
 229     uint32 m_mode;
 230 };
 231
 232 /* ISM_TRANS_CMD_SET_ISE_LANGUAGE */
 233 class MessageItemSetISELanguage : public MessageItemHelper
 234 {
 235 public:
 236     MessageItemSetISELanguage() : m_language(0) {}
 237     virtual ~MessageItemSetISELanguage() {}
 238
 239     uint32& get_language_ref() { return m_language; }
 240 protected:
 241     uint32 m_language;
 242 };
 243
 244 /* ISM_TRANS_CMD_SET_ISE_IMDATA */
 245 class MessageItemSetISEImData : public MessageItemHelper
 246 {
 247 public:
 248     MessageItemSetISEImData() : m_imdata(NULL), m_len(0) {}
 249     virtual ~MessageItemSetISEImData() { if (m_imdata) delete[] m_imdata; m_imdata = NULL; }
 250
 251     char** get_imdata_ptr() { return &m_imdata; }
 252     size_t& get_len_ref() { return m_len; }
 253 protected:
 254     char* m_imdata;
 255     size_t m_len;
 256 };
 257
 258 /* ISM_TRANS_CMD_GET_ISE_IMDATA */
 259 class MessageItemGetISEImdata : public MessageItemHelper
 260 {
 261 };
 262
 263 /* ISM_TRANS_CMD_GET_ISE_LANGUAGE_LOCALE */
 264 class MessageItemGetISELanguageLocale : public MessageItemHelper
 265 {
 266 };
 267
 268 /* ISM_TRANS_CMD_SET_RETURN_KEY_TYPE */
 269 class MessageItemSetReturnKeyType : public MessageItemHelper
 270 {
 271 public:
 272     MessageItemSetReturnKeyType() : m_type(0) {}
 273     virtual ~MessageItemSetReturnKeyType() {}
 274
 275     uint32& get_type_ref() { return m_type; }
 276 protected:
 277     uint32 m_type;
 278 };
 279
 280 /* ISM_TRANS_CMD_GET_RETURN_KEY_TYPE */
 281 class MessageItemGetReturnKeyType : public MessageItemHelper
 282 {
 283 public:
 284     MessageItemGetReturnKeyType() : m_type(0) {}
 285     virtual ~MessageItemGetReturnKeyType() {}
 286
 287     uint32& get_type_ref() { return m_type; }
 288 protected:
 289     uint32 m_type;
 290 };
 291
 292 /* ISM_TRANS_CMD_SET_RETURN_KEY_DISABLE */
 293 class MessageItemSetReturnKeyDisable : public MessageItemHelper
 294 {
 295 public:
 296     MessageItemSetReturnKeyDisable() : m_disabled(0) {}
 297     virtual ~MessageItemSetReturnKeyDisable() {}
 298
 299     uint32& get_disabled_ref() { return m_disabled; }
 300 protected:
 301     uint32 m_disabled;
 302 };
 303
 304 /* ISM_TRANS_CMD_GET_RETURN_KEY_DISABLE */
 305 class MessageItemGetReturnKeyDisable : public MessageItemHelper
 306 {
 307 public:
 308     MessageItemGetReturnKeyDisable() : m_disabled(0) {}
 309     virtual ~MessageItemGetReturnKeyDisable() {}
 310
 311     uint32& get_disabled_ref() { return m_disabled; }
 312 protected:
 313     uint32 m_disabled;
 314 };
 315
 316 /* SCIM_TRANS_CMD_PROCESS_KEY_EVENT */
 317 class MessageItemProcessKeyEvent : public MessageItemHelper
 318 {
 319 public:
 320     MessageItemProcessKeyEvent() : m_serial(0) {}
 321     virtual ~MessageItemProcessKeyEvent() {}
 322
 323     KeyEvent& get_key_ref() { return m_key; }
 324     uint32& get_serial_ref() { return m_serial; }
 325 protected:
 326     KeyEvent m_key;
 327     uint32 m_serial;
 328 };
 329
 330 /* ISM_TRANS_CMD_SET_LAYOUT */
 331 class MessageItemSetLayout : public MessageItemHelper
 332 {
 333 public:
 334     MessageItemSetLayout() : m_layout(0) {}
 335     virtual ~MessageItemSetLayout() {}
 336
 337     uint32& get_layout_ref() { return m_layout; }
 338 protected:
 339     uint32 m_layout;
 340 };
 341
 342 /* ISM_TRANS_CMD_GET_LAYOUT */
 343 class MessageItemGetLayout : public MessageItemHelper
 344 {
 345 public:
 346     MessageItemGetLayout() : m_layout(0) {}
 347     virtual ~MessageItemGetLayout() {}
 348
 349     uint32& get_layout_ref() { return m_layout; }
 350 protected:
 351     uint32 m_layout;
 352 };
 353
 354 /* ISM_TRANS_CMD_SET_INPUT_MODE */
 355 class MessageItemSetInputMode : public MessageItemHelper
 356 {
 357 public:
 358     MessageItemSetInputMode() : m_input_mode(0) {}
 359     virtual ~MessageItemSetInputMode() {}
 360
 361     uint32& get_input_mode_ref() { return m_input_mode; }
 362 protected:
 363     uint32 m_input_mode;
 364 };
 365
 366 /* ISM_TRANS_CMD_SET_CAPS_MODE */
 367 class MessageItemSetCapsMode : public MessageItemHelper
 368 {
 369 public:
 370     MessageItemSetCapsMode() : m_mode(0) {}
 371     virtual ~MessageItemSetCapsMode() {}
 372
 373     uint32& get_mode_ref() { return m_mode; }
 374 protected:
 375     uint32 m_mode;
 376 };
 377
 378 /* SCIM_TRANS_CMD_PANEL_RESET_INPUT_CONTEXT */
 379 class MessageItemPanelResetInputContext : public MessageItemHelper
 380 {
 381 };
 382
 383 /* ISM_TRANS_CMD_UPDATE_CANDIDATE_UI */
 384 class MessageItemUpdateCandidateUI : public MessageItemHelper
 385 {
 386 public:
 387     MessageItemUpdateCandidateUI() : m_style(0), m_mode(0) {}
 388     virtual ~MessageItemUpdateCandidateUI() {}
 389
 390     uint32& get_style_ref() { return m_style; }
 391     uint32& get_mode_ref() { return m_mode; }
 392 protected:
 393     uint32 m_style;
 394     uint32 m_mode;
 395 };
 396
 397 /* ISM_TRANS_CMD_UPDATE_CANDIDATE_GEOMETRY */
 398 class MessageItemUpdateCandidateGeometry : public MessageItemHelper
 399 {
 400 public:
 401     MessageItemUpdateCandidateGeometry() {}
 402     virtual ~MessageItemUpdateCandidateGeometry() {}
 403
 404     struct rectinfo& get_rectinfo_ref() { return m_info; }
 405 protected:
 406     struct rectinfo m_info;
 407 };
 408
 409 /* ISM_TRANS_CMD_UPDATE_KEYBOARD_ISE */
 410 class MessageItemUpdateKeyboardISE : public MessageItemHelper
 411 {
 412 public:
 413     MessageItemUpdateKeyboardISE() {}
 414     virtual ~MessageItemUpdateKeyboardISE() {}
 415
 416     String& get_name_ref() { return m_name; }
 417     String& get_uuid_ref() { return m_uuid; }
 418 protected:
 419     String m_name;
 420     String m_uuid;
 421 };
 422
 423 /* ISM_TRANS_CMD_UPDATE_KEYBOARD_ISE_LIST */
 424 class MessageItemUpdateKeyboardISEList : public MessageItemHelper
 425 {
 426 public:
 427     MessageItemUpdateKeyboardISEList() {}
 428     virtual ~MessageItemUpdateKeyboardISEList() {}
 429
 430     std::vector<String>& get_list_ref() { return m_list; }
 431 protected:
 432     std::vector<String> m_list;
 433 };
 434
 435 /* ISM_TRANS_CMD_CANDIDATE_MORE_WINDOW_SHOW */
 436 class MessageItemCandidateMoreWindowShow : public MessageItemHelper
 437 {
 438 };
 439
 440 /* ISM_TRANS_CMD_CANDIDATE_MORE_WINDOW_HIDE */
 441 class MessageItemCandidateMoreWindowHide : public MessageItemHelper
 442 {
 443 };
 444
 445 /* ISM_TRANS_CMD_SELECT_AUX */
 446 class MessageItemSelectAux : public MessageItemHelper
 447 {
 448 public:
 449     MessageItemSelectAux() : m_item(0) {}
 450     virtual ~MessageItemSelectAux() {}
 451
 452     uint32& get_item_ref() { return m_item; }
 453 protected:
 454     uint32 m_item;
 455 };
 456
 457 /* SCIM_TRANS_CMD_SELECT_CANDIDATE */
 458 class MessageItemSelectCandidate : public MessageItemHelper
 459 {
 460 public:
 461     MessageItemSelectCandidate() : m_item(0) {}
 462     virtual ~MessageItemSelectCandidate() {}
 463
 464     uint32& get_item_ref() { return m_item; }
 465 protected:
 466     uint32 m_item;
 467 };
 468
 469 /* SCIM_TRANS_CMD_LOOKUP_TABLE_PAGE_UP */
 470 class MessageItemLookupTablePageUp : public MessageItemHelper
 471 {
 472 };
 473
 474 /* SCIM_TRANS_CMD_LOOKUP_TABLE_PAGE_DOWN */
 475 class MessageItemLookupTablePageDown : public MessageItemHelper
 476 {
 477 };
 478
 479 /* SCIM_TRANS_CMD_UPDATE_LOOKUP_TABLE_PAGE_SIZE: */
 480 class MessageItemUpdateLookupTablePageSize : public MessageItemHelper
 481 {
 482 public:
 483     MessageItemUpdateLookupTablePageSize() : m_size(0) {}
 484     virtual ~MessageItemUpdateLookupTablePageSize() {}
 485
 486     uint32& get_size_ref() { return m_size; }
 487 protected:
 488     uint32 m_size;
 489 };
 490
 491 /* ISM_TRANS_CMD_CANDIDATE_SHOW */
 492 class MessageItemCandidateShow : public MessageItemHelper
 493 {
 494 };
 495
 496 /* ISM_TRANS_CMD_CANDIDATE_HIDE */
 497 class MessageItemCandidateHide : public MessageItemHelper
 498 {
 499 };
 500
 501 /* ISM_TRANS_CMD_UPDATE_LOOKUP_TABLE */
 502 class MessageItemUpdateLookupTable : public MessageItemHelper
 503 {
 504 public:
 505     MessageItemUpdateLookupTable() {}
 506     virtual ~MessageItemUpdateLookupTable() {}
 507
 508     CommonLookupTable& get_candidate_table_ref() { return m_helper_candidate_table; }
 509 protected:
 510     CommonLookupTable m_helper_candidate_table;
 511 };
 512
 513 /* ISM_TRANS_CMD_UPDATE_CANDIDATE_ITEM_LAYOUT */
 514 class MessageItemUpdateCandidateItemLayout : public MessageItemHelper
 515 {
 516 public:
 517     MessageItemUpdateCandidateItemLayout() {}
 518     virtual ~MessageItemUpdateCandidateItemLayout() {}
 519
 520     std::vector<uint32>& get_row_items_ref() { return m_row_items; }
 521 protected:
 522     std::vector<uint32> m_row_items;
 523 };
 524
 525 /* ISM_TRANS_CMD_SELECT_ASSOCIATE: */
 526 class MessageItemSelectAssociate : public MessageItemHelper
 527 {
 528 public:
 529     MessageItemSelectAssociate() : m_item(0) {}
 530     virtual ~MessageItemSelectAssociate() {}
 531
 532     uint32& get_item_ref() { return m_item; }
 533 protected:
 534     uint32 m_item;
 535 };
 536
 537 /* ISM_TRANS_CMD_ASSOCIATE_TABLE_PAGE_UP */
 538 class MessageItemAssociateTablePageUp : public MessageItemHelper
 539 {
 540 };
 541
 542 /* ISM_TRANS_CMD_ASSOCIATE_TABLE_PAGE_DOWN */
 543 class MessageItemAssociateTablePageDown : public MessageItemHelper
 544 {
 545 };
 546
 547 /* ISM_TRANS_CMD_UPDATE_ASSOCIATE_TABLE_PAGE_SIZE */
 548 class MessageItemUpdateAssociateTablePageSize : public MessageItemHelper
 549 {
 550 public:
 551     MessageItemUpdateAssociateTablePageSize() : m_size(0) {}
 552     virtual ~MessageItemUpdateAssociateTablePageSize() {}
 553
 554     uint32& get_size_ref() { return m_size; }
 555 protected:
 556     uint32 m_size;
 557 };
 558
 559 /* ISM_TRANS_CMD_RESET_ISE_CONTEXT */
 560 class MessageItemResetISEContext : public MessageItemHelper
 561 {
 562 };
 563
 564 /* ISM_TRANS_CMD_TURN_ON_LOG */
 565 class MessageItemTurnOnLog : public MessageItemHelper
 566 {
 567 public:
 568     MessageItemTurnOnLog() : m_state(0) {}
 569     virtual ~MessageItemTurnOnLog() {}
 570
 571     uint32& get_state_ref() { return m_state; }
 572 protected:
 573     uint32 m_state;
 574 };
 575
 576 /* ISM_TRANS_CMD_UPDATE_DISPLAYED_CANDIDATE */
 577 class MessageItemUpdateDisplayedCandidate : public MessageItemHelper
 578 {
 579 public:
 580     MessageItemUpdateDisplayedCandidate() : m_size(0) {}
 581     virtual ~MessageItemUpdateDisplayedCandidate() {}
 582
 583     uint32& get_size_ref() { return m_size; }
 584 protected:
 585     uint32 m_size;
 586 };
 587
 588 /* ISM_TRANS_CMD_LONGPRESS_CANDIDATE */
 589 class MessageItemLongpressCandidate : public MessageItemHelper
 590 {
 591 public:
 592     MessageItemLongpressCandidate() : m_index(0) {}
 593     virtual ~MessageItemLongpressCandidate() {}
 594
 595     uint32& get_index_ref() { return m_index; }
 596 protected:
 597     uint32 m_index;
 598 };
 599
 600 /* ISM_TRANS_CMD_SET_INPUT_HINT */
 601 class MessageItemSetInputHint : public MessageItemHelper
 602 {
 603 public:
 604     MessageItemSetInputHint() : m_input_hint(0) {}
 605     virtual ~MessageItemSetInputHint() {}
 606
 607     uint32& get_input_hint_ref() { return m_input_hint; }
 608 protected:
 609     uint32 m_input_hint;
 610 };
 611
 612 /* ISM_TRANS_CMD_UPDATE_BIDI_DIRECTION */
 613 class MessageItemUpdateBidiDirection : public MessageItemHelper
 614 {
 615 public:
 616     MessageItemUpdateBidiDirection() : m_bidi_direction(0) {}
 617     virtual ~MessageItemUpdateBidiDirection() {}
 618
 619     uint32& get_bidi_direction() { return m_bidi_direction; }
 620 protected:
 621     uint32 m_bidi_direction;
 622 };
 623
 624 /* ISM_TRANS_CMD_SHOW_ISE_OPTION_WINDOW */
 625 class MessageItemShowISEOptionWindow : public MessageItemHelper
 626 {
 627 };
 628
 629 /* ISM_TRANS_CMD_RESUME_ISE_OPTION_WINDOW */
 630 class MessageItemResumeISEOptionWindow : public MessageItemHelper
 631 {
 632 };
 633
 634 /* ISM_TRANS_CMD_CHECK_OPTION_WINDOW */
 635 class MessageItemCheckOptionWindow : public MessageItemHelper
 636 {
 637 public:
 638     MessageItemCheckOptionWindow() : m_avail(0) {}
 639     virtual ~MessageItemCheckOptionWindow() {}
 640
 641     uint32& get_avail_ref() { return m_avail; }
 642 protected:
 643     uint32 m_avail;
 644 };
 645
 646 /* ISM_TRANS_CMD_PROCESS_INPUT_DEVICE_EVENT */
 647 class MessageItemProcessInputDeviceEvent : public MessageItemHelper
 648 {
 649 public:
 650     MessageItemProcessInputDeviceEvent() : m_type(0), m_data(NULL), m_len(0) {}
 651     virtual ~MessageItemProcessInputDeviceEvent() {}
 652
 653     uint32& get_type_ref() { return m_type; }
 654     char** get_data_ptr() { return &m_data; }
 655     size_t& get_len_ref() { return m_len; }
 656 protected:
 657     uint32 m_type;
 658     char* m_data;
 659     size_t m_len;
 660 };
 661
 662 /* SCIM_TRANS_CMD_SET_AUTOCAPITAL_TYPE */
 663 class MessageItemSetAutocapitalType : public MessageItemHelper
 664 {
 665 public:
 666     MessageItemSetAutocapitalType() : m_auto_capital_type(0) {}
 667     virtual ~MessageItemSetAutocapitalType() {}
 668
 669     uint32& get_auto_capital_type_ref() { return m_auto_capital_type; }
 670 protected:
 671     uint32 m_auto_capital_type;
 672 };
 673
 674 /* ISM_TRANS_CMD_SET_PREDICTION_ALLOW */
 675 class MessageItemSetPredictionAllow : public MessageItemHelper
 676 {
 677 public:
 678     MessageItemSetPredictionAllow() : m_prediction_allow(1) {}
 679     virtual ~MessageItemSetPredictionAllow() {}
 680
 681     uint32& get_prediction_allow_ref() { return m_prediction_allow; }
 682 protected:
 683     uint32 m_prediction_allow;
 684 };
 685
 686 template <typename T>
 687 inline T*
 688 alloc_message() /* We could use memory pool in the future for performance enhancement */
 689 {
 690     return new T;
 691 }
 692
 693 template <typename T>
 694 inline void
 695 dealloc_message(T* ptr) /* We could use memory pool in the future for performance enhancement */
 696 {
 697     if (ptr) delete ptr;
 698 }
 699
 700 class MessageQueue
 701 {
 702 public:
 703     MessageQueue() {}
 704     virtual ~MessageQueue() { destroy(); }
 705
 706     void create()
 707     {
 708     }
 709     void destroy()
 710     {
 711         for (MESSAGE_LIST::iterator iter = m_list_messages.begin();
 712             iter != m_list_messages.end(); advance(iter, 1)) {
 713             /* Here we are using MessageItem type template deallocator, should be cautious when using memory pool */
 714             dealloc_message<MessageItem>(*iter);
 715         }
 716         m_list_messages.clear();
 717     }
 718
 719     bool has_pending_message() {
 720         return (m_list_messages.size() > 0);
 721     }
 722
 723     MessageItem* get_pending_message()
 724     {
 725         MessageItem* ret = NULL;
 726         if (!m_list_messages.empty()) {
 727             ret = m_list_messages.front();
 728         }
 729         return ret;
 730     }
 731
 732     MessageItem* get_pending_message_by_cmd(int cmd)
 733     {
 734         MessageItem* ret = NULL;
 735         for (MESSAGE_LIST::iterator iter = m_list_messages.begin();
 736             !ret && iter != m_list_messages.end(); advance(iter, 1)) {
 737             if ((*iter)->get_command_ref() == cmd) {
 738                 ret = (*iter);
 739             }
 740         }
 741         return ret;
 742     }
 743
 744     void remove_message(MessageItem *message)
 745     {
 746         if (message) {
 747             for (MESSAGE_LIST::iterator iter = m_list_messages.begin();
 748                 iter != m_list_messages.end(); advance(iter, 1)) {
 749                 if ((*iter) == message) {
 750                     iter = m_list_messages.erase(iter);
 751                 }
 752             }
 753             /* Here we are using MessageItem type template deallocator, should be cautious when using memory pool */
 754             dealloc_message<MessageItem>(message);
 755         }
 756         return;
 757     }
 758
 759     bool read_from_transaction(scim::Transaction &transaction)
 760     {
 761         int cmd;
 762
 763         uint32 ic = (uint32)-1;
 764         String ic_uuid;
 765
 766         if (!transaction.get_command(cmd) || cmd != SCIM_TRANS_CMD_REPLY) {
 767             LOGW("wrong format of transaction\n");
 768             return true;
 769         }
 770
 771         /* If there are ic and ic_uuid then read them. */
 772         if (!(transaction.get_data_type() == SCIM_TRANS_DATA_COMMAND) &&
 773             !(transaction.get_data(ic) && transaction.get_data(ic_uuid))) {
 774             LOGW("wrong format of transaction\n");
 775             return true;
 776         }
 777
 778         while (transaction.get_command(cmd)) {
 779             switch (cmd) {
 780                 case SCIM_TRANS_CMD_EXIT:
 781                 {
 782                     MessageItemExit *message = alloc_message<MessageItemExit>();
 783                     if (message) {
 784                         message->get_command_ref() = cmd;
 785                         message->get_ic_ref() = ic;
 786                         message->get_ic_uuid_ref() = ic_uuid;
 787                         m_list_messages.push_back(message);
 788                     }
 789                     break;
 790                 }
 791                 case SCIM_TRANS_CMD_RELOAD_CONFIG:
 792                 {
 793                     MessageItemReloadConfig *message = alloc_message<MessageItemReloadConfig>();
 794                     if (message) {
 795                         message->get_command_ref() = cmd;
 796                         message->get_ic_ref() = ic;
 797                         message->get_ic_uuid_ref() = ic_uuid;
 798                         m_list_messages.push_back(message);
 799                     }
 800                     break;
 801                 }
 802                 case SCIM_TRANS_CMD_UPDATE_SCREEN:
 803                 {
 804                     MessageItemUpdateScreen *message = alloc_message<MessageItemUpdateScreen>();
 805                     if (message) {
 806                         message->get_command_ref() = cmd;
 807                         if (transaction.get_data(message->get_screen_ref())) {
 808                             message->get_ic_ref() = ic;
 809                             message->get_ic_uuid_ref() = ic_uuid;
 810                             m_list_messages.push_back(message);
 811                         } else {
 812                             LOGW("wrong format of transaction\n");
 813                             dealloc_message<MessageItemUpdateScreen>(message);
 814                         }
 815                     }
 816                     break;
 817                 }
 818                 case SCIM_TRANS_CMD_UPDATE_SPOT_LOCATION:
 819                 {
 820                     MessageItemUpdateSpotLocation *message = alloc_message<MessageItemUpdateSpotLocation>();
 821                     if (message) {
 822                         message->get_command_ref() = cmd;
 823                         if (transaction.get_data(message->get_x_ref()) && transaction.get_data(message->get_y_ref())) {
 824                             message->get_ic_ref() = ic;
 825                             message->get_ic_uuid_ref() = ic_uuid;
 826                             m_list_messages.push_back(message);
 827                         } else {
 828                             LOGW("wrong format of transaction\n");
 829                             dealloc_message<MessageItemUpdateSpotLocation>(message);
 830                         }
 831                     }
 832                     break;
 833                 }
 834                 case ISM_TRANS_CMD_UPDATE_CURSOR_POSITION:
 835                 {
 836                     MessageItemUpdateCursorPosition *message = alloc_message<MessageItemUpdateCursorPosition>();
 837                     if (message) {
 838                         message->get_command_ref() = cmd;
 839                         if (transaction.get_data(message->get_cursor_pos_ref())) {
 840                             message->get_ic_ref() = ic;
 841                             message->get_ic_uuid_ref() = ic_uuid;
 842                             m_list_messages.push_back(message);
 843                         } else {
 844                             LOGW("wrong format of transaction\n");
 845                             dealloc_message<MessageItemUpdateCursorPosition>(message);
 846                         }
 847                     }
 848                     break;
 849                 }
 850                 case ISM_TRANS_CMD_UPDATE_SURROUNDING_TEXT:
 851                 {
 852                     MessageItemUpdateSurroundingText *message = alloc_message<MessageItemUpdateSurroundingText>();
 853                     if (message) {
 854                         message->get_command_ref() = cmd;
 855                         if (transaction.get_data(message->get_text_ref()) &&
 856                             transaction.get_data(message->get_cursor_ref())) {
 857                             message->get_ic_ref() = ic;
 858                             m_list_messages.push_back(message);
 859                         } else {
 860                             LOGW("wrong format of transaction\n");
 861                             dealloc_message<MessageItemUpdateSurroundingText>(message);
 862                         }
 863                     }
 864                     break;
 865                 }
 866                 case ISM_TRANS_CMD_UPDATE_SELECTION:
 867                 {
 868                     MessageItemUpdateSelection *message = alloc_message<MessageItemUpdateSelection>();
 869                     if (message) {
 870                         message->get_command_ref() = cmd;
 871                         if (transaction.get_data(message->get_text_ref())) {
 872                             message->get_ic_ref() = ic;
 873                             m_list_messages.push_back(message);
 874                         } else {
 875                             LOGW("wrong format of transaction\n");
 876                             dealloc_message<MessageItemUpdateSelection>(message);
 877                         }
 878                     }
 879                     break;
 880                 }
 881                 case SCIM_TRANS_CMD_TRIGGER_PROPERTY:
 882                 {
 883                     MessageItemTriggerProperty *message = alloc_message<MessageItemTriggerProperty>();
 884                     if (message) {
 885                         message->get_command_ref() = cmd;
 886                         if (transaction.get_data(message->get_property_ref())) {
 887                             m_list_messages.push_back(message);
 888                         } else {
 889                             LOGW("wrong format of transaction\n");
 890                             dealloc_message<MessageItemTriggerProperty>(message);
 891                         }
 892                     }
 893                     break;
 894                 }
 895                 case SCIM_TRANS_CMD_HELPER_PROCESS_IMENGINE_EVENT:
 896                 {
 897                     MessageItemHelperProcessImengineEvent *message = alloc_message<MessageItemHelperProcessImengineEvent>();
 898                     if (message) {
 899                         message->get_command_ref() = cmd;
 900                         if (transaction.get_data(message->get_transaction_ref())) {
 901                             message->get_ic_ref() = ic;
 902                             message->get_ic_uuid_ref() = ic_uuid;
 903                             m_list_messages.push_back(message);
 904                         } else {
 905                             LOGW("wrong format of transaction\n");
 906                             dealloc_message<MessageItemHelperProcessImengineEvent>(message);
 907                         }
 908                     }
 909                     break;
 910                 }
 911                 case SCIM_TRANS_CMD_HELPER_ATTACH_INPUT_CONTEXT:
 912                 {
 913                     MessageItemHelperAttachInputContext *message = alloc_message<MessageItemHelperAttachInputContext>();
 914                     if (message) {
 915                         message->get_command_ref() = cmd;
 916                         message->get_ic_ref() = ic;
 917                         message->get_ic_uuid_ref() = ic_uuid;
 918                         m_list_messages.push_back(message);
 919                     }
 920                     break;
 921                 }
 922                 case SCIM_TRANS_CMD_HELPER_DETACH_INPUT_CONTEXT:
 923                 {
 924                     MessageItemHelperDetachInputContext *message = alloc_message<MessageItemHelperDetachInputContext>();
 925                     if (message) {
 926                         message->get_command_ref() = cmd;
 927                         message->get_ic_ref() = ic;
 928                         message->get_ic_uuid_ref() = ic_uuid;
 929                         m_list_messages.push_back(message);
 930                     }
 931                     break;
 932                 }
 933                 case SCIM_TRANS_CMD_FOCUS_OUT:
 934                 {
 935                     MessageItemFocusOut *message = alloc_message<MessageItemFocusOut>();
 936                     if (message) {
 937                         message->get_command_ref() = cmd;
 938                         message->get_ic_ref() = ic;
 939                         message->get_ic_uuid_ref() = ic_uuid;
 940                         m_list_messages.push_back(message);
 941                     }
 942                     break;
 943                 }
 944                 case SCIM_TRANS_CMD_FOCUS_IN:
 945                 {
 946                     MessageItemFocusIn *message = alloc_message<MessageItemFocusIn>();
 947                     if (message) {
 948                         message->get_command_ref() = cmd;
 949                         message->get_ic_ref() = ic;
 950                         message->get_ic_uuid_ref() = ic_uuid;
 951                         m_list_messages.push_back(message);
 952                     }
 953                     break;
 954                 }
 955                 case ISM_TRANS_CMD_SHOW_ISE_PANEL:
 956                 {
 957                     MessageItemShowISEPanel *message = alloc_message<MessageItemShowISEPanel>();
 958                     if (message) {
 959                         message->get_command_ref() = cmd;
 960                         if (transaction.get_data(message->get_data_ptr(), message->get_len_ref())) {
 961                             message->get_ic_ref() = ic;
 962                             m_list_messages.push_back(message);
 963                         } else {
 964                             LOGW("wrong format of transaction\n");
 965                             dealloc_message<MessageItemShowISEPanel>(message);
 966                         }
 967                     }
 968                     break;
 969                 }
 970                 case ISM_TRANS_CMD_HIDE_ISE_PANEL:
 971                 {
 972                     MessageItemHideISEPanel *message = alloc_message<MessageItemHideISEPanel>();
 973                     if (message) {
 974                         message->get_command_ref() = cmd;
 975                         message->get_ic_ref() = ic;
 976                         message->get_ic_uuid_ref() = ic_uuid;
 977                         m_list_messages.push_back(message);
 978                     }
 979                     break;
 980                 }
 981                 case ISM_TRANS_CMD_GET_ACTIVE_ISE_GEOMETRY:
 982                 {
 983                     MessageItemGetActiveISEGeometry *message = alloc_message<MessageItemGetActiveISEGeometry>();
 984                     if (message) {
 985                         message->get_command_ref() = cmd;
 986                         m_list_messages.push_back(message);
 987                     }
 988                     break;
 989                 }
 990                 case ISM_TRANS_CMD_SET_ISE_MODE:
 991                 {
 992                     MessageItemSetISEMode *message = alloc_message<MessageItemSetISEMode>();
 993                     if (message) {
 994                         message->get_command_ref() = cmd;
 995                         if (transaction.get_data(message->get_mode_ref())) {
 996                             m_list_messages.push_back(message);
 997                         } else {
 998                             LOGW("wrong format of transaction\n");
 999                             dealloc_message<MessageItemSetISEMode>(message);
1000                         }
1001                     }
1002                     break;
1003                 }
1004                 case ISM_TRANS_CMD_SET_ISE_LANGUAGE:
1005                 {
1006                     MessageItemSetISELanguage *message = alloc_message<MessageItemSetISELanguage>();
1007                     if (message) {
1008                         message->get_command_ref() = cmd;
1009                         if (transaction.get_data(message->get_language_ref())) {
1010                             m_list_messages.push_back(message);
1011                         } else {
1012                             LOGW("wrong format of transaction\n");
1013                             dealloc_message<MessageItemSetISELanguage>(message);
1014                         }
1015                     }
1016                     break;
1017                 }
1018                 case ISM_TRANS_CMD_SET_ISE_IMDATA:
1019                 {
1020                     MessageItemSetISEImData *message = alloc_message<MessageItemSetISEImData>();
1021                     if (message) {
1022                         message->get_command_ref() = cmd;
1023                         if (transaction.get_data(message->get_imdata_ptr(), message->get_len_ref())) {
1024                             m_list_messages.push_back(message);
1025                         } else {
1026                             LOGW("wrong format of transaction\n");
1027                             dealloc_message<MessageItemSetISEImData>(message);
1028                         }
1029                     }
1030                     break;
1031                 }
1032                 case ISM_TRANS_CMD_GET_ISE_IMDATA:
1033                 {
1034                     MessageItemGetISEImdata *message = alloc_message<MessageItemGetISEImdata>();
1035                     if (message) {
1036                         message->get_command_ref() = cmd;
1037                         m_list_messages.push_back(message);
1038                     }
1039                     break;
1040                 }
1041                 case ISM_TRANS_CMD_GET_ISE_LANGUAGE_LOCALE:
1042                 {
1043                     MessageItemGetISELanguageLocale *message = alloc_message<MessageItemGetISELanguageLocale>();
1044                     if (message) {
1045                         message->get_command_ref() = cmd;
1046                         m_list_messages.push_back(message);
1047                     }
1048                     break;
1049                 }
1050                 case ISM_TRANS_CMD_SET_RETURN_KEY_TYPE:
1051                 {
1052                     MessageItemSetReturnKeyType *message = alloc_message<MessageItemSetReturnKeyType>();
1053                     if (message) {
1054                         message->get_command_ref() = cmd;
1055                         if (transaction.get_data(message->get_type_ref())) {
1056                             m_list_messages.push_back(message);
1057                         }
1058                     }
1059                     break;
1060                 }
1061                 case ISM_TRANS_CMD_GET_RETURN_KEY_TYPE:
1062                 {
1063                     MessageItemGetReturnKeyType *message = alloc_message<MessageItemGetReturnKeyType>();
1064                     if (message) {
1065                         message->get_command_ref() = cmd;
1066                         m_list_messages.push_back(message);
1067                     }
1068                     break;
1069                 }
1070                 case ISM_TRANS_CMD_SET_RETURN_KEY_DISABLE:
1071                 {
1072                     MessageItemSetReturnKeyDisable *message = alloc_message<MessageItemSetReturnKeyDisable>();
1073                     if (message) {
1074                         message->get_command_ref() = cmd;
1075                         if (transaction.get_data(message->get_disabled_ref())) {
1076                             m_list_messages.push_back(message);
1077                         } else {
1078                             LOGW("wrong format of transaction\n");
1079                             dealloc_message<MessageItemSetReturnKeyDisable>(message);
1080                         }
1081                     }
1082                     break;
1083                 }
1084                 case ISM_TRANS_CMD_GET_RETURN_KEY_DISABLE:
1085                 {
1086                     MessageItemGetReturnKeyDisable *message = alloc_message<MessageItemGetReturnKeyDisable>();
1087                     if (message) {
1088                         message->get_command_ref() = cmd;
1089                         m_list_messages.push_back(message);
1090                     }
1091                     break;
1092                 }
1093                 case SCIM_TRANS_CMD_PROCESS_KEY_EVENT:
1094                 {
1095                     MessageItemProcessKeyEvent *message = alloc_message<MessageItemProcessKeyEvent>();
1096                     if (message) {
1097                         message->get_command_ref() = cmd;
1098                         if (transaction.get_data(message->get_key_ref()) &&
1099                             transaction.get_data(message->get_serial_ref())) {
1100                             m_list_messages.push_back(message);
1101                         } else {
1102                             LOGW("wrong format of transaction\n");
1103                             dealloc_message<MessageItemProcessKeyEvent>(message);
1104                         }
1105                     }
1106                     break;
1107                 }
1108                 case ISM_TRANS_CMD_SET_LAYOUT:
1109                 {
1110                     MessageItemSetLayout *message = alloc_message<MessageItemSetLayout>();
1111                     if (message) {
1112                         message->get_command_ref() = cmd;
1113                         if (transaction.get_data(message->get_layout_ref())) {
1114                             m_list_messages.push_back(message);
1115                         } else {
1116                             LOGW("wrong format of transaction\n");
1117                             dealloc_message<MessageItemSetLayout>(message);
1118                         }
1119                     }
1120                     break;
1121                 }
1122                 case ISM_TRANS_CMD_GET_LAYOUT:
1123                 {
1124                     MessageItemGetLayout *message = alloc_message<MessageItemGetLayout>();
1125                     if (message) {
1126                         message->get_command_ref() = cmd;
1127                         m_list_messages.push_back(message);
1128                     }
1129                     break;
1130                 }
1131                 case ISM_TRANS_CMD_SET_INPUT_MODE:
1132                 {
1133                     MessageItemSetInputMode *message = alloc_message<MessageItemSetInputMode>();
1134                     if (message) {
1135                         message->get_command_ref() = cmd;
1136                         if (transaction.get_data(message->get_input_mode_ref())) {
1137                             m_list_messages.push_back(message);
1138                         } else {
1139                             LOGW("wrong format of transaction\n");
1140                             dealloc_message<MessageItemSetInputMode>(message);
1141                         }
1142                     }
1143                     break;
1144                 }
1145                 case ISM_TRANS_CMD_SET_CAPS_MODE:
1146                 {
1147                     MessageItemSetCapsMode *message = alloc_message<MessageItemSetCapsMode>();
1148                     if (message) {
1149                         message->get_command_ref() = cmd;
1150                         if (transaction.get_data(message->get_mode_ref())) {
1151                             m_list_messages.push_back(message);
1152                         } else {
1153                             LOGW("wrong format of transaction\n");
1154                             dealloc_message<MessageItemSetCapsMode>(message);
1155                         }
1156                     }
1157                     break;
1158                 }
1159                 case SCIM_TRANS_CMD_PANEL_RESET_INPUT_CONTEXT:
1160                 {
1161                     MessageItemPanelResetInputContext *message = alloc_message<MessageItemPanelResetInputContext>();
1162                     if (message) {
1163                         message->get_command_ref() = cmd;
1164                         message->get_ic_ref() = ic;
1165                         message->get_ic_uuid_ref() = ic_uuid;
1166                         m_list_messages.push_back(message);
1167                     }
1168                     break;
1169                 }
1170                 case ISM_TRANS_CMD_UPDATE_CANDIDATE_UI:
1171                 {
1172                     MessageItemUpdateCandidateUI *message = alloc_message<MessageItemUpdateCandidateUI>();
1173                     if (message) {
1174                         message->get_command_ref() = cmd;
1175                         if (transaction.get_data(message->get_style_ref()) &&
1176                             transaction.get_data(message->get_mode_ref())) {
1177                             message->get_ic_ref() = ic;
1178                             message->get_ic_uuid_ref() = ic_uuid;
1179                             m_list_messages.push_back(message);
1180                         } else {
1181                             LOGW("wrong format of transaction\n");
1182                             dealloc_message<MessageItemUpdateCandidateUI>(message);
1183                         }
1184                     }
1185                     break;
1186                 }
1187                 case ISM_TRANS_CMD_UPDATE_CANDIDATE_GEOMETRY:
1188                 {
1189                     MessageItemUpdateCandidateGeometry *message = alloc_message<MessageItemUpdateCandidateGeometry>();
1190                     if (message) {
1191                         message->get_command_ref() = cmd;
1192                         if (transaction.get_data(message->get_rectinfo_ref().pos_x)
1193                             && transaction.get_data(message->get_rectinfo_ref().pos_y)
1194                             && transaction.get_data(message->get_rectinfo_ref().width)
1195                             && transaction.get_data(message->get_rectinfo_ref().height)) {
1196                             message->get_ic_ref() = ic;
1197                             message->get_ic_uuid_ref() = ic_uuid;
1198                             m_list_messages.push_back(message);
1199                         } else {
1200                             LOGW("wrong format of transaction\n");
1201                             dealloc_message<MessageItemUpdateCandidateGeometry>(message);
1202                         }
1203                     }
1204                     break;
1205                 }
1206                 case ISM_TRANS_CMD_UPDATE_KEYBOARD_ISE:
1207                 {
1208                     MessageItemUpdateKeyboardISE *message = alloc_message<MessageItemUpdateKeyboardISE>();
1209                     if (message) {
1210                         message->get_command_ref() = cmd;
1211                         String name, uuid;
1212                         if (transaction.get_data(message->get_name_ref()) &&
1213                             transaction.get_data(message->get_uuid_ref())) {
1214                             message->get_ic_ref() = ic;
1215                             message->get_ic_uuid_ref() = ic_uuid;
1216                             m_list_messages.push_back(message);
1217                         } else {
1218                             LOGW("wrong format of transaction\n");
1219                             dealloc_message<MessageItemUpdateKeyboardISE>(message);
1220                         }
1221                     }
1222                     break;
1223                 }
1224                 case ISM_TRANS_CMD_UPDATE_KEYBOARD_ISE_LIST:
1225                 {
1226                     MessageItemUpdateKeyboardISEList *message = alloc_message<MessageItemUpdateKeyboardISEList>();
1227                     if (message) {
1228                         message->get_command_ref() = cmd;
1229                         uint32 num;
1230                         String ise;
1231                         if (transaction.get_data(num)) {
1232                             for (unsigned int i = 0; i < num; i++) {
1233                                 if (transaction.get_data(ise)) {
1234                                     message->get_list_ref().push_back (ise);
1235                                 } else {
1236                                     message->get_list_ref().clear ();
1237                                     break;
1238                                 }
1239                             }
1240                             message->get_ic_ref() = ic;
1241                             message->get_ic_uuid_ref() = ic_uuid;
1242                             m_list_messages.push_back(message);
1243                         } else {
1244                             LOGW("wrong format of transaction\n");
1245                             dealloc_message<MessageItemUpdateKeyboardISEList>(message);
1246                         }
1247                     }
1248                     break;
1249                 }
1250                 case ISM_TRANS_CMD_CANDIDATE_MORE_WINDOW_SHOW:
1251                 {
1252                     MessageItemCandidateMoreWindowShow *message = alloc_message<MessageItemCandidateMoreWindowShow>();
1253                     if (message) {
1254                         message->get_command_ref() = cmd;
1255                         message->get_ic_ref() = ic;
1256                         message->get_ic_uuid_ref() = ic_uuid;
1257                         m_list_messages.push_back(message);
1258                     }
1259                     break;
1260                 }
1261                 case ISM_TRANS_CMD_CANDIDATE_MORE_WINDOW_HIDE:
1262                 {
1263                     MessageItemCandidateMoreWindowHide *message = alloc_message<MessageItemCandidateMoreWindowHide>();
1264                     if (message) {
1265                         message->get_command_ref() = cmd;
1266                         message->get_ic_ref() = ic;
1267                         message->get_ic_uuid_ref() = ic_uuid;
1268                         m_list_messages.push_back(message);
1269                     }
1270                     break;
1271                 }
1272                 case ISM_TRANS_CMD_SELECT_AUX:
1273                 {
1274                     MessageItemSelectAux *message = alloc_message<MessageItemSelectAux>();
1275                     if (message) {
1276                         message->get_command_ref() = cmd;
1277                         if (transaction.get_data(message->get_item_ref())) {
1278                             message->get_ic_ref() = ic;
1279                             message->get_ic_uuid_ref() = ic_uuid;
1280                             m_list_messages.push_back(message);
1281                         } else {
1282                             LOGW("wrong format of transaction\n");
1283                             dealloc_message<MessageItemSelectAux>(message);
1284                         }
1285                     }
1286                     break;
1287                 }
1288                 case SCIM_TRANS_CMD_SELECT_CANDIDATE: //FIXME:remove if useless
1289                 {
1290                     MessageItemSelectCandidate *message = alloc_message<MessageItemSelectCandidate>();
1291                     if (message) {
1292                         message->get_command_ref() = cmd;
1293                         if (transaction.get_data(message->get_item_ref())) {
1294                             message->get_ic_ref() = ic;
1295                             message->get_ic_uuid_ref() = ic_uuid;
1296                             m_list_messages.push_back(message);
1297                         } else {
1298                             LOGW("wrong format of transaction\n");
1299                             dealloc_message<MessageItemSelectCandidate>(message);
1300                         }
1301                     }
1302                     break;
1303                 }
1304                 case SCIM_TRANS_CMD_LOOKUP_TABLE_PAGE_UP: //FIXME:remove if useless
1305                 {
1306                     MessageItemLookupTablePageUp *message = alloc_message<MessageItemLookupTablePageUp>();
1307                     if (message) {
1308                         message->get_command_ref() = cmd;
1309                         message->get_ic_ref() = ic;
1310                         message->get_ic_uuid_ref() = ic_uuid;
1311                         m_list_messages.push_back(message);
1312                     }
1313                     break;
1314                 }
1315                 case SCIM_TRANS_CMD_LOOKUP_TABLE_PAGE_DOWN: //FIXME:remove if useless
1316                 {
1317                     MessageItemLookupTablePageDown *message = alloc_message<MessageItemLookupTablePageDown>();
1318                     if (message) {
1319                         message->get_command_ref() = cmd;
1320                         message->get_ic_ref() = ic;
1321                         message->get_ic_uuid_ref() = ic_uuid;
1322                         m_list_messages.push_back(message);
1323                     }
1324                     break;
1325                 }
1326                 case SCIM_TRANS_CMD_UPDATE_LOOKUP_TABLE_PAGE_SIZE:
1327                 {
1328                     MessageItemUpdateLookupTablePageSize *message = alloc_message<MessageItemUpdateLookupTablePageSize>();
1329                     if (message) {
1330                         message->get_command_ref() = cmd;
1331                         if (transaction.get_data(message->get_size_ref())) {
1332                             message->get_ic_ref() = ic;
1333                             message->get_ic_uuid_ref() = ic_uuid;
1334                             m_list_messages.push_back(message);
1335                         } else {
1336                             LOGW("wrong format of transaction\n");
1337                             dealloc_message<MessageItemUpdateLookupTablePageSize>(message);
1338                         }
1339                     }
1340                     break;
1341                 }
1342                 case ISM_TRANS_CMD_CANDIDATE_SHOW: //FIXME:remove if useless
1343                 {
1344                     MessageItemCandidateShow *message = alloc_message<MessageItemCandidateShow>();
1345                     if (message) {
1346                         message->get_command_ref() = cmd;
1347                         message->get_ic_ref() = ic;
1348                         message->get_ic_uuid_ref() = ic_uuid;
1349                         m_list_messages.push_back(message);
1350                     }
1351                     break;
1352                 }
1353                 case ISM_TRANS_CMD_CANDIDATE_HIDE: //FIXME:remove if useless
1354                 {
1355                     MessageItemCandidateHide *message = alloc_message<MessageItemCandidateHide>();
1356                     if (message) {
1357                         message->get_command_ref() = cmd;
1358                         message->get_ic_ref() = ic;
1359                         message->get_ic_uuid_ref() = ic_uuid;
1360                         m_list_messages.push_back(message);
1361                     }
1362                     break;
1363                 }
1364                 case ISM_TRANS_CMD_UPDATE_LOOKUP_TABLE: //FIXME:remove if useless
1365                 {
1366                     MessageItemUpdateLookupTable *message = alloc_message<MessageItemUpdateLookupTable>();
1367                     if (message) {
1368                         message->get_command_ref() = cmd;
1369                         if (transaction.get_data(message->get_candidate_table_ref())) {
1370                             m_list_messages.push_back(message);
1371                         } else {
1372                             LOGW("wrong format of transaction\n");
1373                             dealloc_message<MessageItemUpdateLookupTable>(message);
1374                         }
1375                     }
1376                     break;
1377                 }
1378                 case ISM_TRANS_CMD_UPDATE_CANDIDATE_ITEM_LAYOUT:
1379                 {
1380                     MessageItemUpdateCandidateItemLayout *message = alloc_message<MessageItemUpdateCandidateItemLayout>();
1381                     if (transaction.get_data(message->get_row_items_ref())) {
1382                         m_list_messages.push_back(message);
1383                     } else {
1384                             LOGW("wrong format of transaction\n");
1385                             dealloc_message<MessageItemUpdateCandidateItemLayout>(message);
1386                     }
1387                     break;
1388                 }
1389                 case ISM_TRANS_CMD_SELECT_ASSOCIATE:
1390                 {
1391                     MessageItemSelectAssociate *message = alloc_message<MessageItemSelectAssociate>();
1392                     if (transaction.get_data(message->get_item_ref())) {
1393                         message->get_ic_ref() = ic;
1394                         message->get_ic_uuid_ref() = ic_uuid;
1395                         m_list_messages.push_back(message);
1396                     } else {
1397                             LOGW("wrong format of transaction\n");
1398                             dealloc_message<MessageItemSelectAssociate>(message);
1399                     }
1400                     break;
1401                 }
1402                 case ISM_TRANS_CMD_ASSOCIATE_TABLE_PAGE_UP:
1403                 {
1404                     MessageItemAssociateTablePageUp *message = alloc_message<MessageItemAssociateTablePageUp>();
1405                     message->get_ic_ref() = ic;
1406                     message->get_ic_uuid_ref() = ic_uuid;
1407                     m_list_messages.push_back(message);
1408                     break;
1409                 }
1410                 case ISM_TRANS_CMD_ASSOCIATE_TABLE_PAGE_DOWN:
1411                 {
1412                     MessageItemAssociateTablePageDown *message = alloc_message<MessageItemAssociateTablePageDown>();
1413                     message->get_ic_ref() = ic;
1414                     message->get_ic_uuid_ref() = ic_uuid;
1415                     m_list_messages.push_back(message);
1416                     break;
1417                 }
1418                 case ISM_TRANS_CMD_UPDATE_ASSOCIATE_TABLE_PAGE_SIZE:
1419                 {
1420                     MessageItemUpdateAssociateTablePageSize *message = alloc_message<MessageItemUpdateAssociateTablePageSize>();
1421                     if (transaction.get_data(message->get_size_ref())) {
1422                         message->get_ic_ref() = ic;
1423                         message->get_ic_uuid_ref() = ic_uuid;
1424                         m_list_messages.push_back(message);
1425                     } else {
1426                         LOGW("wrong format of transaction\n");
1427                         dealloc_message<MessageItemUpdateAssociateTablePageSize>(message);
1428                     }
1429                     break;
1430                 }
1431                 case ISM_TRANS_CMD_RESET_ISE_CONTEXT:
1432                 {
1433                     MessageItemResetISEContext *message = alloc_message<MessageItemResetISEContext>();
1434                     if (message) {
1435                         message->get_command_ref() = cmd;
1436                         message->get_ic_ref() = ic;
1437                         message->get_ic_uuid_ref() = ic_uuid;
1438                         m_list_messages.push_back(message);
1439                     }
1440                     break;
1441                 }
1442                 case ISM_TRANS_CMD_TURN_ON_LOG:
1443                 {
1444                     MessageItemTurnOnLog *message = alloc_message<MessageItemTurnOnLog>();
1445                     if (transaction.get_data(message->get_state_ref())) {
1446                         m_list_messages.push_back(message);
1447                     } else {
1448                         LOGW("wrong format of transaction\n");
1449                         dealloc_message<MessageItemTurnOnLog>(message);
1450                     }
1451                     break;
1452                 }
1453                 case ISM_TRANS_CMD_UPDATE_DISPLAYED_CANDIDATE:
1454                 {
1455                     MessageItemUpdateDisplayedCandidate *message = alloc_message<MessageItemUpdateDisplayedCandidate>();
1456                     if (transaction.get_data(message->get_size_ref())) {
1457                         message->get_ic_ref() = ic;
1458                         message->get_ic_uuid_ref() = ic_uuid;
1459                         m_list_messages.push_back(message);
1460                     } else {
1461                         LOGW("wrong format of transaction\n");
1462                         dealloc_message<MessageItemUpdateDisplayedCandidate>(message);
1463                     }
1464                     break;
1465                 }
1466                 case ISM_TRANS_CMD_LONGPRESS_CANDIDATE:
1467                 {
1468                     MessageItemLongpressCandidate *message = alloc_message<MessageItemLongpressCandidate>();
1469                     if (message) {
1470                         message->get_command_ref() = cmd;
1471                         if (transaction.get_data(message->get_index_ref())) {
1472                             message->get_ic_ref() = ic;
1473                             message->get_ic_uuid_ref() = ic_uuid;
1474                             m_list_messages.push_back(message);
1475                         } else {
1476                             LOGW("wrong format of transaction\n");
1477                             dealloc_message<MessageItemLongpressCandidate>(message);
1478                         }
1479                     }
1480                     break;
1481                 }
1482                 case ISM_TRANS_CMD_SET_INPUT_HINT:
1483                 {
1484                     MessageItemSetInputHint *message = alloc_message<MessageItemSetInputHint>();
1485                     if (message) {
1486                         message->get_command_ref() = cmd;
1487                         if (transaction.get_data(message->get_input_hint_ref())) {
1488                             m_list_messages.push_back(message);
1489                         } else {
1490                             LOGW("wrong format of transaction\n");
1491                             dealloc_message<MessageItemSetInputHint>(message);
1492                         }
1493                     }
1494                     break;
1495                 }
1496                 case ISM_TRANS_CMD_UPDATE_BIDI_DIRECTION:
1497                 {
1498                     MessageItemUpdateBidiDirection *message = alloc_message<MessageItemUpdateBidiDirection>();
1499                     if (message) {
1500                         message->get_command_ref() = cmd;
1501                         if (transaction.get_data(message->get_bidi_direction())) {
1502                             m_list_messages.push_back(message);
1503                         } else {
1504                             LOGW("wrong format of transaction\n");
1505                             dealloc_message<MessageItemUpdateBidiDirection>(message);
1506                         }
1507                     }
1508                     break;
1509                 }
1510                 case ISM_TRANS_CMD_SHOW_ISE_OPTION_WINDOW:
1511                 {
1512                     MessageItemShowISEOptionWindow *message = alloc_message<MessageItemShowISEOptionWindow>();
1513                     if (message) {
1514                         message->get_command_ref() = cmd;
1515                         message->get_ic_ref() = ic;
1516                         message->get_ic_uuid_ref() = ic_uuid;
1517                         m_list_messages.push_back(message);
1518                     }
1519                     break;
1520                 }
1521                 case ISM_TRANS_CMD_RESUME_ISE_OPTION_WINDOW:
1522                 {
1523                     MessageItemResumeISEOptionWindow *message = alloc_message<MessageItemResumeISEOptionWindow>();
1524                     if (message) {
1525                         message->get_command_ref() = cmd;
1526                         message->get_ic_ref() = ic;
1527                         message->get_ic_uuid_ref() = ic_uuid;
1528                         m_list_messages.push_back(message);
1529                     }
1530                     break;
1531                 }
1532                 case ISM_TRANS_CMD_CHECK_OPTION_WINDOW:
1533                 {
1534                     MessageItemCheckOptionWindow *message = alloc_message<MessageItemCheckOptionWindow>();
1535                     if (message) {
1536                         message->get_command_ref() = cmd;
1537                         m_list_messages.push_back(message);
1538                     }
1539                     break;
1540                 }
1541                 case ISM_TRANS_CMD_PROCESS_INPUT_DEVICE_EVENT:
1542                 {
1543                     MessageItemProcessInputDeviceEvent *message = alloc_message<MessageItemProcessInputDeviceEvent>();
1544                     if (message) {
1545                         message->get_command_ref() = cmd;
1546                         if (transaction.get_data(message->get_type_ref()) &&
1547                             transaction.get_data(message->get_data_ptr(), message->get_len_ref())) {
1548                             m_list_messages.push_back(message);
1549                         } else {
1550                             LOGW("wrong format of transaction\n");
1551                             dealloc_message<MessageItemProcessInputDeviceEvent>(message);
1552                         }
1553                     }
1554                     break;
1555                 }
1556                 case SCIM_TRANS_CMD_SET_AUTOCAPITAL_TYPE:
1557                 {
1558                     MessageItemSetAutocapitalType *message = alloc_message<MessageItemSetAutocapitalType>();
1559                     if (message) {
1560                         message->get_command_ref() = cmd;
1561                         if (transaction.get_data(message->get_auto_capital_type_ref())) {
1562                             m_list_messages.push_back(message);
1563                         } else {
1564                             LOGW("wrong format of transaction\n");
1565                             dealloc_message<MessageItemSetAutocapitalType>(message);
1566                         }
1567                     }
1568                     break;
1569                 }
1570                 case ISM_TRANS_CMD_SET_PREDICTION_ALLOW:
1571                 {
1572                     MessageItemSetPredictionAllow *message = alloc_message<MessageItemSetPredictionAllow>();
1573                     if (message) {
1574                         message->get_command_ref() = cmd;
1575                         if (transaction.get_data(message->get_prediction_allow_ref())) {
1576                             m_list_messages.push_back(message);
1577                         } else {
1578                             LOGW("wrong format of transaction\n");
1579                             dealloc_message<MessageItemSetPredictionAllow>(message);
1580                         }
1581                     }
1582                     break;
1583                 }
1584             }
1585         }
1586
1587         return true;
1588     }
1589
1590 protected:
1591     typedef std::list<MessageItem*> MESSAGE_LIST;
1592     MESSAGE_LIST m_list_messages;
1593 };
1594
1595 } /* namespace scim */
1596
1597 #endif  /* __ISF_MESSAGE_H */
1598
1599 /*
1600 vi:ts=4:expandtab:nowrap
1601 */