dali/internal/event/events/key-event-impl.cpp

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.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://www.apache.org/licenses/LICENSE-2.0
   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 // CLASS HEADER
  19 #include <dali/internal/event/events/key-event-impl.h>
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/public-api/common/dali-vector.h>
  23
  24 namespace Dali
  25 {
  26
  27 namespace
  28 {
  29 const uint32_t MODIFIER_SHIFT   = 0x1;
  30 const uint32_t MODIFIER_CTRL    = 0x2;
  31 const uint32_t MODIFIER_ALT     = 0x4;
  32 const int32_t  KEY_INVALID_CODE = -1;
  33 }
  34
  35 namespace Internal
  36 {
  37
  38 KeyEvent::KeyEvent()
  39 : mKeyName( "" ),
  40   mLogicalKey( "" ),
  41   mKeyString( "" ),
  42   mKeyCode( KEY_INVALID_CODE ),
  43   mKeyModifier( 0 ),
  44   mTime( 0 ),
  45   mState( Dali::KeyEvent::Down ),
  46   mCompose( "" ),
  47   mDeviceName( "" ),
  48   mDeviceClass( Device::Class::NONE ),
  49   mDeviceSubclass( Device::Subclass::NONE )
  50 {
  51 }
  52
  53 KeyEvent::KeyEvent( const std::string& keyName,
  54           const std::string& logicalKey,
  55           const std::string& keyString,
  56           int keyCode,
  57           int keyModifier,
  58           unsigned long timeStamp,
  59           const Dali::KeyEvent::State& keyState,
  60           const std::string& compose,
  61           const std::string& deviceName,
  62           const Device::Class::Type deviceClass,
  63           const Device::Subclass::Type deviceSubclass )
  64 : mKeyName( keyName ),
  65   mLogicalKey( logicalKey ),
  66   mKeyString( keyString ),
  67   mKeyCode( keyCode ),
  68   mKeyModifier( keyModifier ),
  69   mTime( timeStamp ),
  70   mState( keyState ),
  71   mCompose( compose ),
  72   mDeviceName( deviceName ),
  73   mDeviceClass( deviceClass ),
  74   mDeviceSubclass( deviceSubclass )
  75 {
  76 }
  77
  78 KeyEvent::~KeyEvent()
  79 {
  80 }
  81
  82 KeyEventPtr KeyEvent::New( const std::string& keyName,
  83                            const std::string& logicalKey,
  84                            const std::string& keyString,
  85                            int keyCode,
  86                            int keyModifier,
  87                            unsigned long timeStamp,
  88                            const Dali::KeyEvent::State& keyState,
  89                            const std::string& compose,
  90                            const std::string& deviceName,
  91                            const Device::Class::Type deviceClass,
  92                            const Device::Subclass::Type deviceSubclass )
  93 {
  94   KeyEventPtr keyEvent = new KeyEvent( keyName, logicalKey, keyString, keyCode, keyModifier, timeStamp, keyState, compose, deviceName, deviceClass, deviceSubclass );
  95   return keyEvent;
  96 }
  97
  98 bool KeyEvent::IsShiftModifier() const
  99 {
 100   return ( ( MODIFIER_SHIFT & mKeyModifier ) == MODIFIER_SHIFT );
 101 }
 102
 103 bool KeyEvent::IsCtrlModifier() const
 104 {
 105   return ( ( MODIFIER_CTRL & mKeyModifier ) == MODIFIER_CTRL );
 106 }
 107
 108 bool KeyEvent::IsAltModifier() const
 109 {
 110   return ( ( MODIFIER_ALT & mKeyModifier ) == MODIFIER_ALT );
 111 }
 112
 113 const std::string& KeyEvent::GetCompose() const
 114 {
 115   return mCompose;
 116 }
 117
 118 const std::string& KeyEvent::GetDeviceName() const
 119 {
 120   return mDeviceName;
 121 }
 122
 123
 124 Device::Class::Type KeyEvent::GetDeviceClass() const
 125 {
 126   return mDeviceClass;
 127 }
 128
 129
 130 Device::Subclass::Type KeyEvent::GetDeviceSubclass() const
 131 {
 132   return mDeviceSubclass;
 133 }
 134
 135
 136 const std::string& KeyEvent::GetKeyName() const
 137 {
 138   return mKeyName;
 139 }
 140
 141
 142 const std::string& KeyEvent::GetKeyString() const
 143 {
 144   return mKeyString;
 145 }
 146
 147
 148 const std::string& KeyEvent::GetLogicalKey() const
 149 {
 150   return mLogicalKey;
 151 }
 152
 153
 154 int32_t KeyEvent::GetKeyCode() const
 155 {
 156   return mKeyCode;
 157 }
 158
 159
 160 int32_t KeyEvent::GetKeyModifier() const
 161 {
 162   return mKeyModifier;
 163 }
 164
 165
 166 unsigned long KeyEvent::GetTime() const
 167 {
 168   return mTime;
 169 }
 170
 171
 172 Dali::KeyEvent::State KeyEvent::GetState() const
 173 {
 174   return mState;
 175 }
 176
 177
 178 void KeyEvent::SetKeyName( const std::string& keyName )
 179 {
 180   mKeyName = keyName;
 181 }
 182
 183
 184 void KeyEvent::SetKeyString( const std::string& keyString )
 185 {
 186   mKeyString = keyString;
 187 }
 188
 189
 190 void KeyEvent::SetKeyCode( int32_t keyCode )
 191 {
 192   mKeyCode = keyCode;
 193 }
 194
 195
 196 void KeyEvent::SetKeyModifier( int32_t keyModifier )
 197 {
 198   mKeyModifier = keyModifier;
 199 }
 200
 201
 202 void KeyEvent::SetTime( unsigned long time )
 203 {
 204   mTime = time;
 205 }
 206
 207
 208 void KeyEvent::SetState( const Dali::KeyEvent::State& state )
 209 {
 210   mState = state;
 211 }
 212
 213 } // namespace Internal
 214
 215 } // namespace Dali