src/ui/FUi_UiKeyEvent.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Flora License, Version 1.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://floralicense.org/license/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an AS IS BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17 /**
  18  * @file                FUi_UiKeyEvent.cpp
  19  * @brief               This is the implementation file for the _UiKeyEvent class.
  20  */
  21
  22 #include <FBaseResult.h>
  23 #include <FBaseSysLog.h>
  24 #include "FUi_UiKeyEvent.h"
  25 #include "FUi_IKeyEventListener.h"
  26 #include "FUi_IKeyEventPreviewer.h"
  27 #include "FUi_Control.h"
  28 #include "FUi_ControlImpl.h"
  29
  30 namespace Tizen { namespace Ui
  31 {
  32
  33 _KeyInfo::_KeyInfo(KeyState keyState, _KeyCode keyCode, int keyModifier, void* pUserData)
  34         : __keyState(keyState)
  35         , __keyCode(keyCode)
  36         , __keyModifier(keyModifier)
  37         , __pUserData(pUserData)
  38 {
  39 }
  40
  41 _KeyInfo::_KeyInfo(const _KeyInfo& rhs)
  42         : __keyState(rhs.__keyState)
  43         , __keyCode(rhs.__keyCode)
  44         , __keyModifier(rhs.__keyModifier)
  45         , __pUserData(rhs.__pUserData)
  46 {
  47 }
  48
  49 _KeyInfo&
  50 _KeyInfo::operator =(const _KeyInfo& rhs)
  51 {
  52         if (this != &rhs)
  53         {
  54                 __keyState = rhs.__keyState;
  55                 __keyCode = rhs.__keyCode;
  56                 __keyModifier = rhs.__keyModifier;
  57                 __pUserData = rhs.__pUserData;
  58         }
  59
  60         return *this;
  61 }
  62
  63 _KeyInfo::~_KeyInfo(void)
  64 {
  65 }
  66
  67 void
  68 _KeyInfo::SetKeyState(KeyState keyState)
  69 {
  70         __keyState = keyState;
  71 }
  72
  73 KeyState
  74 _KeyInfo::GetKeyState(void) const
  75 {
  76         return __keyState;
  77 }
  78
  79 void
  80 _KeyInfo::SetKeyCode(_KeyCode keyCode)
  81 {
  82         __keyCode = keyCode;
  83 }
  84
  85 _KeyCode
  86 _KeyInfo::GetKeyCode(void) const
  87 {
  88         return __keyCode;
  89 }
  90
  91 void
  92 _KeyInfo::SetKeyModifier(int keyModifier)
  93 {
  94         __keyModifier = keyModifier;
  95 }
  96
  97 int
  98 _KeyInfo::GetKeyModifier(void) const
  99 {
 100         return __keyModifier;
 101 }
 102
 103 void
 104 _KeyInfo::SetUserData(void* pUserData)
 105 {
 106         __pUserData = pUserData;
 107 }
 108
 109 void*
 110 _KeyInfo::GetUserData(void) const
 111 {
 112         return __pUserData;
 113 }
 114
 115 _UiKeyEvent::_UiKeyEvent(const _UiObjectHandle& destination, const _KeyInfo& keyInfo, _UiEventRouteType routeType, const _UiObjectHandle& source)
 116         : _UiEvent(destination, source, routeType)
 117         , __keyInfo(keyInfo)
 118 {
 119 }
 120
 121 _UiKeyEvent::~_UiKeyEvent(void)
 122 {
 123 }
 124
 125 _UiKeyEvent::_UiKeyEvent(const _UiKeyEvent& rhs)
 126         : _UiEvent(rhs)
 127         , __keyInfo(rhs.__keyInfo)
 128 {
 129 }
 130
 131 _UiKeyEvent&
 132 _UiKeyEvent::operator =(const _UiKeyEvent& rhs)
 133 {
 134         _UiEvent::operator =(rhs);
 135
 136         if (this != &rhs)
 137         {
 138                 __keyInfo = rhs.__keyInfo;
 139         }
 140
 141         return *this;
 142 }
 143
 144 const _KeyInfo*
 145 _UiKeyEvent::GetKeyInfo(void) const
 146 {
 147         return &__keyInfo;
 148 }
 149
 150 _UiKeyEvent*
 151 _UiKeyEvent::CloneN(void) const
 152 {
 153         return new (std::nothrow) _UiKeyEvent(*this);
 154 }
 155
 156 _UiEventType
 157 _UiKeyEvent::GetEventType(void) const
 158 {
 159         return _UI_EVENT_KEY;
 160 }
 161
 162 void
 163 _UiKeyEvent::SetKeyState(const KeyState keyState)
 164 {
 165         __keyInfo.SetKeyState(keyState);
 166 }
 167
 168 KeyState
 169 _UiKeyEvent::GetKeyState(void) const
 170 {
 171         return __keyInfo.GetKeyState();
 172 }
 173
 174 void
 175 _UiKeyEvent::SetKeyCode(const _KeyCode keyCode)
 176 {
 177         __keyInfo.SetKeyCode(keyCode);
 178 }
 179
 180 _KeyCode
 181 _UiKeyEvent::GetKeyCode(void) const
 182 {
 183         return __keyInfo.GetKeyCode();
 184 }
 185
 186 void
 187 _UiKeyEvent::SetKeyModifier(int keyModifier)
 188 {
 189         __keyInfo.SetKeyModifier(keyModifier);
 190 }
 191
 192 int
 193 _UiKeyEvent::GetKeyModifier(void) const
 194 {
 195         return __keyInfo.GetKeyModifier();
 196 }
 197
 198 result
 199 _UiKeyEvent::OnPreviewEventProcessing(const _Control& control, bool& isFiltered)
 200 {
 201         result r = E_SUCCESS;
 202
 203         if (!control.IsInputEnabled())
 204         {
 205                 return E_SUCCESS;
 206         }
 207
 208         _IKeyEventPreviewer* pKeyEventPreviewer = control.GetEventPreviewer<_UI_EVENT_KEY, _IKeyEventPreviewer*>();
 209         SysTryReturn(NID_UI, pKeyEventPreviewer, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 210
 211         const _Control* pTarget = GetControl(GetDestination());
 212         SysTryReturn(NID_UI, pTarget, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 213
 214         // call a listener method by the key state
 215         switch (GetKeyState())
 216         {
 217         case KEY_PRESSED:
 218                 {
 219                         isFiltered = pKeyEventPreviewer->OnPreviewKeyPressed(*pTarget, __keyInfo);
 220                 }
 221                 break;
 222
 223         case KEY_RELEASED:
 224                 {
 225                         isFiltered = pKeyEventPreviewer->OnPreviewKeyReleased(*pTarget, __keyInfo);
 226                 }
 227                 break;
 228
 229         default:
 230                 //SysLogI(NID_UI, "unable to determine the key event type.");
 231                 r = E_SYSTEM;
 232                 break;
 233         }
 234
 235         return r;
 236 }
 237
 238 result
 239 _UiKeyEvent::OnEventProcessing(const _Control& control, bool& isFiltered)
 240 {
 241         if (isFiltered)
 242         {
 243                 return E_SUCCESS;
 244         }
 245
 246         _IKeyEventListener* pKeyEventListener = control.GetPropagatedKeyEventListener();
 247         SysTryReturn(NID_UI, pKeyEventListener, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 248
 249         return FireListener(pKeyEventListener, isFiltered);
 250 }
 251
 252 result
 253 _UiKeyEvent::OnListenerProcessing(const _IUiEventListener& listener, bool& isFiltered)
 254 {
 255         _IKeyEventListener* pKeyEventListener = dynamic_cast <_IKeyEventListener*>(const_cast <_IUiEventListener*>(&listener));
 256         SysTryReturn(NID_UI, pKeyEventListener, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 257
 258         return FireListener(pKeyEventListener, isFiltered);
 259 }
 260
 261 result
 262 _UiKeyEvent::FireListener(const _IKeyEventListener* pListener, bool& isFiltered)
 263 {
 264         _IKeyEventListener* pKeyEventListener = const_cast <_IKeyEventListener*>(pListener);
 265         SysTryReturn(NID_UI, pKeyEventListener, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 266
 267         result r = E_SUCCESS;
 268
 269         const _Control* pTarget = GetControl(GetDestination());
 270         SysTryReturn(NID_UI, pTarget, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 271
 272         // call a listener method by the key state
 273         switch (GetKeyState())
 274         {
 275         case KEY_PRESSED:
 276                 isFiltered = pKeyEventListener->OnKeyPressed(*pTarget, __keyInfo);
 277                 break;
 278
 279         case KEY_RELEASED:
 280                 isFiltered = pKeyEventListener->OnKeyReleased(*pTarget, __keyInfo);
 281                 break;
 282
 283         // 2.0 compatibility for key simulate
 284         case KEY_LONGPRESSED:
 285                 {
 286                         _ControlImpl* pTargetImpl = static_cast<_ControlImpl*>(pTarget->GetUserData());
 287                         if (pTargetImpl)
 288                         {
 289                                 pTargetImpl->GenerateKeyEvent(KEY_LONGPRESSED, GetKeyCode());
 290                         }
 291                 }
 292                 break;
 293
 294         default:
 295                 //SysLogI(NID_UI, "unable to determine the key event type.");
 296                 r = E_SYSTEM;
 297                 break;
 298         }
 299
 300         return r;
 301 }
 302
 303 }} // Tizen::Ui