dali/internal/window-system/macos/window-base-mac.mm

   1 /*
   2  * Copyright (c) 2021 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 #include "dali/public-api/adaptor-framework/window.h"
  19 #include "dali/public-api/events/wheel-event.h"
  20 #include <Carbon/Carbon.h>
  21 #import <Cocoa/Cocoa.h>
  22
  23 // CLASS HEADER
  24 #include <dali/internal/window-system/macos/window-base-mac.h>
  25
  26 // EXTERNAL_HEADERS
  27 #include <dali/public-api/object/any.h>
  28 #include <dali/integration-api/debug.h>
  29
  30 // INTERNAL HEADERS
  31 #include <dali/internal/window-system/common/window-impl.h>
  32 #include <dali/internal/window-system/common/window-render-surface.h>
  33 #include <dali/internal/window-system/common/window-system.h>
  34
  35 #include <cmath>
  36
  37 using Dali::Internal::Adaptor::WindowBaseCocoa;
  38
  39 // Angle is default selecting CGL as its backend and because
  40 // of that we are using NSOpenGLView. Ideally we should use
  41 // Metal as the backend. When this happends, we must change
  42 // the parent class to MTKView.
  43 @interface CocoaView : NSOpenGLView
  44 - (CocoaView *) initWithFrame:(NSRect) rect withImpl:(WindowBaseCocoa::Impl *) impl;
  45 - (BOOL) isFlipped;
  46 - (BOOL) wantsUpdateLayer;
  47 - (BOOL) acceptsFirstResponder;
  48 - (void) mouseDown:(NSEvent *) event;
  49 - (void) mouseUp:(NSEvent *) event;
  50 - (void) mouseDragged:(NSEvent *) event;
  51 - (void) keyDown:(NSEvent *) event;
  52 - (void) keyUp:(NSEvent *) event;
  53 - (void) drawRect:(NSRect) dirtyRect;
  54 - (void) prepareOpenGL;
  55 @end
  56
  57 @interface WindowDelegate : NSObject <NSWindowDelegate>
  58 - (WindowDelegate *) init:(WindowBaseCocoa::Impl *) impl;
  59 - (void) windowDidBecomeKey:(NSNotification *) notification;
  60 - (void) windowDidResignKey:(NSNotification *) notification;
  61 - (void) windowWillClose:(NSNotification *) notification;
  62 @end
  63
  64 namespace Dali::Internal::Adaptor
  65 {
  66
  67 namespace
  68 {
  69
  70 #if defined(DEBUG_ENABLED)
  71 Debug::Filter* gWindowBaseLogFilter = Debug::Filter::New( Debug::NoLogging, false, "LOG_WINDOW_BASE" );
  72 #endif
  73
  74 // Converts a y coordinate from top to bottom coordinate
  75 CGFloat BottomYCoordinate(CGFloat topYCoordinate, CGFloat windowHeight) noexcept
  76 {
  77   const auto screen = [NSScreen.mainScreen frame];
  78   return screen.size.height - windowHeight - topYCoordinate;
  79 }
  80
  81 NSRect PositionSizeToRect(const PositionSize &positionSize, bool flipped = false) noexcept
  82 {
  83   // positionSize assumes top-left coordinate system
  84   // Cocoa assumes bottom-left coordinate system
  85   // If NSView isFlipped method returns YES, then it uses top-left coordinate system
  86   const auto windowHeight = static_cast<CGFloat>(positionSize.height);
  87   const auto yGiven = static_cast<CGFloat>(positionSize.y);
  88
  89   CGFloat yWindow;
  90   if (flipped)
  91   {
  92     yWindow = yGiven;
  93   }
  94   else
  95   {
  96     yWindow = BottomYCoordinate(yGiven, windowHeight);
  97   }
  98
  99   return
 100   {
 101     .origin =
 102     {
 103       .x = static_cast<CGFloat>(positionSize.x),
 104       .y = yWindow
 105     },
 106     .size =
 107     {
 108       .width = static_cast<CGFloat>(positionSize.width),
 109       .height = windowHeight,
 110     },
 111   };
 112 }
 113
 114 } // unnamed namespace
 115
 116 struct WindowBaseCocoa::Impl final
 117 {
 118   NSWindow *mWindow;
 119   NSWindowController *mWinController;
 120   WindowBaseCocoa *mThis;
 121
 122   Impl(const Impl &rhs) = delete;
 123   Impl &operator<(const Impl &rhs) = delete;
 124   Impl(const Impl &&rhs) = delete;
 125   Impl &operator<(const Impl &&rhs) = delete;
 126
 127   Impl(
 128     WindowBaseCocoa *pThis,
 129     PositionSize positionSize,
 130     Any surface,
 131     bool isTransparent
 132   );
 133
 134   ~Impl();
 135
 136   void OnFocus(bool focus)
 137   {
 138     mThis->mFocusChangedSignal.Emit(focus);
 139   }
 140
 141   // Handle mouse events
 142   void OnMouse(NSEvent *event, PointState::Type state);
 143   void OnMouseWheel(NSEvent *event);
 144   void OnKey(NSEvent *event, Integration::KeyEvent::State keyState);
 145   void OnWindowDamaged(const NSRect &rect);
 146
 147   void OnRedraw(void)
 148   {
 149     mThis->mWindowRedrawRequestSignal.Emit();
 150   }
 151
 152 private:
 153   uint32_t GetKeyModifiers(NSEvent *event) const noexcept;
 154   std::string GetKeyName(NSEvent *event) const;
 155 };
 156
 157 WindowBaseCocoa::Impl::Impl(
 158   WindowBaseCocoa *pThis,
 159   PositionSize positionSize,
 160   Any surface,
 161   bool isTransparent
 162 ) : mThis(pThis)
 163 {
 164   constexpr NSUInteger style =
 165     NSWindowStyleMaskTitled
 166     | NSWindowStyleMaskClosable
 167     | NSWindowStyleMaskMiniaturizable
 168     | NSWindowStyleMaskResizable;
 169
 170   mWindow = [[NSWindow alloc] initWithContentRect:PositionSizeToRect(positionSize)
 171                                         styleMask:style
 172                                           backing:NSBackingStoreBuffered
 173                                             defer:NO];
 174
 175   mWindow.alphaValue = static_cast<CGFloat>(!isTransparent);
 176   mWinController = [[NSWindowController alloc] initWithWindow:mWindow];
 177
 178   mWindow.delegate = [[WindowDelegate alloc] init:this];
 179
 180   NSView *view = [[CocoaView alloc] initWithFrame:PositionSizeToRect(positionSize, true)
 181                                          withImpl:this];
 182   NSPoint origin{0, 0};
 183   [view setFrameOrigin:origin];
 184
 185   mWindow.contentView = view;
 186
 187   [mWindow makeKeyAndOrderFront:nil];
 188 }
 189
 190 WindowBaseCocoa::Impl::~Impl()
 191 {
 192   [mWinController close];
 193   [NSApp stop:nil];
 194 }
 195
 196 void WindowBaseCocoa::Impl::OnMouse(NSEvent *event, PointState::Type state)
 197 {
 198   Integration::Point point;
 199   point.SetDeviceId(event.deviceID);
 200   point.SetState(state);
 201   auto p = [event locationInWindow];
 202   auto [x, y] = [mWindow.contentView convertPoint:p fromView:nil];
 203   point.SetScreenPosition(Vector2(x, y));
 204   point.SetRadius(std::sqrt(x*x + y*y));
 205   point.SetPressure(event.pressure);
 206
 207   if (x == 0.0)
 208   {
 209     point.SetAngle(Degree(0.0));
 210   }
 211   else
 212   {
 213     point.SetAngle(Radian(std::atan(y/x)));
 214   }
 215
 216   DALI_LOG_INFO(
 217     gWindowBaseLogFilter,
 218     Debug::Verbose,
 219     "WindowBaseCocoa::Impl::OnMouse(%.1f, %.1f)\n",
 220     x,
 221     y
 222   );
 223
 224   // timestamp is given in seconds, the signal expects it in milliseconds
 225   mThis->mTouchEventSignal.Emit(point, event.timestamp * 1000);
 226 }
 227
 228 void WindowBaseCocoa::Impl::OnMouseWheel(NSEvent *event)
 229 {
 230   auto p = [event locationInWindow];
 231   auto [x, y] = [mWindow.contentView convertPoint:p fromView:nil];
 232
 233   const auto modifiers = GetKeyModifiers(event);
 234   const Vector2 vec(x, y);
 235   const auto timestamp = event.timestamp * 1000;
 236
 237   if (event.scrollingDeltaY)
 238   {
 239     Integration::WheelEvent wheelEvent(
 240       Integration::WheelEvent::MOUSE_WHEEL,
 241       0,
 242       modifiers,
 243       vec,
 244       event.scrollingDeltaY < 0 ? -1 : 1,
 245       timestamp
 246     );
 247
 248     mThis->mWheelEventSignal.Emit(wheelEvent);
 249   }
 250
 251   if (event.scrollingDeltaX)
 252   {
 253     Integration::WheelEvent wheelEvent(
 254       Integration::WheelEvent::MOUSE_WHEEL,
 255       0,
 256       modifiers,
 257       vec,
 258       event.scrollingDeltaX < 0 ? -1 : 1,
 259       timestamp
 260     );
 261
 262     mThis->mWheelEventSignal.Emit(wheelEvent);
 263   }
 264 }
 265
 266 void WindowBaseCocoa::Impl::OnKey(NSEvent *event, Integration::KeyEvent::State keyState)
 267 {
 268   const std::string empty;
 269
 270   Integration::KeyEvent keyEvent(
 271     GetKeyName(event),
 272     empty,
 273     [event.characters UTF8String],
 274     event.keyCode,
 275     GetKeyModifiers(event),
 276     event.timestamp * 1000,
 277     keyState,
 278     empty,
 279     empty,
 280     Device::Class::NONE,
 281     Device::Subclass::NONE
 282   );
 283
 284   DALI_LOG_INFO(
 285     gWindowBaseLogFilter,
 286     Debug::Verbose,
 287     "WindowBaseCocoa::Impl::OnKey(%s)\n",
 288     [event.characters UTF8String]
 289   );
 290
 291   mThis->mKeyEventSignal.Emit(keyEvent);
 292 }
 293
 294 void WindowBaseCocoa::Impl::OnWindowDamaged(const NSRect &rect)
 295 {
 296   const DamageArea area(
 297     rect.origin.x,
 298     rect.origin.y,
 299     rect.size.width,
 300     rect.size.height
 301   );
 302
 303   mThis->mWindowDamagedSignal.Emit(area);
 304 }
 305
 306 uint32_t WindowBaseCocoa::Impl::GetKeyModifiers(NSEvent *event) const noexcept
 307 {
 308   uint32_t modifiers = 0;
 309
 310   if (event.modifierFlags & NSEventModifierFlagShift)
 311   {
 312     modifiers |= 1;
 313   }
 314
 315   if (event.modifierFlags & NSEventModifierFlagControl)
 316   {
 317     modifiers |= 2;
 318   }
 319
 320   if (event.modifierFlags & NSEventModifierFlagCommand)
 321   {
 322     modifiers |= 4;
 323   }
 324
 325   return modifiers;
 326 }
 327
 328 std::string WindowBaseCocoa::Impl::GetKeyName(NSEvent *event) const
 329 {
 330   switch (event.keyCode)
 331   {
 332     case kVK_Control:     return "Control";
 333     case kVK_Shift:       return "Shift";
 334     case kVK_Delete:      return "Backspace";
 335     case kVK_Command:     return "Command";
 336     case kVK_Tab:         return "Tab";
 337     case kVK_Return:      return "Return";
 338     case kVK_Escape:      return "Escape";
 339     case kVK_Space:       return "Space";
 340     case kVK_LeftArrow:   return "Left";
 341     case kVK_UpArrow:     return "Up";
 342     case kVK_RightArrow:  return "Right";
 343     case kVK_DownArrow:   return "Down";
 344     case kVK_ANSI_0:      return "0";
 345     case kVK_ANSI_1:      return "1";
 346     case kVK_ANSI_2:      return "2";
 347     case kVK_ANSI_3:      return "3";
 348     case kVK_ANSI_4:      return "4";
 349     case kVK_ANSI_5:      return "5";
 350     case kVK_ANSI_6:      return "6";
 351     case kVK_ANSI_7:      return "7";
 352     case kVK_ANSI_8:      return "8";
 353     case kVK_ANSI_9:      return "9";
 354     default:              return [event.characters UTF8String];
 355   }
 356
 357   return "";
 358 }
 359
 360 WindowBaseCocoa::WindowBaseCocoa(PositionSize positionSize, Any surface, bool isTransparent)
 361   : mImpl(std::make_unique<Impl>(this, positionSize, surface, isTransparent))
 362 {
 363 }
 364
 365 WindowBaseCocoa::~WindowBaseCocoa()
 366 {
 367 }
 368
 369 Any WindowBaseCocoa::GetNativeWindow()
 370 {
 371   return mImpl->mWindow;
 372 }
 373
 374 int WindowBaseCocoa::GetNativeWindowId()
 375 {
 376   return mImpl->mWindow.windowNumber;
 377 }
 378
 379 EGLNativeWindowType WindowBaseCocoa::CreateEglWindow(int width, int height)
 380 {
 381   // XXX: this method is called from a secondary thread, but
 382   // we can only resize the window from the main thread
 383   //PositionSize size(0, 0, width, height);
 384   //Resize(size);
 385   return mImpl->mWindow.contentView.layer;
 386 }
 387
 388 void WindowBaseCocoa::DestroyEglWindow()
 389 {
 390 }
 391
 392 void WindowBaseCocoa::SetEglWindowRotation( int angle )
 393 {
 394 }
 395
 396 void WindowBaseCocoa::SetEglWindowBufferTransform( int angle )
 397 {
 398 }
 399
 400 void WindowBaseCocoa::SetEglWindowTransform( int angle )
 401 {
 402 }
 403
 404 void WindowBaseCocoa::ResizeEglWindow( PositionSize positionSize )
 405 {
 406   Resize(positionSize);
 407 }
 408
 409 bool WindowBaseCocoa::IsEglWindowRotationSupported()
 410 {
 411   return false;
 412 }
 413
 414 void WindowBaseCocoa::Move( PositionSize positionSize )
 415 {
 416   const NSPoint p = {
 417     .x = static_cast<CGFloat>(positionSize.x),
 418     .y = static_cast<CGFloat>(positionSize.y),
 419   };
 420
 421   [mImpl->mWindow setFrameTopLeftPoint:p];
 422 }
 423
 424 void WindowBaseCocoa::Resize( PositionSize positionSize )
 425 {
 426   auto r = mImpl->mWindow.frame;
 427   r.size.width = static_cast<CGFloat>(positionSize.width);
 428   r.size.height = static_cast<CGFloat>(positionSize.height);
 429   [mImpl->mWindow setFrame:r display:YES];
 430
 431   NSSize size =
 432   {
 433     .width = r.size.width,
 434     .height = r.size.height,
 435   };
 436
 437   [mImpl->mWindow.contentView setFrameSize:size];
 438
 439 }
 440
 441 void WindowBaseCocoa::MoveResize( PositionSize positionSize )
 442 {
 443   [mImpl->mWindow setFrame: PositionSizeToRect(positionSize) display:YES];
 444
 445   NSSize size =
 446   {
 447     .width = static_cast<CGFloat>(positionSize.width),
 448     .height = static_cast<CGFloat>(positionSize.height),
 449   };
 450
 451   [mImpl->mWindow.contentView setFrameSize:size];
 452 }
 453
 454 void WindowBaseCocoa::SetClass( const std::string& name, const std::string& className )
 455 {
 456 }
 457
 458 void WindowBaseCocoa::Raise()
 459 {
 460   [mImpl->mWindow orderFront:nil];
 461 }
 462
 463 void WindowBaseCocoa::Lower()
 464 {
 465   [mImpl->mWindow orderBack:nil];
 466 }
 467
 468 void WindowBaseCocoa::Activate()
 469 {
 470   [mImpl->mWinController showWindow:nil];
 471 }
 472
 473 void WindowBaseCocoa::Maximize(bool maximize)
 474 {
 475 }
 476
 477 bool WindowBaseCocoa::IsMaximized() const
 478 {
 479   return false;
 480 }
 481
 482 void WindowBaseCocoa::Minimize(bool minimize)
 483 {
 484 }
 485
 486 bool WindowBaseCocoa::IsMinimized() const
 487 {
 488   return false;
 489 }
 490
 491 void WindowBaseCocoa::SetAvailableAnlges( const std::vector< int >& angles )
 492 {
 493 }
 494
 495 void WindowBaseCocoa::SetPreferredAngle( int angle )
 496 {
 497 }
 498
 499 void WindowBaseCocoa::SetAcceptFocus( bool accept )
 500 {
 501 }
 502
 503 void WindowBaseCocoa::Show()
 504 {
 505   [mImpl->mWinController showWindow:nil];
 506 }
 507
 508 void WindowBaseCocoa::Hide()
 509 {
 510   [mImpl->mWindow orderOut:nil];
 511 }
 512
 513 unsigned int WindowBaseCocoa::GetSupportedAuxiliaryHintCount() const
 514 {
 515   return 0;
 516 }
 517
 518 std::string WindowBaseCocoa::GetSupportedAuxiliaryHint( unsigned int index ) const
 519 {
 520   return std::string();
 521 }
 522
 523 unsigned int WindowBaseCocoa::AddAuxiliaryHint( const std::string& hint, const std::string& value )
 524 {
 525   return 0;
 526 }
 527
 528 bool WindowBaseCocoa::RemoveAuxiliaryHint( unsigned int id )
 529 {
 530   return false;
 531 }
 532
 533 bool WindowBaseCocoa::SetAuxiliaryHintValue( unsigned int id, const std::string& value )
 534 {
 535   return false;
 536 }
 537
 538 std::string WindowBaseCocoa::GetAuxiliaryHintValue( unsigned int id ) const
 539 {
 540   return std::string();
 541 }
 542
 543 unsigned int WindowBaseCocoa::GetAuxiliaryHintId( const std::string& hint ) const
 544 {
 545   return 0;
 546 }
 547
 548 void WindowBaseCocoa::SetInputRegion( const Rect< int >& inputRegion )
 549 {
 550 }
 551
 552 void WindowBaseCocoa::SetType( Dali::WindowType type )
 553 {
 554 }
 555
 556 Dali::WindowType WindowBaseCocoa::GetType() const
 557 {
 558   return Dali::WindowType::NORMAL;
 559 }
 560
 561 WindowOperationResult WindowBaseCocoa::SetNotificationLevel( WindowNotificationLevel level )
 562 {
 563   return WindowOperationResult::NOT_SUPPORTED;
 564 }
 565
 566 WindowNotificationLevel WindowBaseCocoa::GetNotificationLevel() const
 567 {
 568   return WindowNotificationLevel::NONE;
 569 }
 570
 571 void WindowBaseCocoa::SetOpaqueState( bool opaque )
 572 {
 573 }
 574
 575 WindowOperationResult WindowBaseCocoa::SetScreenOffMode(WindowScreenOffMode screenOffMode)
 576 {
 577   return WindowOperationResult::NOT_SUPPORTED;
 578 }
 579
 580 WindowScreenOffMode WindowBaseCocoa::GetScreenOffMode() const
 581 {
 582   return WindowScreenOffMode::TIMEOUT;
 583 }
 584
 585 WindowOperationResult WindowBaseCocoa::SetBrightness( int brightness )
 586 {
 587   return WindowOperationResult::NOT_SUPPORTED;
 588 }
 589
 590 int WindowBaseCocoa::GetBrightness() const
 591 {
 592   return 0;
 593 }
 594
 595 bool WindowBaseCocoa::GrabKey( Dali::KEY key, KeyGrab::KeyGrabMode grabMode )
 596 {
 597   return false;
 598 }
 599
 600 bool WindowBaseCocoa::UngrabKey( Dali::KEY key )
 601 {
 602   return false;
 603 }
 604
 605 bool WindowBaseCocoa::GrabKeyList(
 606   const Dali::Vector< Dali::KEY >& key,
 607   const Dali::Vector< KeyGrab::KeyGrabMode >& grabMode,
 608   Dali::Vector< bool >& result
 609 )
 610 {
 611   return false;
 612 }
 613
 614 bool WindowBaseCocoa::UngrabKeyList(
 615   const Dali::Vector< Dali::KEY >& key,
 616   Dali::Vector< bool >& result
 617 )
 618 {
 619   return false;
 620 }
 621
 622 void WindowBaseCocoa::GetDpi(
 623   unsigned int& dpiHorizontal,
 624   unsigned int& dpiVertical
 625 )
 626 {
 627   auto *screen = [NSScreen mainScreen];
 628   NSSize res = [screen.deviceDescription[NSDeviceResolution] sizeValue];
 629   dpiHorizontal = res.width;
 630   dpiVertical = res.height;
 631 }
 632
 633 int WindowBaseCocoa::GetOrientation() const
 634 {
 635   return 0;
 636 }
 637
 638 int WindowBaseCocoa::GetScreenRotationAngle()
 639 {
 640   return 0;
 641 }
 642
 643 void WindowBaseCocoa::SetWindowRotationAngle( int degree )
 644 {
 645 }
 646
 647 void WindowBaseCocoa::WindowRotationCompleted( int degree, int width, int height )
 648 {
 649 }
 650
 651 void WindowBaseCocoa::SetTransparency( bool transparent )
 652 {
 653   mImpl->mWindow.alphaValue = static_cast<CGFloat>(!transparent);
 654 }
 655
 656 void WindowBaseCocoa::SetParent(WindowBase* parentWinBase, bool belowParent)
 657 {
 658   auto &parent = dynamic_cast<WindowBaseCocoa&>(*parentWinBase);
 659   [mImpl->mWindow setParentWindow:parent.mImpl->mWindow];
 660 }
 661
 662 int WindowBaseCocoa::CreateFrameRenderedSyncFence()
 663 {
 664   return -1;
 665 }
 666
 667 int WindowBaseCocoa::CreateFramePresentedSyncFence()
 668 {
 669   return -1;
 670 }
 671
 672 void WindowBaseCocoa::SetPositionSizeWithAngle(PositionSize positionSize, int angle)
 673 {
 674 }
 675
 676 void WindowBaseCocoa::InitializeIme()
 677 {
 678 }
 679
 680 void WindowBaseCocoa::ImeWindowReadyToRender()
 681 {
 682 }
 683
 684 void WindowBaseCocoa::RequestMoveToServer()
 685 {
 686 }
 687
 688 void WindowBaseCocoa::RequestResizeToServer(WindowResizeDirection direction)
 689 {
 690 }
 691
 692 void WindowBaseCocoa::EnableFloatingMode(bool enable)
 693 {
 694 }
 695
 696 bool WindowBaseCocoa::IsFloatingModeEnabled() const
 697 {
 698   return false;
 699 }
 700
 701 void WindowBaseCocoa::IncludeInputRegion(const Rect<int>& inputRegion)
 702 {
 703 }
 704
 705 void WindowBaseCocoa::ExcludeInputRegion(const Rect<int>& inputRegion)
 706 {
 707 }
 708
 709 } // namespace Dali::Internal::Adaptor
 710
 711 @implementation CocoaView
 712 {
 713   WindowBaseCocoa::Impl *mImpl;
 714 }
 715
 716 - (CocoaView *) initWithFrame:(NSRect) rect withImpl:(WindowBaseCocoa::Impl *) impl
 717 {
 718   self = [super initWithFrame:rect];
 719   if (self)
 720   {
 721     mImpl = impl;
 722     self.wantsLayer = YES;
 723     self.wantsBestResolutionOpenGLSurface = NO;
 724   }
 725
 726   return self;
 727 }
 728
 729 - (BOOL) isFlipped
 730 {
 731   return YES;
 732 }
 733
 734 - (BOOL) wantsUpdateLayer
 735 {
 736   return YES;
 737 }
 738
 739 - (BOOL) acceptsFirstResponder
 740 {
 741   return YES;
 742 }
 743
 744 - (void) mouseDown:(NSEvent *) event
 745 {
 746   mImpl->OnMouse(event, Dali::PointState::DOWN);
 747 }
 748
 749 - (void) mouseUp:(NSEvent *) event
 750 {
 751   mImpl->OnMouse(event, Dali::PointState::UP);
 752 }
 753
 754 - (void) mouseDragged:(NSEvent *) event
 755 {
 756   mImpl->OnMouse(event, Dali::PointState::MOTION);
 757 }
 758
 759 - (void) keyDown:(NSEvent *) event
 760 {
 761   mImpl->OnKey(event, Dali::Integration::KeyEvent::DOWN);
 762 }
 763
 764 - (void) keyUp:(NSEvent *) event
 765 {
 766   mImpl->OnKey(event, Dali::Integration::KeyEvent::UP);
 767 }
 768
 769 - (void) drawRect:(NSRect) dirtyRect
 770 {
 771   DALI_LOG_INFO(
 772     Dali::Internal::Adaptor::gWindowBaseLogFilter,
 773     Debug::Verbose,
 774     "-[CocoaView drawRect:(%.1f, %.1f, %.1f, %.1f)]\n",
 775     dirtyRect.origin.x,
 776     dirtyRect.origin.y,
 777     dirtyRect.size.width,
 778     dirtyRect.size.height
 779   );
 780
 781   mImpl->OnWindowDamaged(dirtyRect);
 782 }
 783
 784 - (void) prepareOpenGL
 785 {
 786   auto ctx = CGLGetCurrentContext();
 787   DALI_ASSERT_ALWAYS(ctx);
 788
 789   // Enable multithreading
 790   if (auto err = CGLEnable(ctx, kCGLCEMPEngine); err != kCGLNoError)
 791   {
 792     DALI_LOG_ERROR("%s - %s", __PRETTY_FUNCTION__, CGLErrorString(err));
 793   }
 794 }
 795 @end
 796
 797 @implementation WindowDelegate
 798 {
 799   WindowBaseCocoa::Impl *mImpl;
 800 }
 801
 802 - (WindowDelegate *) init:(Dali::Internal::Adaptor::WindowBaseCocoa::Impl *) impl
 803 {
 804   self = [super init];
 805   if (self)
 806   {
 807     mImpl = impl;
 808   }
 809   return self;
 810 }
 811
 812 - (void) windowDidBecomeKey:(NSNotification *) notification
 813 {
 814   mImpl->OnFocus(true);
 815 }
 816
 817 - (void) windowDidResignKey:(NSNotification *) notification
 818 {
 819   mImpl->OnFocus(false);
 820 }
 821
 822 - (void) windowWillClose:(NSNotification *) notification
 823 {
 824   [NSApp stop:nil];
 825 }
 826 @end
 827