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     if (uiimpl->get_caps_mode()) {
  93         return;
  94     }
  95
  96     CSCLContext *context = CSCLContext::get_instance();
  97
  98     sclboolean turn_shift_off = TRUE;
  99     if (ui_event_desc.key_event == MVK_Shift_L || ui_event_desc.key_event == MVK_Caps_Lock) {
 100         turn_shift_off = FALSE;
 101     }
 102     if (ui_event_desc.key_type == KEY_TYPE_MODECHANGE) {
 103         turn_shift_off = FALSE;
 104     }
 105     /* If we are in ON_PRESSED or ON_KEY_ENTERED mode of shift multi touch state, do not turn it off now */
 106     if (context->get_shift_multi_touch_enabled() && turn_shift_off) {
 107         CSCLContext *context = CSCLContext::get_instance();
 108         if (context) {
 109             if (context->get_shift_multi_touch_state() == SCL_SHIFT_MULTITOUCH_ON_PRESSED) {
 110                 context->set_shift_multi_touch_state(SCL_SHIFT_MULTITOUCH_ON_KEY_ENTERED);
 111                 turn_shift_off = FALSE;
 112             } else if (context->get_shift_multi_touch_state() == SCL_SHIFT_MULTITOUCH_ON_KEY_ENTERED) {
 113                 turn_shift_off = FALSE;
 114             }
 115         }
 116     }
 117     if (turn_shift_off) {
 118         if (uiimpl->get_shift_state() == SCL_SHIFT_STATE_ON) {
 119             uiimpl->set_shift_state(SCL_SHIFT_STATE_OFF);
 120         }
 121     }
 122 }
 123
 124 static void handle_mode_change_button_click_event(SclUIEventDesc ui_event_desc)
 125 {
 126     CSCLUIImpl *uiimpl = CSCLUIImpl::get_instance();
 127
 128     if (uiimpl) {
 129         if (ui_event_desc.key_type == KEY_TYPE_MODECHANGE) {
 130             uiimpl->set_input_mode(ui_event_desc.key_value);
 131         }
 132     }
 133 }
 134
 135 SCLEventReturnType
 136 CSCLEventHandler::on_event_key_clicked(SclUIEventDesc ui_event_desc)
 137 {
 138     SCLEventReturnType ret = SCL_EVENT_PASS_ON;
 139
 140     pre_process_ui_event(ui_event_desc);
 141
 142     if (m_cur_input_mode_event_callback) {
 143         ret = m_cur_input_mode_event_callback->on_event_key_clicked(ui_event_desc);
 144     }
 145     if (ret == SCL_EVENT_PASS_ON) {
 146         if (m_default_event_callback) {
 147             ret = m_default_event_callback->on_event_key_clicked(ui_event_desc);
 148         }
 149     }
 150
 151     if (ret == SCL_EVENT_PASS_ON) {
 152         /* Here we can put the fallback processing of this UIEvent */
 153
 154         /* General requirement - 1 */
 155         /* When the SHIFT button was clicked, we change the shift state to OFF -> ON -> LOCK -> OFF ... */
 156         handle_shift_button_click_event(ui_event_desc);
 157
 158         /* General requirement - 2 */
 159         /* If a key was clicked but it is neither a SHIFT nor a CAPSLOCK, we just turn the shift off, if it is on */
 160         handle_shift_state_on_button_click_event(ui_event_desc);
 161
 162         /* General requirement - 3 */
 163         /* If the key type is KEY_TYPE_MODECHANGE, change the current input mode to given key_value */
 164         handle_mode_change_button_click_event(ui_event_desc);
 165     }
 166
 167     return ret;
 168 }
 169
 170 SCLEventReturnType
 171 CSCLEventHandler::on_event_drag_state_changed(SclUIEventDesc ui_event_desc)
 172 {
 173     SCLEventReturnType ret = SCL_EVENT_PASS_ON;
 174
 175     pre_process_ui_event(ui_event_desc);
 176
 177     if (m_cur_input_mode_event_callback) {
 178         ret = m_cur_input_mode_event_callback->on_event_drag_state_changed(ui_event_desc);
 179     }
 180     if (ret == SCL_EVENT_PASS_ON) {
 181         if (m_default_event_callback) {
 182             ret = m_default_event_callback->on_event_drag_state_changed(ui_event_desc);
 183         }
 184     }
 185
 186     if (ret == SCL_EVENT_PASS_ON) {
 187         /* Here we can put the fallback processing of this UIEvent */
 188         CSCLUIImpl *uiimpl = CSCLUIImpl::get_instance();
 189         CSCLContext *context = CSCLContext::get_instance();
 190
 191         /* General requirement - 1 */
 192         /* When the SHIFT button was 'pressed' and shift button multitouch action is enabled,
 193            we change the current shift multitouch state to 'ON_PRESSED' */
 194         if (uiimpl && context) {
 195             if (context->get_shift_multi_touch_enabled()) {
 196                 if (ui_event_desc.event_type == EVENT_TYPE_PRESS) {
 197                     if (context) {
 198                         if (ui_event_desc.key_event == MVK_Shift_L) {
 199                             if (context->get_shift_multi_touch_state() == SCL_SHIFT_MULTITOUCH_OFF) {
 200                                 uiimpl->set_shift_state(SCL_SHIFT_STATE_ON);
 201                                 context->set_shift_multi_touch_state(SCL_SHIFT_MULTITOUCH_ON_PRESSED);
 202                             }
 203                         }
 204                     }
 205                 }
 206             }
 207         }
 208     }
 209
 210     return ret;
 211 }
 212
 213 SCLEventReturnType
 214 CSCLEventHandler::on_event_notification(SCLUINotiType noti_type, sclint etc_info)
 215 {
 216     SCLEventReturnType ret = SCL_EVENT_PASS_ON;
 217
 218     if (m_cur_input_mode_event_callback) {
 219         ret = m_cur_input_mode_event_callback->on_event_notification(noti_type, etc_info);
 220     }
 221     if (ret == SCL_EVENT_PASS_ON) {
 222         if (m_default_event_callback) {
 223             ret = m_default_event_callback->on_event_notification(noti_type, etc_info);
 224         }
 225     }
 226
 227     if (ret == SCL_EVENT_PASS_ON) {
 228         /* Here we can put the fallback processing of this UIEvent */
 229     }
 230
 231     return ret;
 232 }
 233
 234 sclboolean
 235 CSCLEventHandler::set_input_mode(const sclchar *input_mode)
 236 {
 237     SCL_DEBUG();
 238
 239     sclboolean ret = FALSE;
 240     m_cur_input_mode_event_callback = NULL;
 241
 242     if (input_mode) {
 243         std::string id = input_mode;
 244         std::map<std::string, ISCLUIEventCallback*>::iterator iter = m_input_mode_event_callbacks.find(input_mode);
 245         if (iter != m_input_mode_event_callbacks.end()) {
 246             m_cur_input_mode_event_callback = (iter->second);
 247         }
 248     }
 249
 250     if (m_cur_input_mode_event_callback) {
 251         ret = TRUE;
 252     }
 253
 254     return ret;
 255 }
 256
 257 void
 258 CSCLEventHandler::set_event_callback(ISCLUIEventCallback *callback, const sclchar *input_mode)
 259 {
 260     SCL_DEBUG();
 261
 262     scl_assert_return(callback);
 263
 264     if (input_mode) {
 265         std::string id = input_mode;
 266         m_input_mode_event_callbacks[id] = callback;
 267     } else {
 268         m_default_event_callback = callback;
 269     }
 270 }
 271
 272 void
 273 CSCLEventHandler::pre_process_ui_event(SclUIEventDesc &ui_event_desc)
 274 {
 275     SCL_DEBUG();
 276
 277     typedef struct {
 278         const sclchar *key_value;
 279         sclulong key_event;
 280     } KEY_VALUE_EVENT_CONVERT_TABLE;
 281
 282     KEY_VALUE_EVENT_CONVERT_TABLE control_keys[] = {
 283         {"Space",       MVK_space       },
 284         {"BackSpace",   MVK_BackSpace   },
 285         {"Shift",       MVK_Shift_L     },
 286         {"CapsLock",    MVK_Caps_Lock   },
 287         {"Enter",       MVK_Return      },
 288         {"Left",        MVK_Left        },
 289         {"Right",       MVK_Right       },
 290         {"Up",          MVK_Up          },
 291         {"Down",        MVK_Down        },
 292     };
 293
 294     /* Translate key_values only when key_event is 0 and key_value is not NULL */
 295     if (ui_event_desc.key_value && ui_event_desc.key_event == 0) {
 296         if (ui_event_desc.key_type == KEY_TYPE_CHAR) {
 297             /* If the key_value is a string with length 1, and the first character has value between
 298                SCL_ISCHAR range, provide the corresponding ASCII code in key_event field */
 299             if (ui_event_desc.key_value[0] != '\0' && ui_event_desc.key_value[1] == '\0') {
 300                 if (SCL_ISCHAR(ui_event_desc.key_value[0])) {
 301                     ui_event_desc.key_event = ui_event_desc.key_value[0];
 302                 }
 303             }
 304         } else if (ui_event_desc.key_type == KEY_TYPE_CONTROL) {
 305             const scluint control_keys_size = sizeof(control_keys) / sizeof(KEY_VALUE_EVENT_CONVERT_TABLE);
 306
 307             for (scluint loop = 0;loop < control_keys_size;loop++) {
 308                 if (strncmp(control_keys[loop].key_value, ui_event_desc.key_value, strlen(control_keys[loop].key_value)) == 0) {
 309                     ui_event_desc.key_event = control_keys[loop].key_event;
 310                 }
 311             }
 312         } else if (ui_event_desc.key_type == KEY_TYPE_STRING) {
 313             CSCLResourceCache *cache = CSCLResourceCache::get_instance();
 314             if (cache) {
 315                 ui_event_desc.key_value = cache->find_substituted_string(ui_event_desc.key_value);
 316             }
 317         }
 318     }
 319 }