src/ui/FUi_UiKeyEvent.cpp

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