dali/internal/window-system/windows/window-base-win.cpp

   1 /*
   2  * Copyright (c) 2018 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/window-system/windows/window-base-win.h>
  20
  21 // EXTERNAL_HEADERS
  22 #include <dali/public-api/object/any.h>
  23 #include <dali/integration-api/debug.h>
  24
  25 // INTERNAL HEADERS
  26 #include <dali/internal/window-system/common/window-impl.h>
  27 #include <dali/internal/window-system/common/window-render-surface.h>
  28 #include <dali/internal/window-system/common/window-system.h>
  29
  30 namespace Dali
  31 {
  32
  33 namespace Internal
  34 {
  35
  36 namespace Adaptor
  37 {
  38
  39 namespace
  40 {
  41
  42 const Device::Class::Type DEFAULT_DEVICE_CLASS = Device::Class::NONE;
  43 const Device::Subclass::Type DEFAULT_DEVICE_SUBCLASS = Device::Subclass::NONE;
  44
  45 const unsigned int PRIMARY_TOUCH_BUTTON_ID( 1 );
  46
  47 #if defined(DEBUG_ENABLED)
  48 Debug::Filter* gWindowBaseLogFilter = Debug::Filter::New( Debug::NoLogging, false, "LOG_WINDOW_BASE" );
  49 #endif
  50
  51 } // unnamed namespace
  52
  53 WindowBaseWin::WindowBaseWin( Dali::PositionSize positionSize, Any surface, bool isTransparent )
  54 : mWin32Window( 0 ),
  55   mOwnSurface( false ),
  56   mIsTransparent( false ), // Should only be set to true once we actually create a transparent window regardless of what isTransparent is.
  57   mRotationAppSet( false )
  58 {
  59   Initialize( positionSize, surface, isTransparent );
  60 }
  61
  62 WindowBaseWin::~WindowBaseWin()
  63 {
  64   WindowsPlatformImplementation::PostWinMessage( WM_CLOSE, 0, 0, mWin32Window );
  65 }
  66
  67 void WindowBaseWin::Initialize( PositionSize positionSize, Any surface, bool isTransparent )
  68 {
  69   // see if there is a surface in Any surface
  70   unsigned int surfaceId = GetSurfaceId( surface );
  71
  72   // if the surface is empty, create a new one.
  73   if( surfaceId == 0 )
  74   {
  75     // we own the surface about to created
  76     mOwnSurface = true;
  77     CreateWinWindow( positionSize, isTransparent );
  78   }
  79   else
  80   {
  81     // XLib should already be initialized so no point in calling XInitThreads
  82     mWin32Window = static_cast< WinWindowHandle >( surfaceId );
  83   }
  84
  85   WindowsPlatformImplementation::SetListener( MakeCallback( this, &WindowBaseWin::EventEntry ) );
  86 }
  87
  88 void WindowBaseWin::OnDeleteRequest()
  89 {
  90   mDeleteRequestSignal.Emit();
  91 }
  92
  93 void WindowBaseWin::OnFocusIn( int type, TWinEventInfo *event )
  94 {
  95 }
  96
  97 void WindowBaseWin::OnFocusOut( int type, TWinEventInfo *event )
  98 {
  99 }
 100
 101 void WindowBaseWin::OnWindowDamaged( int type, TWinEventInfo *event )
 102 {
 103   Event_Mouse_Button* windowDamagedEvent( (Event_Mouse_Button*)event );\r
 104 \r
 105   if( windowDamagedEvent->window == mWin32Window )\r
 106   {\r
 107     DamageArea area;\r
 108     area.x = 0;\r
 109     area.y = 0;\r
 110     WindowSystem::GetScreenSize( area.width, area.height );\r
 111 \r
 112     mWindowDamagedSignal.Emit( area );\r
 113   }\r
 114 }
 115
 116 void WindowBaseWin::OnMouseButtonDown( int type, TWinEventInfo *event )
 117 {
 118   Event_Mouse_Button touchEvent = *((Event_Mouse_Button*)event);
 119   touchEvent.timestamp = GetTickCount();
 120   touchEvent.x = LOWORD( event->lParam );\r
 121   touchEvent.y = HIWORD( event->lParam );\r
 122   touchEvent.multi.device = DEVICE_MOUSE;
 123
 124   if( touchEvent.window == mWin32Window )
 125   {
 126     PointState::Type state ( PointState::DOWN );
 127
 128     Integration::Point point;
 129     point.SetDeviceId( touchEvent.multi.device );
 130     point.SetState( state );
 131     point.SetScreenPosition( Vector2( touchEvent.x, touchEvent.y + WindowsPlatformImplementation::GetEdgeHeight() ) );
 132     point.SetRadius( touchEvent.multi.radius, Vector2( touchEvent.multi.radius_x, touchEvent.multi.radius_y ) );
 133     point.SetPressure( touchEvent.multi.pressure );
 134     point.SetAngle( Degree( touchEvent.multi.angle ) );
 135
 136     mTouchEventSignal.Emit( point, touchEvent.timestamp );
 137   }
 138 }
 139
 140 void WindowBaseWin::OnMouseButtonUp( int type, TWinEventInfo *event )
 141 {
 142   Event_Mouse_Button touchEvent = *( (Event_Mouse_Button*)event );
 143   touchEvent.timestamp = GetTickCount();
 144   touchEvent.x = LOWORD( event->lParam );\r
 145   touchEvent.y = HIWORD( event->lParam );\r
 146   touchEvent.multi.device = DEVICE_MOUSE;
 147
 148   if( touchEvent.window == mWin32Window )
 149   {
 150     PointState::Type state( PointState::UP );
 151
 152     Integration::Point point;
 153     point.SetDeviceId( touchEvent.multi.device );
 154     point.SetState( state );
 155     point.SetScreenPosition( Vector2( touchEvent.x, touchEvent.y + WindowsPlatformImplementation::GetEdgeHeight() ) );
 156     point.SetRadius( touchEvent.multi.radius, Vector2( touchEvent.multi.radius_x, touchEvent.multi.radius_y ) );
 157     point.SetPressure( touchEvent.multi.pressure );
 158     point.SetAngle( Degree( touchEvent.multi.angle ) );
 159
 160     mTouchEventSignal.Emit( point, touchEvent.timestamp );
 161   }
 162 }
 163
 164 void WindowBaseWin::OnMouseButtonMove( int type, TWinEventInfo *event )
 165 {
 166   Event_Mouse_Button touchEvent = *((Event_Mouse_Button*)event);
 167   touchEvent.timestamp = GetTickCount();
 168   touchEvent.x = LOWORD( event->lParam );\r
 169   touchEvent.y = HIWORD( event->lParam );\r
 170   touchEvent.multi.device = DEVICE_MOUSE;
 171
 172   if( touchEvent.window == mWin32Window )
 173   {
 174     PointState::Type state( PointState::MOTION );
 175
 176     Integration::Point point;
 177     point.SetDeviceId( touchEvent.multi.device );
 178     point.SetState( state );
 179     point.SetScreenPosition( Vector2( touchEvent.x, touchEvent.y + WindowsPlatformImplementation::GetEdgeHeight() ) );
 180     point.SetRadius( touchEvent.multi.radius, Vector2( touchEvent.multi.radius_x, touchEvent.multi.radius_y ) );
 181     point.SetPressure( touchEvent.multi.pressure );
 182     point.SetAngle( Degree( touchEvent.multi.angle ) );
 183
 184     mTouchEventSignal.Emit( point, touchEvent.timestamp );
 185   }
 186 }
 187
 188 void WindowBaseWin::OnMouseWheel( int type, TWinEventInfo *event )
 189 {
 190   Event_Mouse_Wheel mouseWheelEvent = *((Event_Mouse_Wheel*)( event ));
 191
 192   if( mouseWheelEvent.window == mWin32Window )
 193   {
 194     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseWin::OnMouseWheel: direction: %d, modifiers: %d, x: %d, y: %d, z: %d\n", mouseWheelEvent.direction, mouseWheelEvent.modifiers, mouseWheelEvent.x, mouseWheelEvent.y, mouseWheelEvent.z );
 195
 196     WheelEvent wheelEvent( WheelEvent::MOUSE_WHEEL, mouseWheelEvent.direction, mouseWheelEvent.modifiers, Vector2( mouseWheelEvent.x, mouseWheelEvent.y ), mouseWheelEvent.z, mouseWheelEvent.timestamp );
 197
 198     mWheelEventSignal.Emit( wheelEvent );
 199   }
 200 }
 201
 202 void WindowBaseWin::OnKeyDown( int type, TWinEventInfo *event )
 203 {
 204   if( event->mWindow == mWin32Window )
 205   {
 206     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseWin::OnKeyDown\n" );
 207
 208     int keyCode = event->wParam;
 209     std::string keyName( WindowsPlatformImplementation::GetKeyName( keyCode ) );
 210     std::string keyString;
 211     std::string emptyString;
 212
 213     int modifier( 0 );
 214     unsigned long time( 0 );
 215
 216     // Ensure key event string is not NULL as keys like SHIFT have a null string.
 217     keyString.push_back( event->wParam );
 218
 219     Integration::KeyEvent keyEvent( keyName, emptyString, keyString, keyCode, modifier, time, Integration::KeyEvent::Down, emptyString, emptyString, DEFAULT_DEVICE_CLASS, DEFAULT_DEVICE_SUBCLASS );
 220
 221     mKeyEventSignal.Emit( keyEvent );
 222   }
 223 }
 224
 225 void WindowBaseWin::OnKeyUp( int type, TWinEventInfo *event )
 226 {
 227   if( event->mWindow == mWin32Window )
 228   {
 229     DALI_LOG_INFO( gWindowBaseLogFilter, Debug::General, "WindowBaseWin::OnKeyDown\n" );
 230
 231     int keyCode = event->wParam;
 232     std::string keyName( WindowsPlatformImplementation::GetKeyName( keyCode ) );
 233     std::string keyString;
 234     std::string emptyString;
 235
 236     int modifier( 0 );
 237     unsigned long time( 0 );
 238
 239     // Ensure key event string is not NULL as keys like SHIFT have a null string.
 240     keyString.push_back( event->wParam );
 241
 242     Integration::KeyEvent keyEvent( keyName, emptyString, keyString, keyCode, modifier, time, Integration::KeyEvent::Down, emptyString, emptyString, DEFAULT_DEVICE_CLASS, DEFAULT_DEVICE_SUBCLASS );
 243
 244     mKeyEventSignal.Emit( keyEvent );
 245   }
 246 }
 247
 248 Any WindowBaseWin::GetNativeWindow()
 249 {
 250   return mWin32Window;
 251 }
 252
 253 int WindowBaseWin::GetNativeWindowId()
 254 {
 255   return mWin32Window;
 256 }
 257
 258 EGLNativeWindowType WindowBaseWin::CreateEglWindow( int width, int height )
 259 {
 260   return reinterpret_cast< EGLNativeWindowType >( mWin32Window );
 261 }
 262
 263 void WindowBaseWin::DestroyEglWindow()
 264 {
 265 }
 266
 267 void WindowBaseWin::SetEglWindowRotation( int angle )
 268 {
 269 }
 270
 271 void WindowBaseWin::SetEglWindowBufferTransform( int angle )
 272 {
 273 }
 274
 275 void WindowBaseWin::SetEglWindowTransform( int angle )
 276 {
 277 }
 278
 279 void WindowBaseWin::ResizeEglWindow( PositionSize positionSize )
 280 {
 281 }
 282
 283 bool WindowBaseWin::IsEglWindowRotationSupported()
 284 {
 285   return false;
 286 }
 287
 288 void WindowBaseWin::Move( PositionSize positionSize )
 289 {
 290 }
 291
 292 void WindowBaseWin::Resize( PositionSize positionSize )
 293 {
 294 }
 295
 296 void WindowBaseWin::MoveResize( PositionSize positionSize )
 297 {
 298 }
 299
 300 void WindowBaseWin::SetClass( const std::string& name, const std::string& className )
 301 {
 302 }
 303
 304 void WindowBaseWin::Raise()
 305 {
 306 }
 307
 308 void WindowBaseWin::Lower()
 309 {
 310 }
 311
 312 void WindowBaseWin::Activate()
 313 {
 314 }
 315
 316 void WindowBaseWin::SetAvailableOrientations( const std::vector< Dali::Window::WindowOrientation >& orientations )
 317 {
 318 }
 319
 320 void WindowBaseWin::SetPreferredOrientation( Dali::Window::WindowOrientation orientation )
 321 {
 322 }
 323
 324 void WindowBaseWin::SetAcceptFocus( bool accept )
 325 {
 326 }
 327
 328 void WindowBaseWin::Show()
 329 {
 330 }
 331
 332 void WindowBaseWin::Hide()
 333 {
 334 }
 335
 336 unsigned int WindowBaseWin::GetSupportedAuxiliaryHintCount() const
 337 {
 338   return 0;
 339 }
 340
 341 std::string WindowBaseWin::GetSupportedAuxiliaryHint( unsigned int index ) const
 342 {
 343   return std::string();
 344 }
 345
 346 unsigned int WindowBaseWin::AddAuxiliaryHint( const std::string& hint, const std::string& value )
 347 {
 348   return 0;
 349 }
 350
 351 bool WindowBaseWin::RemoveAuxiliaryHint( unsigned int id )
 352 {
 353   return false;
 354 }
 355
 356 bool WindowBaseWin::SetAuxiliaryHintValue( unsigned int id, const std::string& value )
 357 {
 358   return false;
 359 }
 360
 361 std::string WindowBaseWin::GetAuxiliaryHintValue( unsigned int id ) const
 362 {
 363   return std::string();
 364 }
 365
 366 unsigned int WindowBaseWin::GetAuxiliaryHintId( const std::string& hint ) const
 367 {
 368   return 0;
 369 }
 370
 371 void WindowBaseWin::SetInputRegion( const Rect< int >& inputRegion )
 372 {
 373 }
 374
 375 void WindowBaseWin::SetType( Dali::Window::Type type )
 376 {
 377 }
 378
 379 bool WindowBaseWin::SetNotificationLevel( Dali::Window::NotificationLevel::Type level )
 380 {
 381   return false;
 382 }
 383
 384 Dali::Window::NotificationLevel::Type WindowBaseWin::GetNotificationLevel() const
 385 {
 386   return Dali::Window::NotificationLevel::NONE;
 387 }
 388
 389 void WindowBaseWin::SetOpaqueState( bool opaque )
 390 {
 391 }
 392
 393 bool WindowBaseWin::SetScreenOffMode(Dali::Window::ScreenOffMode::Type screenOffMode)
 394 {
 395   return false;
 396 }
 397
 398 Dali::Window::ScreenOffMode::Type WindowBaseWin::GetScreenOffMode() const
 399 {
 400   return Dali::Window::ScreenOffMode::TIMEOUT;
 401 }
 402
 403 bool WindowBaseWin::SetBrightness( int brightness )
 404 {
 405   return false;
 406 }
 407
 408 int WindowBaseWin::GetBrightness() const
 409 {
 410   return 0;
 411 }
 412
 413 bool WindowBaseWin::GrabKey( Dali::KEY key, KeyGrab::KeyGrabMode grabMode )
 414 {
 415   return false;
 416 }
 417
 418 bool WindowBaseWin::UngrabKey( Dali::KEY key )
 419 {
 420   return false;
 421 }
 422
 423 bool WindowBaseWin::GrabKeyList( const Dali::Vector< Dali::KEY >& key, const Dali::Vector< KeyGrab::KeyGrabMode >& grabMode, Dali::Vector< bool >& result )
 424 {
 425   return false;
 426 }
 427
 428 bool WindowBaseWin::UngrabKeyList( const Dali::Vector< Dali::KEY >& key, Dali::Vector< bool >& result )
 429 {
 430   return false;
 431 }
 432
 433 void WindowBaseWin::GetDpi( unsigned int& dpiHorizontal, unsigned int& dpiVertical )
 434 {
 435   // calculate DPI
 436   float xres, yres;
 437
 438   //// 1 inch = 25.4 millimeters
 439   WindowsPlatformImplementation::GetDPI( mWin32Window, xres, yres );
 440
 441   xres *= 1.5f;
 442   yres *= 1.5f;
 443
 444   dpiHorizontal = static_cast<int>( xres + 0.5f );  // rounding
 445   dpiVertical = static_cast<int>( yres + 0.5f );
 446 }
 447
 448 int WindowBaseWin::GetScreenRotationAngle()
 449 {
 450   return 0;
 451 }
 452
 453 void WindowBaseWin::SetWindowRotationAngle( int degree )
 454 {
 455 }
 456
 457 void WindowBaseWin::WindowRotationCompleted( int degree, int width, int height )
 458 {
 459 }
 460
 461 void WindowBaseWin::SetTransparency( bool transparent )
 462 {
 463 }
 464
 465 unsigned int WindowBaseWin::GetSurfaceId( Any surface ) const
 466 {
 467   unsigned int surfaceId = 0;
 468
 469   if ( surface.Empty() == false )
 470   {
 471     // check we have a valid type
 472     DALI_ASSERT_ALWAYS( (surface.GetType() == typeid ( WinWindowHandle ) )
 473                         && "Surface type is invalid" );
 474
 475     surfaceId = AnyCast< WinWindowHandle >( surface );
 476   }
 477   return surfaceId;
 478 }
 479
 480 void WindowBaseWin::CreateWinWindow( PositionSize positionSize, bool isTransparent )
 481 {
 482   long hWnd = WindowsPlatformImplementation::CreateHwnd( "Demo", "Demo", positionSize.x, positionSize.y, positionSize.width, positionSize.height, NULL );\r
 483 \r
 484   WindowsPlatformImplementation::ShowWindow( hWnd );\r
 485 \r
 486   mWin32Window = (WinWindowHandle)hWnd;\r
 487   DALI_ASSERT_ALWAYS( mWin32Window != 0 && "There is no Windows window" );
 488 }
 489
 490 void WindowBaseWin::EventEntry( TWinEventInfo *event )
 491 {
 492   unsigned int uMsg = event->uMsg;
 493
 494   switch( uMsg )\r
 495   {\r
 496   case WM_SETFOCUS:\r
 497   {\r
 498     OnFocusIn( uMsg, event );\r
 499     break;\r
 500   }\r
 501 \r
 502   case WM_KILLFOCUS:\r
 503   {\r
 504     OnFocusOut( uMsg, event );\r
 505     break;\r
 506   }\r
 507 \r
 508   case WM_PAINT:\r
 509   {\r
 510     OnWindowDamaged( uMsg, event );\r
 511     break;\r
 512   }\r
 513 \r
 514   case WM_LBUTTONDOWN:\r
 515   {\r
 516     OnMouseButtonDown( uMsg, event );\r
 517     break;\r
 518   }\r
 519 \r
 520   case WM_LBUTTONUP:\r
 521   {\r
 522     OnMouseButtonUp( uMsg, event );\r
 523     break;\r
 524   }\r
 525 \r
 526   case WM_MOUSEMOVE:\r
 527   {\r
 528     OnMouseButtonMove( uMsg, event );\r
 529     break;\r
 530   }\r
 531 \r
 532   case WM_MOUSEWHEEL:\r
 533   {\r
 534     OnMouseWheel( uMsg, event );\r
 535     break;\r
 536   }\r
 537 \r
 538   case WM_KEYDOWN:\r
 539   {\r
 540     OnKeyDown( uMsg, event );\r
 541     break;\r
 542   }\r
 543 \r
 544   case WM_KEYUP:\r
 545   {\r
 546     OnKeyUp( uMsg, event );\r
 547     break;\r
 548   }\r
 549 \r
 550   default:
 551     break;\r
 552   }
 553 }
 554
 555 } // namespace Adaptor
 556
 557 } // namespace Internal
 558
 559 } // namespace Dali
 560