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::SetAvailableAnlges( const std::vector< int >& angles )
 474 {
 475 }
 476
 477 void WindowBaseCocoa::SetPreferredAngle( int angle )
 478 {
 479 }
 480
 481 void WindowBaseCocoa::SetAcceptFocus( bool accept )
 482 {
 483 }
 484
 485 void WindowBaseCocoa::Show()
 486 {
 487   [mImpl->mWinController showWindow:nil];
 488 }
 489
 490 void WindowBaseCocoa::Hide()
 491 {
 492   [mImpl->mWindow orderOut:nil];
 493 }
 494
 495 unsigned int WindowBaseCocoa::GetSupportedAuxiliaryHintCount() const
 496 {
 497   return 0;
 498 }
 499
 500 std::string WindowBaseCocoa::GetSupportedAuxiliaryHint( unsigned int index ) const
 501 {
 502   return std::string();
 503 }
 504
 505 unsigned int WindowBaseCocoa::AddAuxiliaryHint( const std::string& hint, const std::string& value )
 506 {
 507   return 0;
 508 }
 509
 510 bool WindowBaseCocoa::RemoveAuxiliaryHint( unsigned int id )
 511 {
 512   return false;
 513 }
 514
 515 bool WindowBaseCocoa::SetAuxiliaryHintValue( unsigned int id, const std::string& value )
 516 {
 517   return false;
 518 }
 519
 520 std::string WindowBaseCocoa::GetAuxiliaryHintValue( unsigned int id ) const
 521 {
 522   return std::string();
 523 }
 524
 525 unsigned int WindowBaseCocoa::GetAuxiliaryHintId( const std::string& hint ) const
 526 {
 527   return 0;
 528 }
 529
 530 void WindowBaseCocoa::SetInputRegion( const Rect< int >& inputRegion )
 531 {
 532 }
 533
 534 void WindowBaseCocoa::SetType( Dali::WindowType type )
 535 {
 536 }
 537
 538 Dali::WindowType WindowBaseCocoa::GetType() const
 539 {
 540   return Dali::WindowType::NORMAL;
 541 }
 542
 543 WindowOperationResult WindowBaseCocoa::SetNotificationLevel( WindowNotificationLevel level )
 544 {
 545   return WindowOperationResult::NOT_SUPPORTED;
 546 }
 547
 548 WindowNotificationLevel WindowBaseCocoa::GetNotificationLevel() const
 549 {
 550   return WindowNotificationLevel::NONE;
 551 }
 552
 553 void WindowBaseCocoa::SetOpaqueState( bool opaque )
 554 {
 555 }
 556
 557 WindowOperationResult WindowBaseCocoa::SetScreenOffMode(WindowScreenOffMode screenOffMode)
 558 {
 559   return WindowOperationResult::NOT_SUPPORTED;
 560 }
 561
 562 WindowScreenOffMode WindowBaseCocoa::GetScreenOffMode() const
 563 {
 564   return WindowScreenOffMode::TIMEOUT;
 565 }
 566
 567 WindowOperationResult WindowBaseCocoa::SetBrightness( int brightness )
 568 {
 569   return WindowOperationResult::NOT_SUPPORTED;
 570 }
 571
 572 int WindowBaseCocoa::GetBrightness() const
 573 {
 574   return 0;
 575 }
 576
 577 bool WindowBaseCocoa::GrabKey( Dali::KEY key, KeyGrab::KeyGrabMode grabMode )
 578 {
 579   return false;
 580 }
 581
 582 bool WindowBaseCocoa::UngrabKey( Dali::KEY key )
 583 {
 584   return false;
 585 }
 586
 587 bool WindowBaseCocoa::GrabKeyList(
 588   const Dali::Vector< Dali::KEY >& key,
 589   const Dali::Vector< KeyGrab::KeyGrabMode >& grabMode,
 590   Dali::Vector< bool >& result
 591 )
 592 {
 593   return false;
 594 }
 595
 596 bool WindowBaseCocoa::UngrabKeyList(
 597   const Dali::Vector< Dali::KEY >& key,
 598   Dali::Vector< bool >& result
 599 )
 600 {
 601   return false;
 602 }
 603
 604 void WindowBaseCocoa::GetDpi(
 605   unsigned int& dpiHorizontal,
 606   unsigned int& dpiVertical
 607 )
 608 {
 609   auto *screen = [NSScreen mainScreen];
 610   NSSize res = [screen.deviceDescription[NSDeviceResolution] sizeValue];
 611   dpiHorizontal = res.width;
 612   dpiVertical = res.height;
 613 }
 614
 615 int WindowBaseCocoa::GetOrientation() const
 616 {
 617   return 0;
 618 }
 619
 620 int WindowBaseCocoa::GetScreenRotationAngle()
 621 {
 622   return 0;
 623 }
 624
 625 void WindowBaseCocoa::SetWindowRotationAngle( int degree )
 626 {
 627 }
 628
 629 void WindowBaseCocoa::WindowRotationCompleted( int degree, int width, int height )
 630 {
 631 }
 632
 633 void WindowBaseCocoa::SetTransparency( bool transparent )
 634 {
 635   mImpl->mWindow.alphaValue = static_cast<CGFloat>(!transparent);
 636 }
 637
 638 void WindowBaseCocoa::SetParent( WindowBase* parentWinBase )
 639 {
 640   auto &parent = dynamic_cast<WindowBaseCocoa&>(*parentWinBase);
 641   [mImpl->mWindow setParentWindow:parent.mImpl->mWindow];
 642 }
 643
 644 int WindowBaseCocoa::CreateFrameRenderedSyncFence()
 645 {
 646   return -1;
 647 }
 648
 649 int WindowBaseCocoa::CreateFramePresentedSyncFence()
 650 {
 651   return -1;
 652 }
 653
 654 void WindowBaseCocoa::SetPositionSizeWithAngle(PositionSize positionSize, int angle)
 655 {
 656 }
 657
 658 void WindowBaseCocoa::InitializeIme()
 659 {
 660 }
 661
 662 void WindowBaseCocoa::ImeWindowReadyToRender()
 663 {
 664 }
 665
 666 void WindowBaseCocoa::RequestMoveToServer()
 667 {
 668 }
 669
 670 void WindowBaseCocoa::RequestResizeToServer(WindowResizeDirection direction)
 671 {
 672 }
 673
 674 void WindowBaseCocoa::EnableFloatingMode(bool enable)
 675 {
 676 }
 677
 678 bool WindowBaseCocoa::IsFloatingModeEnabled() const
 679 {
 680   return false;
 681 }
 682
 683 } // namespace Dali::Internal::Adaptor
 684
 685 @implementation CocoaView
 686 {
 687   WindowBaseCocoa::Impl *mImpl;
 688 }
 689
 690 - (CocoaView *) initWithFrame:(NSRect) rect withImpl:(WindowBaseCocoa::Impl *) impl
 691 {
 692   self = [super initWithFrame:rect];
 693   if (self)
 694   {
 695     mImpl = impl;
 696     self.wantsLayer = YES;
 697     self.wantsBestResolutionOpenGLSurface = NO;
 698   }
 699
 700   return self;
 701 }
 702
 703 - (BOOL) isFlipped
 704 {
 705   return YES;
 706 }
 707
 708 - (BOOL) wantsUpdateLayer
 709 {
 710   return YES;
 711 }
 712
 713 - (BOOL) acceptsFirstResponder
 714 {
 715   return YES;
 716 }
 717
 718 - (void) mouseDown:(NSEvent *) event
 719 {
 720   mImpl->OnMouse(event, Dali::PointState::DOWN);
 721 }
 722
 723 - (void) mouseUp:(NSEvent *) event
 724 {
 725   mImpl->OnMouse(event, Dali::PointState::UP);
 726 }
 727
 728 - (void) mouseDragged:(NSEvent *) event
 729 {
 730   mImpl->OnMouse(event, Dali::PointState::MOTION);
 731 }
 732
 733 - (void) keyDown:(NSEvent *) event
 734 {
 735   mImpl->OnKey(event, Dali::Integration::KeyEvent::DOWN);
 736 }
 737
 738 - (void) keyUp:(NSEvent *) event
 739 {
 740   mImpl->OnKey(event, Dali::Integration::KeyEvent::UP);
 741 }
 742
 743 - (void) drawRect:(NSRect) dirtyRect
 744 {
 745   DALI_LOG_INFO(
 746     Dali::Internal::Adaptor::gWindowBaseLogFilter,
 747     Debug::Verbose,
 748     "-[CocoaView drawRect:(%.1f, %.1f, %.1f, %.1f)]\n",
 749     dirtyRect.origin.x,
 750     dirtyRect.origin.y,
 751     dirtyRect.size.width,
 752     dirtyRect.size.height
 753   );
 754
 755   mImpl->OnWindowDamaged(dirtyRect);
 756 }
 757
 758 - (void) prepareOpenGL
 759 {
 760   auto ctx = CGLGetCurrentContext();
 761   DALI_ASSERT_ALWAYS(ctx);
 762
 763   // Enable multithreading
 764   if (auto err = CGLEnable(ctx, kCGLCEMPEngine); err != kCGLNoError)
 765   {
 766     DALI_LOG_ERROR("%s - %s", __PRETTY_FUNCTION__, CGLErrorString(err));
 767   }
 768 }
 769 @end
 770
 771 @implementation WindowDelegate
 772 {
 773   WindowBaseCocoa::Impl *mImpl;
 774 }
 775
 776 - (WindowDelegate *) init:(Dali::Internal::Adaptor::WindowBaseCocoa::Impl *) impl
 777 {
 778   self = [super init];
 779   if (self)
 780   {
 781     mImpl = impl;
 782   }
 783   return self;
 784 }
 785
 786 - (void) windowDidBecomeKey:(NSNotification *) notification
 787 {
 788   mImpl->OnFocus(true);
 789 }
 790
 791 - (void) windowDidResignKey:(NSNotification *) notification
 792 {
 793   mImpl->OnFocus(false);
 794 }
 795
 796 - (void) windowWillClose:(NSNotification *) notification
 797 {
 798   [NSApp stop:nil];
 799 }
 800 @end
 801