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   mWindowImpl.PostWinMessage( WM_CLOSE, 0, 0 );
  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   mWindowImpl.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 );
 104
 105   if( windowDamagedEvent->window == mWin32Window )
 106   {
 107     DamageArea area;
 108     area.x = 0;
 109     area.y = 0;
 110     WindowSystem::GetScreenSize( area.width, area.height );
 111
 112     mWindowDamagedSignal.Emit( area );
 113   }
 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 );
 121   touchEvent.y = HIWORD( event->lParam );
 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 + mWindowImpl.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 );
 145   touchEvent.y = HIWORD( event->lParam );
 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 + mWindowImpl.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 );
 169   touchEvent.y = HIWORD( event->lParam );
 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 + mWindowImpl.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::Up, 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   ::SetWindowPos( (HWND)mWin32Window, NULL, positionSize.x, positionSize.y, positionSize.width, positionSize.height, SWP_SHOWWINDOW );
 295 }
 296
 297 void WindowBaseWin::MoveResize( PositionSize positionSize )
 298 {
 299 }
 300
 301 void WindowBaseWin::SetClass( const std::string& name, const std::string& className )
 302 {
 303 }
 304
 305 void WindowBaseWin::Raise()
 306 {
 307 }
 308
 309 void WindowBaseWin::Lower()
 310 {
 311 }
 312
 313 void WindowBaseWin::Activate()
 314 {
 315 }
 316
 317 void WindowBaseWin::SetAvailableAnlges( const std::vector< int >& angles )
 318 {
 319 }
 320
 321 void WindowBaseWin::SetPreferredAngle( int angle )
 322 {
 323 }
 324
 325 void WindowBaseWin::SetAcceptFocus( bool accept )
 326 {
 327 }
 328
 329 void WindowBaseWin::Show()
 330 {
 331 }
 332
 333 void WindowBaseWin::Hide()
 334 {
 335 }
 336
 337 unsigned int WindowBaseWin::GetSupportedAuxiliaryHintCount() const
 338 {
 339   return 0;
 340 }
 341
 342 std::string WindowBaseWin::GetSupportedAuxiliaryHint( unsigned int index ) const
 343 {
 344   return std::string();
 345 }
 346
 347 unsigned int WindowBaseWin::AddAuxiliaryHint( const std::string& hint, const std::string& value )
 348 {
 349   return 0;
 350 }
 351
 352 bool WindowBaseWin::RemoveAuxiliaryHint( unsigned int id )
 353 {
 354   return false;
 355 }
 356
 357 bool WindowBaseWin::SetAuxiliaryHintValue( unsigned int id, const std::string& value )
 358 {
 359   return false;
 360 }
 361
 362 std::string WindowBaseWin::GetAuxiliaryHintValue( unsigned int id ) const
 363 {
 364   return std::string();
 365 }
 366
 367 unsigned int WindowBaseWin::GetAuxiliaryHintId( const std::string& hint ) const
 368 {
 369   return 0;
 370 }
 371
 372 void WindowBaseWin::SetInputRegion( const Rect< int >& inputRegion )
 373 {
 374 }
 375
 376 void WindowBaseWin::SetType( Dali::Window::Type type )
 377 {
 378 }
 379
 380 bool WindowBaseWin::SetNotificationLevel( Dali::Window::NotificationLevel::Type level )
 381 {
 382   return false;
 383 }
 384
 385 Dali::Window::NotificationLevel::Type WindowBaseWin::GetNotificationLevel() const
 386 {
 387   return Dali::Window::NotificationLevel::NONE;
 388 }
 389
 390 void WindowBaseWin::SetOpaqueState( bool opaque )
 391 {
 392 }
 393
 394 bool WindowBaseWin::SetScreenOffMode(Dali::Window::ScreenOffMode::Type screenOffMode)
 395 {
 396   return false;
 397 }
 398
 399 Dali::Window::ScreenOffMode::Type WindowBaseWin::GetScreenOffMode() const
 400 {
 401   return Dali::Window::ScreenOffMode::TIMEOUT;
 402 }
 403
 404 bool WindowBaseWin::SetBrightness( int brightness )
 405 {
 406   return false;
 407 }
 408
 409 int WindowBaseWin::GetBrightness() const
 410 {
 411   return 0;
 412 }
 413
 414 bool WindowBaseWin::GrabKey( Dali::KEY key, KeyGrab::KeyGrabMode grabMode )
 415 {
 416   return false;
 417 }
 418
 419 bool WindowBaseWin::UngrabKey( Dali::KEY key )
 420 {
 421   return false;
 422 }
 423
 424 bool WindowBaseWin::GrabKeyList( const Dali::Vector< Dali::KEY >& key, const Dali::Vector< KeyGrab::KeyGrabMode >& grabMode, Dali::Vector< bool >& result )
 425 {
 426   return false;
 427 }
 428
 429 bool WindowBaseWin::UngrabKeyList( const Dali::Vector< Dali::KEY >& key, Dali::Vector< bool >& result )
 430 {
 431   return false;
 432 }
 433
 434 void WindowBaseWin::GetDpi( unsigned int& dpiHorizontal, unsigned int& dpiVertical )
 435 {
 436   // calculate DPI
 437   float xres, yres;
 438
 439   //// 1 inch = 25.4 millimeters
 440   mWindowImpl.GetDPI( xres, yres );
 441
 442   xres *= 1.5f;
 443   yres *= 1.5f;
 444
 445   dpiHorizontal = static_cast<int>( xres + 0.5f );  // rounding
 446   dpiVertical = static_cast<int>( yres + 0.5f );
 447 }
 448
 449 int WindowBaseWin::GetScreenRotationAngle()
 450 {
 451   return 0;
 452 }
 453
 454 void WindowBaseWin::SetWindowRotationAngle( int degree )
 455 {
 456 }
 457
 458 int WindowBaseWin::GetWindowRotationAngle()
 459 {
 460 }
 461
 462 void WindowBaseWin::WindowRotationCompleted( int degree, int width, int height )
 463 {
 464 }
 465
 466 void WindowBaseWin::SetTransparency( bool transparent )
 467 {
 468 }
 469
 470 int WindowBaseWin::GetOrientation() const
 471 {
 472 }
 473
 474 unsigned int WindowBaseWin::GetSurfaceId( Any surface ) const
 475 {
 476   unsigned int surfaceId = 0;
 477
 478   if ( surface.Empty() == false )
 479   {
 480     // check we have a valid type
 481     DALI_ASSERT_ALWAYS( (surface.GetType() == typeid ( WinWindowHandle ) )
 482                         && "Surface type is invalid" );
 483
 484     surfaceId = AnyCast< WinWindowHandle >( surface );
 485   }
 486   return surfaceId;
 487 }
 488
 489 void WindowBaseWin::CreateWinWindow( PositionSize positionSize, bool isTransparent )
 490 {
 491   long hWnd = mWindowImpl.CreateHwnd( "Demo", "Demo", positionSize.x, positionSize.y, positionSize.width, positionSize.height, NULL );
 492
 493   mWin32Window = (WinWindowHandle)hWnd;
 494   DALI_ASSERT_ALWAYS( mWin32Window != 0 && "There is no Windows window" );
 495 }
 496
 497 void WindowBaseWin::EventEntry( TWinEventInfo *event )
 498 {
 499   unsigned int uMsg = event->uMsg;
 500
 501   switch( uMsg )
 502   {
 503   case WM_SETFOCUS:
 504   {
 505     OnFocusIn( uMsg, event );
 506     break;
 507   }
 508
 509   case WM_KILLFOCUS:
 510   {
 511     OnFocusOut( uMsg, event );
 512     break;
 513   }
 514
 515   case WM_PAINT:
 516   {
 517     OnWindowDamaged( uMsg, event );
 518     break;
 519   }
 520
 521   case WM_LBUTTONDOWN:
 522   {
 523     OnMouseButtonDown( uMsg, event );
 524     break;
 525   }
 526
 527   case WM_LBUTTONUP:
 528   {
 529     OnMouseButtonUp( uMsg, event );
 530     break;
 531   }
 532
 533   case WM_MOUSEMOVE:
 534   {
 535     OnMouseButtonMove( uMsg, event );
 536     break;
 537   }
 538
 539   case WM_MOUSEWHEEL:
 540   {
 541     OnMouseWheel( uMsg, event );
 542     break;
 543   }
 544
 545   case WM_KEYDOWN:
 546   {
 547     OnKeyDown( uMsg, event );
 548     break;
 549   }
 550
 551   case WM_KEYUP:
 552   {
 553     OnKeyUp( uMsg, event );
 554     break;
 555   }
 556
 557   default:
 558     break;
 559   }
 560 }
 561
 562 void WindowBaseWin::SetParent( WindowBase* parentWinBase )
 563 {
 564
 565 }
 566
 567 } // namespace Adaptor
 568
 569 } // namespace Internal
 570
 571 } // namespace Dali
 572