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

   1 /*
   2  * Copyright (c) 2022 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 std::string WindowBaseCocoa::GetNativeWindowResourceId()
 380 {
 381   return std::string();
 382 }
 383
 384 EGLNativeWindowType WindowBaseCocoa::CreateEglWindow(int width, int height)
 385 {
 386   // XXX: this method is called from a secondary thread, but
 387   // we can only resize the window from the main thread
 388   //PositionSize size(0, 0, width, height);
 389   //Resize(size);
 390   return mImpl->mWindow.contentView.layer;
 391 }
 392
 393 void WindowBaseCocoa::DestroyEglWindow()
 394 {
 395 }
 396
 397 void WindowBaseCocoa::SetEglWindowRotation( int angle )
 398 {
 399 }
 400
 401 void WindowBaseCocoa::SetEglWindowBufferTransform( int angle )
 402 {
 403 }
 404
 405 void WindowBaseCocoa::SetEglWindowTransform( int angle )
 406 {
 407 }
 408
 409 void WindowBaseCocoa::ResizeEglWindow( PositionSize positionSize )
 410 {
 411   Resize(positionSize);
 412 }
 413
 414 bool WindowBaseCocoa::IsEglWindowRotationSupported()
 415 {
 416   return false;
 417 }
 418
 419 void WindowBaseCocoa::Move( PositionSize positionSize )
 420 {
 421   const NSPoint p = {
 422     .x = static_cast<CGFloat>(positionSize.x),
 423     .y = static_cast<CGFloat>(positionSize.y),
 424   };
 425
 426   [mImpl->mWindow setFrameTopLeftPoint:p];
 427 }
 428
 429 void WindowBaseCocoa::Resize( PositionSize positionSize )
 430 {
 431   auto r = mImpl->mWindow.frame;
 432   r.size.width = static_cast<CGFloat>(positionSize.width);
 433   r.size.height = static_cast<CGFloat>(positionSize.height);
 434   [mImpl->mWindow setFrame:r display:YES];
 435
 436   NSSize size =
 437   {
 438     .width = r.size.width,
 439     .height = r.size.height,
 440   };
 441
 442   [mImpl->mWindow.contentView setFrameSize:size];
 443
 444 }
 445
 446 void WindowBaseCocoa::MoveResize( PositionSize positionSize )
 447 {
 448   [mImpl->mWindow setFrame: PositionSizeToRect(positionSize) display:YES];
 449
 450   NSSize size =
 451   {
 452     .width = static_cast<CGFloat>(positionSize.width),
 453     .height = static_cast<CGFloat>(positionSize.height),
 454   };
 455
 456   [mImpl->mWindow.contentView setFrameSize:size];
 457 }
 458
 459 void WindowBaseCocoa::SetClass( const std::string& name, const std::string& className )
 460 {
 461 }
 462
 463 void WindowBaseCocoa::Raise()
 464 {
 465   [mImpl->mWindow orderFront:nil];
 466 }
 467
 468 void WindowBaseCocoa::Lower()
 469 {
 470   [mImpl->mWindow orderBack:nil];
 471 }
 472
 473 void WindowBaseCocoa::Activate()
 474 {
 475   [mImpl->mWinController showWindow:nil];
 476 }
 477
 478 void WindowBaseCocoa::Maximize(bool maximize)
 479 {
 480 }
 481
 482 bool WindowBaseCocoa::IsMaximized() const
 483 {
 484   return false;
 485 }
 486
 487 void WindowBaseCocoa::Minimize(bool minimize)
 488 {
 489 }
 490
 491 bool WindowBaseCocoa::IsMinimized() const
 492 {
 493   return false;
 494 }
 495
 496 void WindowBaseCocoa::SetAvailableAnlges( const std::vector< int >& angles )
 497 {
 498 }
 499
 500 void WindowBaseCocoa::SetPreferredAngle( int angle )
 501 {
 502 }
 503
 504 void WindowBaseCocoa::SetAcceptFocus( bool accept )
 505 {
 506 }
 507
 508 void WindowBaseCocoa::Show()
 509 {
 510   [mImpl->mWinController showWindow:nil];
 511 }
 512
 513 void WindowBaseCocoa::Hide()
 514 {
 515   [mImpl->mWindow orderOut:nil];
 516 }
 517
 518 unsigned int WindowBaseCocoa::GetSupportedAuxiliaryHintCount() const
 519 {
 520   return 0;
 521 }
 522
 523 std::string WindowBaseCocoa::GetSupportedAuxiliaryHint( unsigned int index ) const
 524 {
 525   return std::string();
 526 }
 527
 528 unsigned int WindowBaseCocoa::AddAuxiliaryHint( const std::string& hint, const std::string& value )
 529 {
 530   return 0;
 531 }
 532
 533 bool WindowBaseCocoa::RemoveAuxiliaryHint( unsigned int id )
 534 {
 535   return false;
 536 }
 537
 538 bool WindowBaseCocoa::SetAuxiliaryHintValue( unsigned int id, const std::string& value )
 539 {
 540   return false;
 541 }
 542
 543 std::string WindowBaseCocoa::GetAuxiliaryHintValue( unsigned int id ) const
 544 {
 545   return std::string();
 546 }
 547
 548 unsigned int WindowBaseCocoa::GetAuxiliaryHintId( const std::string& hint ) const
 549 {
 550   return 0;
 551 }
 552
 553 void WindowBaseCocoa::SetInputRegion( const Rect< int >& inputRegion )
 554 {
 555 }
 556
 557 void WindowBaseCocoa::SetType( Dali::WindowType type )
 558 {
 559 }
 560
 561 Dali::WindowType WindowBaseCocoa::GetType() const
 562 {
 563   return Dali::WindowType::NORMAL;
 564 }
 565
 566 WindowOperationResult WindowBaseCocoa::SetNotificationLevel( WindowNotificationLevel level )
 567 {
 568   return WindowOperationResult::NOT_SUPPORTED;
 569 }
 570
 571 WindowNotificationLevel WindowBaseCocoa::GetNotificationLevel() const
 572 {
 573   return WindowNotificationLevel::NONE;
 574 }
 575
 576 void WindowBaseCocoa::SetOpaqueState( bool opaque )
 577 {
 578 }
 579
 580 WindowOperationResult WindowBaseCocoa::SetScreenOffMode(WindowScreenOffMode screenOffMode)
 581 {
 582   return WindowOperationResult::NOT_SUPPORTED;
 583 }
 584
 585 WindowScreenOffMode WindowBaseCocoa::GetScreenOffMode() const
 586 {
 587   return WindowScreenOffMode::TIMEOUT;
 588 }
 589
 590 WindowOperationResult WindowBaseCocoa::SetBrightness( int brightness )
 591 {
 592   return WindowOperationResult::NOT_SUPPORTED;
 593 }
 594
 595 int WindowBaseCocoa::GetBrightness() const
 596 {
 597   return 0;
 598 }
 599
 600 bool WindowBaseCocoa::GrabKey( Dali::KEY key, KeyGrab::KeyGrabMode grabMode )
 601 {
 602   return false;
 603 }
 604
 605 bool WindowBaseCocoa::UngrabKey( Dali::KEY key )
 606 {
 607   return false;
 608 }
 609
 610 bool WindowBaseCocoa::GrabKeyList(
 611   const Dali::Vector< Dali::KEY >& key,
 612   const Dali::Vector< KeyGrab::KeyGrabMode >& grabMode,
 613   Dali::Vector< bool >& result
 614 )
 615 {
 616   return false;
 617 }
 618
 619 bool WindowBaseCocoa::UngrabKeyList(
 620   const Dali::Vector< Dali::KEY >& key,
 621   Dali::Vector< bool >& result
 622 )
 623 {
 624   return false;
 625 }
 626
 627 void WindowBaseCocoa::GetDpi(
 628   unsigned int& dpiHorizontal,
 629   unsigned int& dpiVertical
 630 )
 631 {
 632   auto *screen = [NSScreen mainScreen];
 633   NSSize res = [screen.deviceDescription[NSDeviceResolution] sizeValue];
 634   dpiHorizontal = res.width;
 635   dpiVertical = res.height;
 636 }
 637
 638 int WindowBaseCocoa::GetOrientation() const
 639 {
 640   return 0;
 641 }
 642
 643 int WindowBaseCocoa::GetScreenRotationAngle()
 644 {
 645   return 0;
 646 }
 647
 648 void WindowBaseCocoa::SetWindowRotationAngle( int degree )
 649 {
 650 }
 651
 652 void WindowBaseCocoa::WindowRotationCompleted( int degree, int width, int height )
 653 {
 654 }
 655
 656 void WindowBaseCocoa::SetTransparency( bool transparent )
 657 {
 658   mImpl->mWindow.alphaValue = static_cast<CGFloat>(!transparent);
 659 }
 660
 661 void WindowBaseCocoa::SetParent(WindowBase* parentWinBase, bool belowParent)
 662 {
 663   auto &parent = dynamic_cast<WindowBaseCocoa&>(*parentWinBase);
 664   [mImpl->mWindow setParentWindow:parent.mImpl->mWindow];
 665 }
 666
 667 int WindowBaseCocoa::CreateFrameRenderedSyncFence()
 668 {
 669   return -1;
 670 }
 671
 672 int WindowBaseCocoa::CreateFramePresentedSyncFence()
 673 {
 674   return -1;
 675 }
 676
 677 void WindowBaseCocoa::SetPositionSizeWithAngle(PositionSize positionSize, int angle)
 678 {
 679 }
 680
 681 void WindowBaseCocoa::InitializeIme()
 682 {
 683 }
 684
 685 void WindowBaseCocoa::ImeWindowReadyToRender()
 686 {
 687 }
 688
 689 void WindowBaseCocoa::RequestMoveToServer()
 690 {
 691 }
 692
 693 void WindowBaseCocoa::RequestResizeToServer(WindowResizeDirection direction)
 694 {
 695 }
 696
 697 void WindowBaseCocoa::EnableFloatingMode(bool enable)
 698 {
 699 }
 700
 701 bool WindowBaseCocoa::IsFloatingModeEnabled() const
 702 {
 703   return false;
 704 }
 705
 706 void WindowBaseCocoa::IncludeInputRegion(const Rect<int>& inputRegion)
 707 {
 708 }
 709
 710 void WindowBaseCocoa::ExcludeInputRegion(const Rect<int>& inputRegion)
 711 {
 712 }
 713
 714 } // namespace Dali::Internal::Adaptor
 715
 716 @implementation CocoaView
 717 {
 718   WindowBaseCocoa::Impl *mImpl;
 719 }
 720
 721 - (CocoaView *) initWithFrame:(NSRect) rect withImpl:(WindowBaseCocoa::Impl *) impl
 722 {
 723   self = [super initWithFrame:rect];
 724   if (self)
 725   {
 726     mImpl = impl;
 727     self.wantsLayer = YES;
 728     self.wantsBestResolutionOpenGLSurface = NO;
 729   }
 730
 731   return self;
 732 }
 733
 734 - (BOOL) isFlipped
 735 {
 736   return YES;
 737 }
 738
 739 - (BOOL) wantsUpdateLayer
 740 {
 741   return YES;
 742 }
 743
 744 - (BOOL) acceptsFirstResponder
 745 {
 746   return YES;
 747 }
 748
 749 - (void) mouseDown:(NSEvent *) event
 750 {
 751   mImpl->OnMouse(event, Dali::PointState::DOWN);
 752 }
 753
 754 - (void) mouseUp:(NSEvent *) event
 755 {
 756   mImpl->OnMouse(event, Dali::PointState::UP);
 757 }
 758
 759 - (void) mouseDragged:(NSEvent *) event
 760 {
 761   mImpl->OnMouse(event, Dali::PointState::MOTION);
 762 }
 763
 764 - (void) keyDown:(NSEvent *) event
 765 {
 766   mImpl->OnKey(event, Dali::Integration::KeyEvent::DOWN);
 767 }
 768
 769 - (void) keyUp:(NSEvent *) event
 770 {
 771   mImpl->OnKey(event, Dali::Integration::KeyEvent::UP);
 772 }
 773
 774 - (void) drawRect:(NSRect) dirtyRect
 775 {
 776   DALI_LOG_INFO(
 777     Dali::Internal::Adaptor::gWindowBaseLogFilter,
 778     Debug::Verbose,
 779     "-[CocoaView drawRect:(%.1f, %.1f, %.1f, %.1f)]\n",
 780     dirtyRect.origin.x,
 781     dirtyRect.origin.y,
 782     dirtyRect.size.width,
 783     dirtyRect.size.height
 784   );
 785
 786   mImpl->OnWindowDamaged(dirtyRect);
 787 }
 788
 789 - (void) prepareOpenGL
 790 {
 791   auto ctx = CGLGetCurrentContext();
 792   DALI_ASSERT_ALWAYS(ctx);
 793
 794   // Enable multithreading
 795   if (auto err = CGLEnable(ctx, kCGLCEMPEngine); err != kCGLNoError)
 796   {
 797     DALI_LOG_ERROR("%s - %s", __PRETTY_FUNCTION__, CGLErrorString(err));
 798   }
 799 }
 800 @end
 801
 802 @implementation WindowDelegate
 803 {
 804   WindowBaseCocoa::Impl *mImpl;
 805 }
 806
 807 - (WindowDelegate *) init:(Dali::Internal::Adaptor::WindowBaseCocoa::Impl *) impl
 808 {
 809   self = [super init];
 810   if (self)
 811   {
 812     mImpl = impl;
 813   }
 814   return self;
 815 }
 816
 817 - (void) windowDidBecomeKey:(NSNotification *) notification
 818 {
 819   mImpl->OnFocus(true);
 820 }
 821
 822 - (void) windowDidResignKey:(NSNotification *) notification
 823 {
 824   mImpl->OnFocus(false);
 825 }
 826
 827 - (void) windowWillClose:(NSNotification *) notification
 828 {
 829   [NSApp stop:nil];
 830 }
 831 @end
 832