scl/scleventhandler.cpp

   1 /*
   2  * Copyright 2012-2013 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Flora License, Version 1.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://floralicense.org/license/
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include "sclresourcecache.h"
  19 #include "scleventhandler.h"
  20 #include "scldebug.h"
  21 #include "sclkeydefines.h"
  22 #include "scluiimpl.h"
  23
  24 using namespace scl;
  25
  26 CSCLEventHandler* CSCLEventHandler::m_instance = NULL; /* For singleton */
  27
  28 CSCLEventHandler::CSCLEventHandler()
  29 {
  30     SCL_DEBUG();
  31
  32     m_default_event_callback = NULL;
  33     m_cur_input_mode_event_callback = NULL;
  34 }
  35
  36 CSCLEventHandler::~CSCLEventHandler()
  37 {
  38     SCL_DEBUG();
  39 }
  40
  41 CSCLEventHandler*
  42 CSCLEventHandler::get_instance()
  43 {
  44     if (!m_instance) {
  45         m_instance = new CSCLEventHandler();
  46     }
  47     return (CSCLEventHandler*)m_instance;
  48 }
  49
  50 static void handle_shift_button_click_event(SclUIEventDesc ui_event_desc)
  51 {
  52     CSCLUIImpl *uiimpl = CSCLUIImpl::get_instance();
  53     CSCLContext *context = CSCLContext::get_instance();
  54
  55     if (uiimpl && context) {
  56         if (ui_event_desc.key_type == KEY_TYPE_CONTROL && ui_event_desc.key_event == MVK_Shift_L) {
  57             switch (uiimpl->get_shift_state()) {
  58                 case SCL_SHIFT_STATE_OFF: {
  59                     uiimpl->set_shift_state(SCL_SHIFT_STATE_ON);
  60                 }
  61                 break;
  62                 case SCL_SHIFT_STATE_ON: {
  63                     /* The default next state should be LOCK state */
  64                     SCLShiftState next_state = SCL_SHIFT_STATE_LOCK;
  65                     if (context->get_shift_multi_touch_enabled()) {
  66                         CSCLContext *context = CSCLContext::get_instance();
  67                         if (context) {
  68                             if (context->get_shift_multi_touch_state() == SCL_SHIFT_MULTITOUCH_ON_PRESSED) {
  69                                 /* If the shift multi touch state is ON_PRESSED, don't leave ON state now */
  70                                 next_state = SCL_SHIFT_STATE_ON;
  71                             } else if (context->get_shift_multi_touch_state() == SCL_SHIFT_MULTITOUCH_ON_KEY_ENTERED) {
  72                                 /* If some keys were already entered while shift key was in pressed state, move to OFF */
  73                                 next_state = SCL_SHIFT_STATE_OFF;
  74                             }
  75                         }
  76                     }
  77                     uiimpl->set_shift_state(next_state);
  78                 }
  79                 break;
  80                 case SCL_SHIFT_STATE_LOCK: {
  81                     uiimpl->set_shift_state(SCL_SHIFT_STATE_OFF);
  82                 }
  83                 break;
  84             }
  85         }
  86     }
  87 }
  88
  89 static void handle_shift_state_on_button_click_event(SclUIEventDesc ui_event_desc)
  90 {
  91     CSCLUIImpl *uiimpl = CSCLUIImpl::get_instance();
  92     CSCLContext *context = CSCLContext::get_instance();
  93
  94     if (uiimpl && context) {
  95         sclboolean turn_shift_off = TRUE;
  96         if (ui_event_desc.key_type == KEY_TYPE_CONTROL) {
  97             if (ui_event_desc.key_event == MVK_Shift_L || ui_event_desc.key_event == MVK_Caps_Lock) {
  98                 turn_shift_off = FALSE;
  99             }
 100             if (ui_event_desc.key_type == KEY_TYPE_MODECHANGE) {
 101                 turn_shift_off = FALSE;
 102             }
 103             if (uiimpl->get_caps_mode()) {
 104                 turn_shift_off = FALSE;
 105             }
 106         }
 107         /* If we are in ON_PRESSED or ON_KEY_ENTERED mode of shift multi touch state, do not turn it off now */
 108         if (context->get_shift_multi_touch_enabled() && turn_shift_off) {
 109             CSCLContext *context = CSCLContext::get_instance();
 110             if (context) {
 111                 if (context->get_shift_multi_touch_state() == SCL_SHIFT_MULTITOUCH_ON_PRESSED) {
 112                     context->set_shift_multi_touch_state(SCL_SHIFT_MULTITOUCH_ON_KEY_ENTERED);
 113                     turn_shift_off = FALSE;
 114                 } else if (context->get_shift_multi_touch_state() == SCL_SHIFT_MULTITOUCH_ON_KEY_ENTERED) {
 115                     turn_shift_off = FALSE;
 116                 }
 117             }
 118         }
 119         if (turn_shift_off) {
 120             if (uiimpl->get_shift_state() == SCL_SHIFT_STATE_ON) {
 121                 uiimpl->set_shift_state(SCL_SHIFT_STATE_OFF);
 122             }
 123         }
 124     }
 125 }
 126
 127 static void handle_mode_change_button_click_event(SclUIEventDesc ui_event_desc)
 128 {
 129     CSCLUIImpl *uiimpl = CSCLUIImpl::get_instance();
 130
 131     if (uiimpl) {
 132         if (ui_event_desc.key_type == KEY_TYPE_MODECHANGE) {
 133             uiimpl->set_input_mode(ui_event_desc.key_value);
 134         }
 135     }
 136 }
 137
 138 SCLEventReturnType
 139 CSCLEventHandler::on_event_key_clicked(SclUIEventDesc ui_event_desc)
 140 {
 141     SCLEventReturnType ret = SCL_EVENT_PASS_ON;
 142
 143     pre_process_ui_event(ui_event_desc);
 144
 145     if (m_cur_input_mode_event_callback) {
 146         ret = m_cur_input_mode_event_callback->on_event_key_clicked(ui_event_desc);
 147     }
 148     if (ret == SCL_EVENT_PASS_ON) {
 149         if (m_default_event_callback) {
 150             ret = m_default_event_callback->on_event_key_clicked(ui_event_desc);
 151         }
 152     }
 153
 154     if (ret == SCL_EVENT_PASS_ON) {
 155         /* Here we can put the fallback processing of this UIEvent */
 156
 157         /* General requirement - 1 */
 158         /* When the SHIFT button was clicked, we change the shift state to OFF -> ON -> LOCK -> OFF ... */
 159         handle_shift_button_click_event(ui_event_desc);
 160
 161         /* General requirement - 2 */
 162         /* If a key was clicked but it is neither a SHIFT nor a CAPSLOCK, we just turn the shift off, if it is on */
 163         handle_shift_state_on_button_click_event(ui_event_desc);
 164
 165         /* General requirement - 3 */
 166         /* If the key type is KEY_TYPE_MODECHANGE, change the current input mode to given key_value */
 167         handle_mode_change_button_click_event(ui_event_desc);
 168     }
 169
 170     return ret;
 171 }
 172
 173 SCLEventReturnType
 174 CSCLEventHandler::on_event_drag_state_changed(SclUIEventDesc ui_event_desc)
 175 {
 176     SCLEventReturnType ret = SCL_EVENT_PASS_ON;
 177
 178     pre_process_ui_event(ui_event_desc);
 179
 180     if (m_cur_input_mode_event_callback) {
 181         ret = m_cur_input_mode_event_callback->on_event_drag_state_changed(ui_event_desc);
 182     }
 183     if (ret == SCL_EVENT_PASS_ON) {
 184         if (m_default_event_callback) {
 185             ret = m_default_event_callback->on_event_drag_state_changed(ui_event_desc);
 186         }
 187     }
 188
 189     if (ret == SCL_EVENT_PASS_ON) {
 190         /* Here we can put the fallback processing of this UIEvent */
 191         CSCLUIImpl *uiimpl = CSCLUIImpl::get_instance();
 192         CSCLContext *context = CSCLContext::get_instance();
 193
 194         /* General requirement - 1 */
 195         /* When the SHIFT button was 'pressed' and shift button multitouch action is enabled,
 196            we change the current shift multitouch state to 'ON_PRESSED' */
 197         if (uiimpl && context) {
 198             if (context->get_shift_multi_touch_enabled()) {
 199                 if (ui_event_desc.event_type == EVENT_TYPE_PRESS) {
 200                     if (context) {
 201                         if (ui_event_desc.key_event == MVK_Shift_L) {
 202                             if (context->get_shift_multi_touch_state() == SCL_SHIFT_MULTITOUCH_OFF) {
 203                                 uiimpl->set_shift_state(SCL_SHIFT_STATE_ON);
 204                                 context->set_shift_multi_touch_state(SCL_SHIFT_MULTITOUCH_ON_PRESSED);
 205                             }
 206                         }
 207                     }
 208                 }
 209             }
 210         }
 211     }
 212
 213     return ret;
 214 }
 215
 216 SCLEventReturnType
 217 CSCLEventHandler::on_event_notification(SCLUINotiType noti_type, sclint etc_info)
 218 {
 219     SCLEventReturnType ret = SCL_EVENT_PASS_ON;
 220
 221     if (m_cur_input_mode_event_callback) {
 222         ret = m_cur_input_mode_event_callback->on_event_notification(noti_type, etc_info);
 223     }
 224     if (ret == SCL_EVENT_PASS_ON) {
 225         if (m_default_event_callback) {
 226             ret = m_default_event_callback->on_event_notification(noti_type, etc_info);
 227         }
 228     }
 229
 230     if (ret == SCL_EVENT_PASS_ON) {
 231         /* Here we can put the fallback processing of this UIEvent */
 232     }
 233
 234     return ret;
 235 }
 236
 237 sclboolean
 238 CSCLEventHandler::set_input_mode(const sclchar *input_mode)
 239 {
 240     SCL_DEBUG();
 241
 242     sclboolean ret = FALSE;
 243     m_cur_input_mode_event_callback = NULL;
 244
 245     if (input_mode) {
 246         std::string id = input_mode;
 247         std::map<std::string, ISCLUIEventCallback*>::iterator iter = m_input_mode_event_callbacks.find(input_mode);
 248         if (iter != m_input_mode_event_callbacks.end()) {
 249             m_cur_input_mode_event_callback = (iter->second);
 250         }
 251     }
 252
 253     if (m_cur_input_mode_event_callback) {
 254         ret = TRUE;
 255     }
 256
 257     return ret;
 258 }
 259
 260 void
 261 CSCLEventHandler::set_event_callback(ISCLUIEventCallback *callback, const sclchar *input_mode)
 262 {
 263     SCL_DEBUG();
 264
 265     scl_assert_return(callback);
 266
 267     if (input_mode) {
 268         std::string id = input_mode;
 269         m_input_mode_event_callbacks[id] = callback;
 270     } else {
 271         m_default_event_callback = callback;
 272     }
 273 }
 274
 275 void
 276 CSCLEventHandler::pre_process_ui_event(SclUIEventDesc &ui_event_desc)
 277 {
 278     SCL_DEBUG();
 279
 280     typedef struct {
 281         const sclchar *key_value;
 282         sclulong key_event;
 283     } KEY_VALUE_EVENT_CONVERT_TABLE;
 284
 285     KEY_VALUE_EVENT_CONVERT_TABLE control_keys[] = {
 286         {"Space",       MVK_space       },
 287         {"BackSpace",   MVK_BackSpace   },
 288         {"Shift",       MVK_Shift_L     },
 289         {"CapsLock",    MVK_Caps_Lock   },
 290         {"Enter",       MVK_Return      },
 291         {"Left",        MVK_Left        },
 292         {"Right",       MVK_Right       },
 293         {"Up",          MVK_Up          },
 294         {"Down",        MVK_Down        },
 295     };
 296
 297     /* Translate key_values only when key_event is 0 and key_value is not NULL */
 298     if (ui_event_desc.key_value && ui_event_desc.key_event == 0) {
 299         if (ui_event_desc.key_type == KEY_TYPE_CHAR) {
 300             /* If the key_value is a string with length 1, and the first character has value between
 301                SCL_ISCHAR range, provide the corresponding ASCII code in key_event field */
 302             if (ui_event_desc.key_value[0] != '\0' && ui_event_desc.key_value[1] == '\0') {
 303                 if (SCL_ISCHAR(ui_event_desc.key_value[0])) {
 304                     ui_event_desc.key_event = ui_event_desc.key_value[0];
 305                 }
 306             }
 307         } else if (ui_event_desc.key_type == KEY_TYPE_CONTROL) {
 308             const scluint control_keys_size = sizeof(control_keys) / sizeof(KEY_VALUE_EVENT_CONVERT_TABLE);
 309
 310             for (scluint loop = 0;loop < control_keys_size;loop++) {
 311                 if (strncmp(control_keys[loop].key_value, ui_event_desc.key_value, strlen(control_keys[loop].key_value)) == 0) {
 312                     ui_event_desc.key_event = control_keys[loop].key_event;
 313                 }
 314             }
 315         } else if (ui_event_desc.key_type == KEY_TYPE_STRING) {
 316             CSCLResourceCache *cache = CSCLResourceCache::get_instance();
 317             if (cache) {
 318                 ui_event_desc.key_value = cache->find_substituted_string(ui_event_desc.key_value);
 319             }
 320         }
 321     }
 322 }