src/ui/FUi_AccessibilityGesture.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 #include <Ecore_X.h>
  18 #include <FAppUiApp.h>
  19 #include <FAppIAppFrame.h>
  20 #include <FBaseSysLog.h>
  21 #include <FGrpCoordinateSystem.h>
  22 #include <FGrpDimension.h>
  23 #include <FUiCtrlFrame.h>
  24 #include <FUiCtrlForm.h>
  25 #include "FUi_AccessibilityGesture.h"
  26 #include "FUi_AccessibilityManager.h"
  27 #include "FUi_ControlManager.h"
  28
  29 #include "FUiAnim_RootVisualElement.h"
  30 #include "FUiAnim_AnimationManager.h"
  31 #include "FUiAnim_DisplayManager.h"
  32 #include "FUiAnim_EflLayer.h"
  33 #include "FUi_Window.h"
  34
  35 using namespace Tizen::App;
  36 using namespace Tizen::Graphics;
  37 using namespace Tizen::Ui::Controls;
  38
  39 /*
  40 namespace
  41 {
  42         void ConvertTouchPosition(Tizen::Ui::_AccessibilityGestureType& type, float &x, float&y)
  43         {
  44                 Tizen::Ui::_Window* pWindow = Tizen::Ui::_ControlManager::GetInstance()->GetCurrentFrame();
  45                 Tizen::Ui::Animations::_RootVisualElement* pRootVE = pWindow->GetRootVisualElement();
  46                 Tizen::Ui::Animations::_EflLayer* pLayer = static_cast<Tizen::Ui::Animations::_EflLayer*>(pRootVE->GetNativeLayer());
  47
  48                 Ecore_Evas* pEcoreEvas = pLayer->GetEcoreEvas();
  49                 Ecore_X_Window win = (Ecore_X_Window)ecore_evas_window_get(pEcoreEvas);
  50
  51                 int rootW = 0;
  52                 int rootH = 0;
  53                 ecore_x_window_size_get(ecore_x_window_root_get(win), &rootW, &rootH);
  54
  55                 int rotation = ecore_evas_rotation_get(pEcoreEvas);
  56                 switch (rotation)
  57                 {
  58                 case 270:
  59                         {
  60                                 float _x = x;
  61                                 x = y;
  62                                 y = rootH - (int)_x;
  63                         }
  64
  65                         break;
  66                         switch(type)
  67                         {
  68                                 case Tizen::Ui::_ACCESSIBILITY_GESTURE_TYPE_FLICK_UP:
  69                                         type = Tizen::Ui::_ACCESSIBILITY_GESTURE_TYPE_FLICK_LEFT;
  70                                         break;
  71                                 case Tizen::Ui::_ACCESSIBILITY_GESTURE_TYPE_FLICK_DOWN:
  72                                         type = Tizen::Ui::_ACCESSIBILITY_GESTURE_TYPE_FLICK_RIGHT;
  73                                         break;
  74                                 case Tizen::Ui::_ACCESSIBILITY_GESTURE_TYPE_FLICK_LEFT:
  75                                         type = Tizen::Ui::_ACCESSIBILITY_GESTURE_TYPE_FLICK_DOWN;
  76                                         break;
  77                                 case Tizen::Ui::_ACCESSIBILITY_GESTURE_TYPE_FLICK_RIGHT:
  78                                         type = Tizen::Ui::_ACCESSIBILITY_GESTURE_TYPE_FLICK_UP;
  79                                         break;
  80                                 default:
  81                                         break;
  82                         }
  83                 case 180:
  84                         {
  85                                 float _x = x;
  86                                 float _y = y;
  87                                 x = rootW - (int)_x;
  88                                 y = rootH - (int)_y;
  89                         }
  90
  91                         switch(type)
  92                         {
  93                                 case Tizen::Ui::_ACCESSIBILITY_GESTURE_TYPE_FLICK_UP:
  94                                         type = Tizen::Ui::_ACCESSIBILITY_GESTURE_TYPE_FLICK_DOWN;
  95                                         break;
  96                                 case Tizen::Ui::_ACCESSIBILITY_GESTURE_TYPE_FLICK_DOWN:
  97                                         type = Tizen::Ui::_ACCESSIBILITY_GESTURE_TYPE_FLICK_UP;
  98                                         break;
  99                                 case Tizen::Ui::_ACCESSIBILITY_GESTURE_TYPE_FLICK_LEFT:
 100                                         type = Tizen::Ui::_ACCESSIBILITY_GESTURE_TYPE_FLICK_RIGHT;
 101                                         break;
 102                                 case Tizen::Ui::_ACCESSIBILITY_GESTURE_TYPE_FLICK_RIGHT:
 103                                         type = Tizen::Ui::_ACCESSIBILITY_GESTURE_TYPE_FLICK_LEFT;
 104                                         break;
 105                                 default:
 106                                         break;
 107                         }
 108                         break;
 109                 case 90:
 110                         {
 111                                 float _x = x;
 112                                 x = rootW - (int)y;
 113                                 y = _x;
 114                         }
 115                         switch(type)
 116                         {
 117                                 case Tizen::Ui::_ACCESSIBILITY_GESTURE_TYPE_FLICK_UP:
 118                                         type = Tizen::Ui::_ACCESSIBILITY_GESTURE_TYPE_FLICK_RIGHT;
 119                                         break;
 120                                 case Tizen::Ui::_ACCESSIBILITY_GESTURE_TYPE_FLICK_DOWN:
 121                                         type = Tizen::Ui::_ACCESSIBILITY_GESTURE_TYPE_FLICK_LEFT;
 122                                         break;
 123                                 case Tizen::Ui::_ACCESSIBILITY_GESTURE_TYPE_FLICK_LEFT:
 124                                         type = Tizen::Ui::_ACCESSIBILITY_GESTURE_TYPE_FLICK_UP;
 125                                         break;
 126                                 case Tizen::Ui::_ACCESSIBILITY_GESTURE_TYPE_FLICK_RIGHT:
 127                                         type = Tizen::Ui::_ACCESSIBILITY_GESTURE_TYPE_FLICK_DOWN;
 128                                         break;
 129                                 default:
 130                                         break;
 131                         }
 132                         break;
 133                 default:
 134                         break;
 135                 }
 136         }
 137 }
 138 */
 139 namespace Tizen { namespace Ui
 140 {
 141 _AccessibilityGesture::_AccessibilityGesture(_AccessibilityManager& manager)
 142 : __pManager(&manager)
 143 {
 144 }
 145
 146 _AccessibilityGesture::~_AccessibilityGesture(void)
 147 {
 148 }
 149
 150 bool
 151 _AccessibilityGesture::ProcessGesture(_AccessibilityGestureType type, float x, float y)
 152 {
 153         x = CoordinateSystem::ConvertToLogicalX(x);
 154         y = CoordinateSystem::ConvertToLogicalY(y);
 155         //ConvertTouchPosition(type, x,y);
 156         _AccessibilityManager::GetInstance()->ProcessGesture(type,Tizen::Graphics::FloatPoint(x, y));
 157         return true;
 158 }
 159 }} //Tizen::Ui
 160