dali/public-api/events/key-event.cpp

   1 /*
   2  * Copyright (c) 2015 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/public-api/events/key-event.h>
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/devel-api/events/key-event-devel.h>
  23 #include <dali/devel-api/common/map-wrapper.h>
  24
  25 namespace Dali
  26 {
  27
  28 namespace
  29 {
  30 const unsigned int MODIFIER_SHIFT = 0x1;
  31 const unsigned int MODIFIER_CTRL  = 0x2;
  32 const unsigned int MODIFIER_ALT   = 0x4;
  33 const int KEY_INVALID_CODE = -1;
  34
  35 struct KeyEventImpl
  36 {
  37   KeyEventImpl()
  38   : deviceName( "" ),
  39     deviceClass( DevelKeyEvent::DeviceClass::NONE )
  40   {
  41   }
  42
  43   KeyEventImpl& operator=( const KeyEventImpl& rhs )
  44   {
  45     if( this != &rhs )
  46     {
  47       deviceName = rhs.deviceName;
  48       deviceClass = rhs.deviceClass;
  49     }
  50
  51     return *this;
  52   }
  53
  54   KeyEventImpl( const KeyEventImpl& rhs )
  55   {
  56     deviceName =  rhs.deviceName;
  57     deviceClass = rhs.deviceClass;
  58   }
  59
  60   std::string deviceName;
  61   DevelKeyEvent::DeviceClass::Type deviceClass;
  62 };
  63
  64 typedef std::map< const KeyEvent*, KeyEventImpl*> KeyEventMap;
  65 typedef KeyEventMap::const_iterator KeyEventMapIter;
  66
  67
  68 KeyEventMap keyEventImplMap;
  69
  70 }
  71
  72 KeyEvent::KeyEvent()
  73 : keyPressedName(""),
  74   keyPressed(""),
  75   keyCode(KEY_INVALID_CODE),
  76   keyModifier(0),
  77   time(0),
  78   state(KeyEvent::Down)
  79 {
  80   KeyEventImpl* impl = new KeyEventImpl;
  81   keyEventImplMap[this] = impl;
  82 }
  83
  84 KeyEvent::KeyEvent(const std::string& keyName, const std::string& keyString, int keyCode, int keyModifier,unsigned long timeStamp, const State& keyState)
  85 : keyPressedName(keyName),
  86   keyPressed(keyString),
  87   keyCode(keyCode),
  88   keyModifier(keyModifier),
  89   time(timeStamp),
  90   state(keyState)
  91 {
  92   keyEventImplMap[this] = new KeyEventImpl;
  93 }
  94
  95 KeyEvent::KeyEvent( const KeyEvent& rhs )
  96 : keyPressedName( rhs.keyPressedName ),
  97   keyPressed( rhs.keyPressed ),
  98   keyCode( rhs.keyCode ),
  99   keyModifier( rhs.keyModifier ),
 100   time( rhs.time ),
 101   state( rhs.state )
 102 {
 103   keyEventImplMap[this] = new KeyEventImpl( *keyEventImplMap[ &rhs ] );
 104 }
 105
 106 KeyEvent& KeyEvent::operator=( const KeyEvent& rhs )
 107 {
 108   if( this != &rhs )
 109   {
 110     keyPressedName = rhs.keyPressedName;
 111     keyPressed = rhs.keyPressed;
 112     keyCode = rhs.keyCode;
 113     keyModifier = rhs.keyModifier;
 114     time = rhs.time;
 115     state = rhs.state;
 116
 117     *keyEventImplMap[ this ] = *keyEventImplMap[ &rhs ];
 118   }
 119
 120   return *this;
 121 }
 122
 123 KeyEvent::~KeyEvent()
 124 {
 125   delete keyEventImplMap[this];
 126   keyEventImplMap.erase( this );
 127 }
 128
 129 bool KeyEvent::IsShiftModifier() const
 130 {
 131   if ((MODIFIER_SHIFT & keyModifier) == MODIFIER_SHIFT)
 132   {
 133     return true;
 134   }
 135
 136   return false;
 137 }
 138
 139 bool KeyEvent::IsCtrlModifier() const
 140 {
 141   if ((MODIFIER_CTRL & keyModifier) == MODIFIER_CTRL)
 142   {
 143     return true;
 144   }
 145
 146   return false;
 147 }
 148
 149 bool KeyEvent::IsAltModifier() const
 150 {
 151   if ((MODIFIER_ALT & keyModifier) == MODIFIER_ALT)
 152   {
 153     return true;
 154   }
 155
 156   return false;
 157 }
 158
 159 std::string DevelKeyEvent::GetDeviceName( const KeyEvent& keyEvent )
 160 {
 161   KeyEventMapIter search = keyEventImplMap.find( &keyEvent );
 162
 163   if( search != keyEventImplMap.end())
 164   {
 165     return search->second->deviceName;
 166   }
 167
 168   return std::string("");
 169 }
 170
 171 void DevelKeyEvent::SetDeviceName( KeyEvent& keyEvent, const std::string& deviceName )
 172 {
 173   KeyEventMapIter search = keyEventImplMap.find( &keyEvent );
 174
 175   if( search != keyEventImplMap.end())
 176   {
 177     search->second->deviceName = deviceName;
 178   }
 179 }
 180
 181 DevelKeyEvent::DeviceClass::Type DevelKeyEvent::GetDeviceClass( const KeyEvent& keyEvent )
 182 {
 183   KeyEventMapIter search = keyEventImplMap.find( &keyEvent );
 184
 185   DevelKeyEvent::DeviceClass::Type result = DevelKeyEvent::DeviceClass::NONE;
 186
 187   if( search != keyEventImplMap.end() )
 188   {
 189     result = search->second->deviceClass;
 190   }
 191
 192   return result;
 193 }
 194
 195 void DevelKeyEvent::SetDeviceClass( KeyEvent& keyEvent, const DeviceClass::Type& deviceClass )
 196 {
 197   KeyEventMapIter search = keyEventImplMap.find( &keyEvent );
 198
 199   if( search != keyEventImplMap.end() )
 200   {
 201     search->second->deviceClass = deviceClass;
 202   }
 203 }
 204
 205 } // namespace Dali