DISTRHO
/
JUCE
mirror of https://github.com/DISTRHO/JUCE
1
0
Fork 0
Code Releases 1 Activity
The JUCE cross-platform C++ framework, with DISTRHO/KXStudio specific changes
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
12847 Commits
9 Branches
486MB
Tree: 970483b1cd
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '970483b1cd'
${ noResults }
JUCE/modules/juce_gui_basics/native/juce_mac_NSViewComponentPee...

2764 lines
104KB
Raw Blame History 

  1. /*

  2.   ==============================================================================

  3. 

  4.    This file is part of the JUCE library.

  5.    Copyright (c) 2020 - Raw Material Software Limited

  6. 

  7.    JUCE is an open source library subject to commercial or open-source

  8.    licensing.

  9. 

  10.    By using JUCE, you agree to the terms of both the JUCE 6 End-User License

  11.    Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).

  12. 

  13.    End User License Agreement: www.juce.com/juce-6-licence

  14.    Privacy Policy: www.juce.com/juce-privacy-policy

  15. 

  16.    Or: You may also use this code under the terms of the GPL v3 (see

  17.    www.gnu.org/licenses).

  18. 

  19.    JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER

  20.    EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE

  21.    DISCLAIMED.

  22. 

  23.   ==============================================================================

  24. */

  25. 

  26. @interface NSEvent (DeviceDelta)

  27. - (float)deviceDeltaX;

  28. - (float)deviceDeltaY;

  29. @end

  30. 

  31. //==============================================================================

  32. namespace juce

  33. {

  34.     typedef void (*AppFocusChangeCallback)();

  35.     extern AppFocusChangeCallback appFocusChangeCallback;

  36.     typedef bool (*CheckEventBlockedByModalComps) (NSEvent*);

  37.     extern CheckEventBlockedByModalComps isEventBlockedByModalComps;

  38. }

  39. 

  40. namespace juce

  41. {

  42. 

  43. //==============================================================================

  44. static constexpr int translateVirtualToAsciiKeyCode (int keyCode) noexcept

  45. {

  46.     switch (keyCode)

  47.     {

  48.         // The virtual keycodes are from HIToolbox/Events.h

  49.         case 0x00: return 'A';

  50.         case 0x01: return 'S';

  51.         case 0x02: return 'D';

  52.         case 0x03: return 'F';

  53.         case 0x04: return 'H';

  54.         case 0x05: return 'G';

  55.         case 0x06: return 'Z';

  56.         case 0x07: return 'X';

  57.         case 0x08: return 'C';

  58.         case 0x09: return 'V';

  59.         case 0x0B: return 'B';

  60.         case 0x0C: return 'Q';

  61.         case 0x0D: return 'W';

  62.         case 0x0E: return 'E';

  63.         case 0x0F: return 'R';

  64.         case 0x10: return 'Y';

  65.         case 0x11: return 'T';

  66.         case 0x12: return '1';

  67.         case 0x13: return '2';

  68.         case 0x14: return '3';

  69.         case 0x15: return '4';

  70.         case 0x16: return '6';

  71.         case 0x17: return '5';

  72.         case 0x18: return '=';  // kVK_ANSI_Equal

  73.         case 0x19: return '9';

  74.         case 0x1A: return '7';

  75.         case 0x1B: return '-';  // kVK_ANSI_Minus

  76.         case 0x1C: return '8';

  77.         case 0x1D: return '0';

  78.         case 0x1E: return ']';  // kVK_ANSI_RightBracket

  79.         case 0x1F: return 'O';

  80.         case 0x20: return 'U';

  81.         case 0x21: return '[';  // kVK_ANSI_LeftBracket

  82.         case 0x22: return 'I';

  83.         case 0x23: return 'P';

  84.         case 0x25: return 'L';

  85.         case 0x26: return 'J';

  86.         case 0x27: return '"';  // kVK_ANSI_Quote

  87.         case 0x28: return 'K';

  88.         case 0x29: return ';';  // kVK_ANSI_Semicolon

  89.         case 0x2A: return '\\'; // kVK_ANSI_Backslash

  90.         case 0x2B: return ',';  // kVK_ANSI_Comma

  91.         case 0x2C: return '/';  // kVK_ANSI_Slash

  92.         case 0x2D: return 'N';

  93.         case 0x2E: return 'M';

  94.         case 0x2F: return '.';  // kVK_ANSI_Period

  95.         case 0x32: return '`';  // kVK_ANSI_Grave

  96. 

  97.         default:   return keyCode;

  98.     }

  99. }

  100. 

  101. constexpr int extendedKeyModifier = 0x30000;

  102. 

  103. //==============================================================================

  104. class NSViewComponentPeer  : public ComponentPeer,

  105.                              private Timer

  106. {

  107. public:

  108.     NSViewComponentPeer (Component& comp, const int windowStyleFlags, NSView* viewToAttachTo)

  109.         : ComponentPeer (comp, windowStyleFlags),

  110.           safeComponent (&comp),

  111.           isSharedWindow (viewToAttachTo != nil),

  112.           lastRepaintTime (Time::getMillisecondCounter())

  113.     {

  114.         appFocusChangeCallback = appFocusChanged;

  115.         isEventBlockedByModalComps = checkEventBlockedByModalComps;

  116. 

  117.         auto r = makeNSRect (component.getLocalBounds());

  118. 

  119.         view = [createViewInstance() initWithFrame: r];

  120.         setOwner (view, this);

  121. 

  122.         [view registerForDraggedTypes: getSupportedDragTypes()];

  123. 

  124.         const auto options = NSTrackingMouseEnteredAndExited

  125.                            | NSTrackingMouseMoved

  126.                            | NSTrackingEnabledDuringMouseDrag

  127.                            | NSTrackingActiveAlways

  128.                            | NSTrackingInVisibleRect;

  129.         const NSUniquePtr<NSTrackingArea> trackingArea { [[NSTrackingArea alloc] initWithRect: r

  130.                                                                                       options: options

  131.                                                                                         owner: view

  132.                                                                                      userInfo: nil] };

  133.         [view addTrackingArea: trackingArea.get()];

  134. 

  135.         notificationCenter = [NSNotificationCenter defaultCenter];

  136. 

  137.         [notificationCenter  addObserver: view

  138.                                 selector: frameChangedSelector

  139.                                     name: NSViewFrameDidChangeNotification

  140.                                   object: view];

  141. 

  142.         [view setPostsFrameChangedNotifications: YES];

  143. 

  144.        #if USE_COREGRAPHICS_RENDERING && JUCE_COREGRAPHICS_DRAW_ASYNC

  145.         if (! getComponentAsyncLayerBackedViewDisabled (component))

  146.         {

  147.             if (@available (macOS 10.8, *))

  148.             {

  149.                 [view setWantsLayer: YES];

  150.                 [[view layer] setDrawsAsynchronously: YES];

  151.             }

  152.         }

  153.        #endif

  154. 

  155.         if (isSharedWindow)

  156.         {

  157.             window = [viewToAttachTo window];

  158.             [viewToAttachTo addSubview: view];

  159.         }

  160.         else

  161.         {

  162.             r.origin.x = (CGFloat) component.getX();

  163.             r.origin.y = (CGFloat) component.getY();

  164.             r = flippedScreenRect (r);

  165. 

  166.             window = [createWindowInstance() initWithContentRect: r

  167.                                                        styleMask: getNSWindowStyleMask (windowStyleFlags)

  168.                                                          backing: NSBackingStoreBuffered

  169.                                                            defer: YES];

  170.             setOwner (window, this);

  171. 

  172.             if (@available (macOS 10.10, *))

  173.                 [window setAccessibilityElement: YES];

  174. 

  175.             [window orderOut: nil];

  176.             [window setDelegate: (id<NSWindowDelegate>) window];

  177. 

  178.             [window setOpaque: component.isOpaque()];

  179. 

  180.             if (! [window isOpaque])

  181.                 [window setBackgroundColor: [NSColor clearColor]];

  182. 

  183.            if (@available (macOS 10.9, *))

  184.                 [view setAppearance: [NSAppearance appearanceNamed: NSAppearanceNameAqua]];

  185. 

  186.             [window setHasShadow: ((windowStyleFlags & windowHasDropShadow) != 0)];

  187. 

  188.             if (component.isAlwaysOnTop())

  189.                 setAlwaysOnTop (true);

  190. 

  191.             [window setContentView: view];

  192. 

  193.             // We'll both retain and also release this on closing because plugin hosts can unexpectedly

  194.             // close the window for us, and also tend to get cause trouble if setReleasedWhenClosed is NO.

  195.             [window setReleasedWhenClosed: YES];

  196.             [window retain];

  197. 

  198.             [window setExcludedFromWindowsMenu: (windowStyleFlags & windowIsTemporary) != 0];

  199.             [window setIgnoresMouseEvents: (windowStyleFlags & windowIgnoresMouseClicks) != 0];

  200. 

  201.             setCollectionBehaviour (false);

  202. 

  203.             [window setRestorable: NO];

  204. 

  205.            #if defined (MAC_OS_X_VERSION_10_12) && (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_12)

  206.             if (@available (macOS 10.12, *))

  207.                 [window setTabbingMode: NSWindowTabbingModeDisallowed];

  208.            #endif

  209. 

  210.             [notificationCenter  addObserver: view

  211.                                     selector: frameChangedSelector

  212.                                         name: NSWindowDidMoveNotification

  213.                                       object: window];

  214. 

  215.             [notificationCenter  addObserver: view

  216.                                     selector: frameChangedSelector

  217.                                         name: NSWindowDidMiniaturizeNotification

  218.                                       object: window];

  219. 

  220.             [notificationCenter  addObserver: view

  221.                                     selector: @selector (windowWillMiniaturize:)

  222.                                         name: NSWindowWillMiniaturizeNotification

  223.                                       object: window];

  224. 

  225.             [notificationCenter  addObserver: view

  226.                                     selector: @selector (windowDidDeminiaturize:)

  227.                                         name: NSWindowDidDeminiaturizeNotification

  228.                                       object: window];

  229.         }

  230. 

  231.         auto alpha = component.getAlpha();

  232. 

  233.         if (alpha < 1.0f)

  234.             setAlpha (alpha);

  235. 

  236.         setTitle (component.getName());

  237. 

  238.         getNativeRealtimeModifiers = []

  239.         {

  240.             if ([NSEvent respondsToSelector: @selector (modifierFlags)])

  241.                 NSViewComponentPeer::updateModifiers ([NSEvent modifierFlags]);

  242. 

  243.             return ModifierKeys::currentModifiers;

  244.         };

  245.     }

  246. 

  247.     ~NSViewComponentPeer() override

  248.     {

  249.         [notificationCenter removeObserver: view];

  250.         setOwner (view, nullptr);

  251. 

  252.         if ([view superview] != nil)

  253.         {

  254.             redirectWillMoveToWindow (nullptr);

  255.             [view removeFromSuperview];

  256.         }

  257. 

  258.         if (! isSharedWindow)

  259.         {

  260.             setOwner (window, nullptr);

  261.             [window setContentView: nil];

  262.             [window close];

  263.             [window release];

  264.         }

  265. 

  266.         [view release];

  267.     }

  268. 

  269.     //==============================================================================

  270.     void* getNativeHandle() const override    { return view; }

  271. 

  272.     void setVisible (bool shouldBeVisible) override

  273.     {

  274.         if (isSharedWindow)

  275.         {

  276.             if (shouldBeVisible)

  277.                 [view setHidden: false];

  278.             else if ([window firstResponder] != view || ([window firstResponder] == view && [window makeFirstResponder: nil]))

  279.                 [view setHidden: true];

  280.         }

  281.         else

  282.         {

  283.             if (shouldBeVisible)

  284.             {

  285.                 ++insideToFrontCall;

  286.                 [window orderFront: nil];

  287.                 --insideToFrontCall;

  288.                 handleBroughtToFront();

  289.             }

  290.             else

  291.             {

  292.                 [window orderOut: nil];

  293.             }

  294.         }

  295.     }

  296. 

  297.     void setTitle (const String& title) override

  298.     {

  299.         JUCE_AUTORELEASEPOOL

  300.         {

  301.             if (! isSharedWindow)

  302.                 [window setTitle: juceStringToNS (title)];

  303.         }

  304.     }

  305. 

  306.     bool setDocumentEditedStatus (bool edited) override

  307.     {

  308.         if (! hasNativeTitleBar())

  309.             return false;

  310. 

  311.         [window setDocumentEdited: edited];

  312.         return true;

  313.     }

  314. 

  315.     void setRepresentedFile (const File& file) override

  316.     {

  317.         if (! isSharedWindow)

  318.         {

  319.             [window setRepresentedFilename: juceStringToNS (file != File()

  320.                                                                 ? file.getFullPathName()

  321.                                                                 : String())];

  322. 

  323.             windowRepresentsFile = (file != File());

  324.         }

  325.     }

  326. 

  327.     void setBounds (const Rectangle<int>& newBounds, bool) override

  328.     {

  329.         auto r = makeNSRect (newBounds);

  330.         auto oldViewSize = [view frame].size;

  331. 

  332.         if (isSharedWindow)

  333.         {

  334.             [view setFrame: r];

  335.         }

  336.         else

  337.         {

  338.             // Repaint behaviour of setFrame seemed to change in 10.11, and the drawing became synchronous,

  339.             // causing performance issues. But sending an async update causes flickering in older versions,

  340.             // hence this version check to use the old behaviour on pre 10.11 machines

  341.             static bool isPre10_11 = SystemStats::getOperatingSystemType() <= SystemStats::MacOSX_10_10;

  342. 

  343.             [window setFrame: [window frameRectForContentRect: flippedScreenRect (r)]

  344.                      display: isPre10_11];

  345.         }

  346. 

  347.         if (oldViewSize.width != r.size.width || oldViewSize.height != r.size.height)

  348.             [view setNeedsDisplay: true];

  349.     }

  350. 

  351.     Rectangle<int> getBounds (const bool global) const

  352.     {

  353.         auto r = [view frame];

  354.         NSWindow* viewWindow = [view window];

  355. 

  356.         if (global && viewWindow != nil)

  357.         {

  358.             r = [[view superview] convertRect: r toView: nil];

  359.             r = [viewWindow convertRectToScreen: r];

  360. 

  361.             r = flippedScreenRect (r);

  362.         }

  363. 

  364.         return convertToRectInt (r);

  365.     }

  366. 

  367.     Rectangle<int> getBounds() const override

  368.     {

  369.         return getBounds (! isSharedWindow);

  370.     }

  371. 

  372.     Point<float> localToGlobal (Point<float> relativePosition) override

  373.     {

  374.         return relativePosition + getBounds (true).getPosition().toFloat();

  375.     }

  376. 

  377.     using ComponentPeer::localToGlobal;

  378. 

  379.     Point<float> globalToLocal (Point<float> screenPosition) override

  380.     {

  381.         return screenPosition - getBounds (true).getPosition().toFloat();

  382.     }

  383. 

  384.     using ComponentPeer::globalToLocal;

  385. 

  386.     void setAlpha (float newAlpha) override

  387.     {

  388.         if (isSharedWindow)

  389.             [view setAlphaValue: (CGFloat) newAlpha];

  390.         else

  391.             [window setAlphaValue: (CGFloat) newAlpha];

  392.     }

  393. 

  394.     void setMinimised (bool shouldBeMinimised) override

  395.     {

  396.         if (! isSharedWindow)

  397.         {

  398.             if (shouldBeMinimised)

  399.                 [window miniaturize: nil];

  400.             else

  401.                 [window deminiaturize: nil];

  402.         }

  403.     }

  404. 

  405.     bool isMinimised() const override

  406.     {

  407.         return [window isMiniaturized];

  408.     }

  409. 

  410.     NSWindowCollectionBehavior getCollectionBehavior (bool forceFullScreen) const

  411.     {

  412.         if (forceFullScreen)

  413.             return NSWindowCollectionBehaviorFullScreenPrimary;

  414. 

  415.         // Some SDK versions don't define NSWindowCollectionBehaviorFullScreenNone

  416.         constexpr auto fullScreenNone = (NSUInteger) (1 << 9);

  417. 

  418.         return (getStyleFlags() & (windowHasMaximiseButton | windowIsResizable)) == (windowHasMaximiseButton | windowIsResizable)

  419.              ? NSWindowCollectionBehaviorFullScreenPrimary

  420.              : fullScreenNone;

  421.     }

  422. 

  423.     void setCollectionBehaviour (bool forceFullScreen) const

  424.     {

  425.         [window setCollectionBehavior: getCollectionBehavior (forceFullScreen)];

  426.     }

  427. 

  428.     void setFullScreen (bool shouldBeFullScreen) override

  429.     {

  430.         if (isSharedWindow)

  431.             return;

  432. 

  433.         if (shouldBeFullScreen)

  434.             setCollectionBehaviour (true);

  435. 

  436.         if (isMinimised())

  437.             setMinimised (false);

  438. 

  439.         if (shouldBeFullScreen != isFullScreen())

  440.             [window toggleFullScreen: nil];

  441.     }

  442. 

  443.     bool isFullScreen() const override

  444.     {

  445.         return ([window styleMask] & NSWindowStyleMaskFullScreen) != 0;

  446.     }

  447. 

  448.     bool isKioskMode() const override

  449.     {

  450.         return isFullScreen() && ComponentPeer::isKioskMode();

  451.     }

  452. 

  453.     static bool isWindowAtPoint (NSWindow* w, NSPoint screenPoint)

  454.     {

  455.         if ([NSWindow respondsToSelector: @selector (windowNumberAtPoint:belowWindowWithWindowNumber:)])

  456.             return [NSWindow windowNumberAtPoint: screenPoint belowWindowWithWindowNumber: 0] == [w windowNumber];

  457. 

  458.         return true;

  459.     }

  460. 

  461.     bool contains (Point<int> localPos, bool trueIfInAChildWindow) const override

  462.     {

  463.         NSRect viewFrame = [view frame];

  464. 

  465.         if (! (isPositiveAndBelow (localPos.getX(), viewFrame.size.width)

  466.             && isPositiveAndBelow (localPos.getY(), viewFrame.size.height)))

  467.             return false;

  468. 

  469.         if (! SystemStats::isRunningInAppExtensionSandbox())

  470.         {

  471.             if (NSWindow* const viewWindow = [view window])

  472.             {

  473.                 NSRect windowFrame = [viewWindow frame];

  474.                 NSPoint windowPoint = [view convertPoint: NSMakePoint (localPos.x, localPos.y) toView: nil];

  475.                 NSPoint screenPoint = NSMakePoint (windowFrame.origin.x + windowPoint.x,

  476.                                                    windowFrame.origin.y + windowPoint.y);

  477. 

  478.                 if (! isWindowAtPoint (viewWindow, screenPoint))

  479.                     return false;

  480. 

  481.             }

  482.         }

  483. 

  484.         NSView* v = [view hitTest: NSMakePoint (viewFrame.origin.x + localPos.getX(),

  485.                                                 viewFrame.origin.y + localPos.getY())];

  486. 

  487.         return trueIfInAChildWindow ? (v != nil)

  488.                                     : (v == view);

  489.     }

  490. 

  491.     OptionalBorderSize getFrameSizeIfPresent() const override

  492.     {

  493.         if (! isSharedWindow)

  494.         {

  495.             BorderSize<int> b;

  496. 

  497.             NSRect v = [view convertRect: [view frame] toView: nil];

  498.             NSRect w = [window frame];

  499. 

  500.             b.setTop ((int) (w.size.height - (v.origin.y + v.size.height)));

  501.             b.setBottom ((int) v.origin.y);

  502.             b.setLeft ((int) v.origin.x);

  503.             b.setRight ((int) (w.size.width - (v.origin.x + v.size.width)));

  504. 

  505.             return OptionalBorderSize { b };

  506.         }

  507. 

  508.         return {};

  509.     }

  510. 

  511.     BorderSize<int> getFrameSize() const override

  512.     {

  513.         if (const auto frameSize = getFrameSizeIfPresent())

  514.             return *frameSize;

  515. 

  516.         return {};

  517.     }

  518. 

  519.     bool hasNativeTitleBar() const

  520.     {

  521.         return (getStyleFlags() & windowHasTitleBar) != 0;

  522.     }

  523. 

  524.     bool setAlwaysOnTop (bool alwaysOnTop) override

  525.     {

  526.         if (! isSharedWindow)

  527.         {

  528.             [window setLevel: alwaysOnTop ? ((getStyleFlags() & windowIsTemporary) != 0 ? NSPopUpMenuWindowLevel

  529.                                                                                         : NSFloatingWindowLevel)

  530.                                           : NSNormalWindowLevel];

  531. 

  532.             isAlwaysOnTop = alwaysOnTop;

  533.         }

  534. 

  535.         return true;

  536.     }

  537. 

  538.     void toFront (bool makeActiveWindow) override

  539.     {

  540.         if (isSharedWindow)

  541.         {

  542.             NSView* superview = [view superview];

  543.             NSMutableArray* subviews = [NSMutableArray arrayWithArray: [superview subviews]];

  544. 

  545.             const auto isFrontmost = [[subviews lastObject] isEqual: view];

  546. 

  547.             if (! isFrontmost)

  548.             {

  549.                 [view retain];

  550.                 [subviews removeObject: view];

  551.                 [subviews addObject: view];

  552. 

  553.                 [superview setSubviews: subviews];

  554.                 [view release];

  555.             }

  556.         }

  557. 

  558.         if (window != nil && component.isVisible())

  559.         {

  560.             ++insideToFrontCall;

  561. 

  562.             if (makeActiveWindow)

  563.                 [window makeKeyAndOrderFront: nil];

  564.             else

  565.                 [window orderFront: nil];

  566. 

  567.             if (insideToFrontCall <= 1)

  568.             {

  569.                 Desktop::getInstance().getMainMouseSource().forceMouseCursorUpdate();

  570.                 handleBroughtToFront();

  571.             }

  572. 

  573.             --insideToFrontCall;

  574.         }

  575.     }

  576. 

  577.     void toBehind (ComponentPeer* other) override

  578.     {

  579.         if (auto* otherPeer = dynamic_cast<NSViewComponentPeer*> (other))

  580.         {

  581.             if (isSharedWindow)

  582.             {

  583.                 NSView* superview = [view superview];

  584.                 NSMutableArray* subviews = [NSMutableArray arrayWithArray: [superview subviews]];

  585. 

  586.                 const auto otherViewIndex = [subviews indexOfObject: otherPeer->view];

  587. 

  588.                 if (otherViewIndex == NSNotFound)

  589.                     return;

  590. 

  591.                 const auto isBehind = [subviews indexOfObject: view] < otherViewIndex;

  592. 

  593.                 if (! isBehind)

  594.                 {

  595.                     [view retain];

  596.                     [subviews removeObject: view];

  597.                     [subviews insertObject: view

  598.                                    atIndex: otherViewIndex];

  599. 

  600.                     [superview setSubviews: subviews];

  601.                     [view release];

  602.                 }

  603.             }

  604.             else if (component.isVisible())

  605.             {

  606.                 [window orderWindow: NSWindowBelow

  607.                          relativeTo: [otherPeer->window windowNumber]];

  608.             }

  609.         }

  610.         else

  611.         {

  612.             jassertfalse; // wrong type of window?

  613.         }

  614.     }

  615. 

  616.     void setIcon (const Image& newIcon) override

  617.     {

  618.         if (! isSharedWindow)

  619.         {

  620.             // need to set a dummy represented file here to show the file icon (which we then set to the new icon)

  621.             if (! windowRepresentsFile)

  622.                 [window setRepresentedFilename: juceStringToNS (" ")]; // can't just use an empty string for some reason...

  623. 

  624.             auto img = NSUniquePtr<NSImage> { imageToNSImage (ScaledImage (newIcon)) };

  625.             [[window standardWindowButton: NSWindowDocumentIconButton] setImage: img.get()];

  626.         }

  627.     }

  628. 

  629.     StringArray getAvailableRenderingEngines() override

  630.     {

  631.         StringArray s ("Software Renderer");

  632. 

  633.        #if USE_COREGRAPHICS_RENDERING

  634.         s.add ("CoreGraphics Renderer");

  635.        #endif

  636. 

  637.         return s;

  638.     }

  639. 

  640.     int getCurrentRenderingEngine() const override

  641.     {

  642.         return usingCoreGraphics ? 1 : 0;

  643.     }

  644. 

  645.     void setCurrentRenderingEngine (int index) override

  646.     {

  647.        #if USE_COREGRAPHICS_RENDERING

  648.         if (usingCoreGraphics != (index > 0))

  649.         {

  650.             usingCoreGraphics = index > 0;

  651.             [view setNeedsDisplay: true];

  652.         }

  653.        #else

  654.         ignoreUnused (index);

  655.        #endif

  656.     }

  657. 

  658.     void redirectMouseDown (NSEvent* ev)

  659.     {

  660.         if (! Process::isForegroundProcess())

  661.             Process::makeForegroundProcess();

  662. 

  663.         ModifierKeys::currentModifiers = ModifierKeys::currentModifiers.withFlags (getModifierForButtonNumber ([ev buttonNumber]));

  664.         sendMouseEvent (ev);

  665.     }

  666. 

  667.     void redirectMouseUp (NSEvent* ev)

  668.     {

  669.         ModifierKeys::currentModifiers = ModifierKeys::currentModifiers.withoutFlags (getModifierForButtonNumber ([ev buttonNumber]));

  670.         sendMouseEvent (ev);

  671.         showArrowCursorIfNeeded();

  672.     }

  673. 

  674.     void redirectMouseDrag (NSEvent* ev)

  675.     {

  676.         ModifierKeys::currentModifiers = ModifierKeys::currentModifiers.withFlags (getModifierForButtonNumber ([ev buttonNumber]));

  677.         sendMouseEvent (ev);

  678.     }

  679. 

  680.     void redirectMouseMove (NSEvent* ev)

  681.     {

  682.         ModifierKeys::currentModifiers = ModifierKeys::currentModifiers.withoutMouseButtons();

  683. 

  684.         NSPoint windowPos = [ev locationInWindow];

  685.         NSPoint screenPos = [[ev window] convertRectToScreen: NSMakeRect (windowPos.x, windowPos.y, 1.0f, 1.0f)].origin;

  686. 

  687.         if (isWindowAtPoint ([ev window], screenPos))

  688.             sendMouseEvent (ev);

  689.         else

  690.             // moved into another window which overlaps this one, so trigger an exit

  691.             handleMouseEvent (MouseInputSource::InputSourceType::mouse, MouseInputSource::offscreenMousePos, ModifierKeys::currentModifiers,

  692.                               getMousePressure (ev), MouseInputSource::defaultOrientation, getMouseTime (ev));

  693. 

  694.         showArrowCursorIfNeeded();

  695.     }

  696. 

  697.     void redirectMouseEnter (NSEvent* ev)

  698.     {

  699.         sendMouseEnterExit (ev);

  700.     }

  701. 

  702.     void redirectMouseExit (NSEvent* ev)

  703.     {

  704.         sendMouseEnterExit (ev);

  705.     }

  706. 

  707.     static float checkDeviceDeltaReturnValue (float v) noexcept

  708.     {

  709.         // (deviceDeltaX can fail and return NaN, so need to sanity-check the result)

  710.         v *= 0.5f / 256.0f;

  711.         return (v > -1000.0f && v < 1000.0f) ? v : 0.0f;

  712.     }

  713. 

  714.     void redirectMouseWheel (NSEvent* ev)

  715.     {

  716.         updateModifiers (ev);

  717. 

  718.         MouseWheelDetails wheel;

  719.         wheel.deltaX = 0;

  720.         wheel.deltaY = 0;

  721.         wheel.isReversed = false;

  722.         wheel.isSmooth = false;

  723.         wheel.isInertial = false;

  724. 

  725.         @try

  726.         {

  727.             if ([ev respondsToSelector: @selector (isDirectionInvertedFromDevice)])

  728.                 wheel.isReversed = [ev isDirectionInvertedFromDevice];

  729. 

  730.             wheel.isInertial = ([ev momentumPhase] != NSEventPhaseNone);

  731. 

  732.             if ([ev respondsToSelector: @selector (hasPreciseScrollingDeltas)])

  733.             {

  734.                 if ([ev hasPreciseScrollingDeltas])

  735.                 {

  736.                     const float scale = 0.5f / 256.0f;

  737.                     wheel.deltaX = scale * (float) [ev scrollingDeltaX];

  738.                     wheel.deltaY = scale * (float) [ev scrollingDeltaY];

  739.                     wheel.isSmooth = true;

  740.                 }

  741.             }

  742.             else if ([ev respondsToSelector: @selector (deviceDeltaX)])

  743.             {

  744.                 wheel.deltaX = checkDeviceDeltaReturnValue ([ev deviceDeltaX]);

  745.                 wheel.deltaY = checkDeviceDeltaReturnValue ([ev deviceDeltaY]);

  746.             }

  747.         }

  748.         @catch (...)

  749.         {}

  750. 

  751.         if (wheel.deltaX == 0.0f && wheel.deltaY == 0.0f)

  752.         {

  753.             const float scale = 10.0f / 256.0f;

  754.             wheel.deltaX = scale * (float) [ev deltaX];

  755.             wheel.deltaY = scale * (float) [ev deltaY];

  756.         }

  757. 

  758.         handleMouseWheel (MouseInputSource::InputSourceType::mouse, getMousePos (ev, view), getMouseTime (ev), wheel);

  759.     }

  760. 

  761.     void redirectMagnify (NSEvent* ev)

  762.     {

  763.         const float invScale = 1.0f - (float) [ev magnification];

  764. 

  765.         if (invScale > 0.0f)

  766.             handleMagnifyGesture (MouseInputSource::InputSourceType::mouse, getMousePos (ev, view), getMouseTime (ev), 1.0f / invScale);

  767.     }

  768. 

  769.     void redirectCopy      (NSObject*) { handleKeyPress (KeyPress ('c', ModifierKeys (ModifierKeys::commandModifier), 'c')); }

  770.     void redirectPaste     (NSObject*) { handleKeyPress (KeyPress ('v', ModifierKeys (ModifierKeys::commandModifier), 'v')); }

  771.     void redirectCut       (NSObject*) { handleKeyPress (KeyPress ('x', ModifierKeys (ModifierKeys::commandModifier), 'x')); }

  772.     void redirectSelectAll (NSObject*) { handleKeyPress (KeyPress ('a', ModifierKeys (ModifierKeys::commandModifier), 'a')); }

  773. 

  774.     void redirectWillMoveToWindow (NSWindow* newWindow)

  775.     {

  776.         if (auto* currentWindow = [view window])

  777.         {

  778.             [notificationCenter removeObserver: view

  779.                                           name: NSWindowDidMoveNotification

  780.                                         object: currentWindow];

  781. 

  782.             [notificationCenter removeObserver: view

  783.                                           name: NSWindowWillMiniaturizeNotification

  784.                                         object: currentWindow];

  785. 

  786.            #if JUCE_COREGRAPHICS_DRAW_ASYNC

  787.             [notificationCenter removeObserver: view

  788.                                           name: NSWindowDidBecomeKeyNotification

  789.                                         object: currentWindow];

  790.            #endif

  791.         }

  792. 

  793.         if (isSharedWindow && [view window] == window && newWindow == nullptr)

  794.         {

  795.             if (auto* comp = safeComponent.get())

  796.                 comp->setVisible (false);

  797.         }

  798.     }

  799. 

  800.     void sendMouseEvent (NSEvent* ev)

  801.     {

  802.         updateModifiers (ev);

  803.         handleMouseEvent (MouseInputSource::InputSourceType::mouse, getMousePos (ev, view), ModifierKeys::currentModifiers,

  804.                           getMousePressure (ev), MouseInputSource::defaultOrientation, getMouseTime (ev));

  805.     }

  806. 

  807.     bool handleKeyEvent (NSEvent* ev, bool isKeyDown)

  808.     {

  809.         auto unicode = nsStringToJuce ([ev characters]);

  810.         auto keyCode = getKeyCodeFromEvent (ev);

  811. 

  812.        #if JUCE_DEBUG_KEYCODES

  813.         DBG ("unicode: " + unicode + " " + String::toHexString ((int) unicode[0]));

  814.         auto unmodified = nsStringToJuce ([ev charactersIgnoringModifiers]);

  815.         DBG ("unmodified: " + unmodified + " " + String::toHexString ((int) unmodified[0]));

  816.        #endif

  817. 

  818.         if (keyCode != 0 || unicode.isNotEmpty())

  819.         {

  820.             if (isKeyDown)

  821.             {

  822.                 bool used = false;

  823. 

  824.                 for (auto u = unicode.getCharPointer(); ! u.isEmpty();)

  825.                 {

  826.                     auto textCharacter = u.getAndAdvance();

  827. 

  828.                     switch (keyCode)

  829.                     {

  830.                         case NSLeftArrowFunctionKey:

  831.                         case NSRightArrowFunctionKey:

  832.                         case NSUpArrowFunctionKey:

  833.                         case NSDownArrowFunctionKey:

  834.                         case NSPageUpFunctionKey:

  835.                         case NSPageDownFunctionKey:

  836.                         case NSEndFunctionKey:

  837.                         case NSHomeFunctionKey:

  838.                         case NSDeleteFunctionKey:

  839.                             textCharacter = 0;

  840.                             break; // (these all seem to generate unwanted garbage unicode strings)

  841. 

  842.                         default:

  843.                             if (([ev modifierFlags] & NSEventModifierFlagCommand) != 0

  844.                                  || (keyCode >= NSF1FunctionKey && keyCode <= NSF35FunctionKey))

  845.                                 textCharacter = 0;

  846.                             break;

  847.                     }

  848. 

  849.                     used = handleKeyUpOrDown (true) || used;

  850.                     used = handleKeyPress (keyCode, textCharacter) || used;

  851.                 }

  852. 

  853.                 return used;

  854.             }

  855. 

  856.             if (handleKeyUpOrDown (false))

  857.                 return true;

  858.         }

  859. 

  860.         return false;

  861.     }

  862. 

  863.     bool redirectKeyDown (NSEvent* ev)

  864.     {

  865.         // (need to retain this in case a modal loop runs in handleKeyEvent and

  866.         // our event object gets lost)

  867.         const NSUniquePtr<NSEvent> r ([ev retain]);

  868. 

  869.         updateKeysDown (ev, true);

  870.         bool used = handleKeyEvent (ev, true);

  871. 

  872.         if (([ev modifierFlags] & NSEventModifierFlagCommand) != 0)

  873.         {

  874.             // for command keys, the key-up event is thrown away, so simulate one..

  875.             updateKeysDown (ev, false);

  876.             used = (isValidPeer (this) && handleKeyEvent (ev, false)) || used;

  877.         }

  878. 

  879.         // (If we're running modally, don't allow unused keystrokes to be passed

  880.         // along to other blocked views..)

  881.         if (Component::getCurrentlyModalComponent() != nullptr)

  882.             used = true;

  883. 

  884.         return used;

  885.     }

  886. 

  887.     bool redirectKeyUp (NSEvent* ev)

  888.     {

  889.         updateKeysDown (ev, false);

  890.         return handleKeyEvent (ev, false)

  891.                 || Component::getCurrentlyModalComponent() != nullptr;

  892.     }

  893. 

  894.     void redirectModKeyChange (NSEvent* ev)

  895.     {

  896.         // (need to retain this in case a modal loop runs and our event object gets lost)

  897.         const NSUniquePtr<NSEvent> r ([ev retain]);

  898. 

  899.         keysCurrentlyDown.clear();

  900.         handleKeyUpOrDown (true);

  901. 

  902.         updateModifiers (ev);

  903.         handleModifierKeysChange();

  904.     }

  905. 

  906.     //==============================================================================

  907.     void drawRect (NSRect r)

  908.     {

  909.         if (r.size.width < 1.0f || r.size.height < 1.0f)

  910.             return;

  911. 

  912.         auto cg = []

  913.         {

  914.             if (@available (macOS 10.10, *))

  915.                 return (CGContextRef) [[NSGraphicsContext currentContext] CGContext];

  916. 

  917.             JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wdeprecated-declarations")

  918.             return (CGContextRef) [[NSGraphicsContext currentContext] graphicsPort];

  919.             JUCE_END_IGNORE_WARNINGS_GCC_LIKE

  920.         }();

  921. 

  922.         if (! component.isOpaque())

  923.             CGContextClearRect (cg, CGContextGetClipBoundingBox (cg));

  924. 

  925.         float displayScale = 1.0f;

  926.         NSScreen* screen = [[view window] screen];

  927. 

  928.         if ([screen respondsToSelector: @selector (backingScaleFactor)])

  929.             displayScale = (float) screen.backingScaleFactor;

  930. 

  931.         auto invalidateTransparentWindowShadow = [this]

  932.         {

  933.             // transparent NSWindows with a drop-shadow need to redraw their shadow when the content

  934.             // changes to avoid stale shadows being drawn behind the window

  935.             if (! isSharedWindow && ! [window isOpaque] && [window hasShadow])

  936.                 [window invalidateShadow];

  937.         };

  938. 

  939.        #if USE_COREGRAPHICS_RENDERING && JUCE_COREGRAPHICS_RENDER_WITH_MULTIPLE_PAINT_CALLS

  940.         // This option invokes a separate paint call for each rectangle of the clip region.

  941.         // It's a long story, but this is a basically a workaround for a CGContext not having

  942.         // a way of finding whether a rectangle falls within its clip region

  943.         if (usingCoreGraphics)

  944.         {

  945.             const NSRect* rects = nullptr;

  946.             NSInteger numRects = 0;

  947.             [view getRectsBeingDrawn: &rects count: &numRects];

  948. 

  949.             if (numRects > 1)

  950.             {

  951.                 for (int i = 0; i < numRects; ++i)

  952.                 {

  953.                     NSRect rect = rects[i];

  954.                     CGContextSaveGState (cg);

  955.                     CGContextClipToRect (cg, CGRectMake (rect.origin.x, rect.origin.y, rect.size.width, rect.size.height));

  956.                     drawRectWithContext (cg, rect, displayScale);

  957.                     CGContextRestoreGState (cg);

  958.                 }

  959. 

  960.                 invalidateTransparentWindowShadow();

  961.                 return;

  962.             }

  963.         }

  964.        #endif

  965. 

  966.         drawRectWithContext (cg, r, displayScale);

  967.         invalidateTransparentWindowShadow();

  968.     }

  969. 

  970.     void drawRectWithContext (CGContextRef cg, NSRect r, float displayScale)

  971.     {

  972.        #if USE_COREGRAPHICS_RENDERING

  973.         if (usingCoreGraphics)

  974.         {

  975.             const auto height = getComponent().getHeight();

  976.             CGContextConcatCTM (cg, CGAffineTransformMake (1, 0, 0, -1, 0, height));

  977.             CoreGraphicsContext context (cg, (float) height);

  978.             handlePaint (context);

  979.         }

  980.         else

  981.        #endif

  982.         {

  983.             const Point<int> offset (-roundToInt (r.origin.x), -roundToInt (r.origin.y));

  984.             auto clipW = (int) (r.size.width  + 0.5f);

  985.             auto clipH = (int) (r.size.height + 0.5f);

  986. 

  987.             RectangleList<int> clip;

  988.             getClipRects (clip, offset, clipW, clipH);

  989. 

  990.             if (! clip.isEmpty())

  991.             {

  992.                 Image temp (component.isOpaque() ? Image::RGB : Image::ARGB,

  993.                             roundToInt (clipW * displayScale),

  994.                             roundToInt (clipH * displayScale),

  995.                             ! component.isOpaque());

  996. 

  997.                 {

  998.                     auto intScale = roundToInt (displayScale);

  999. 

  1000.                     if (intScale != 1)

  1001.                         clip.scaleAll (intScale);

  1002. 

  1003.                     auto context = component.getLookAndFeel()

  1004.                                             .createGraphicsContext (temp, offset * intScale, clip);

  1005. 

  1006.                     if (intScale != 1)

  1007.                         context->addTransform (AffineTransform::scale (displayScale));

  1008. 

  1009.                     handlePaint (*context);

  1010.                 }

  1011. 

  1012.                 detail::ColorSpacePtr colourSpace { CGColorSpaceCreateWithName (kCGColorSpaceSRGB) };

  1013.                 CGImageRef image = juce_createCoreGraphicsImage (temp, colourSpace.get());

  1014.                 CGContextConcatCTM (cg, CGAffineTransformMake (1, 0, 0, -1, r.origin.x, r.origin.y + clipH));

  1015.                 CGContextDrawImage (cg, CGRectMake (0.0f, 0.0f, clipW, clipH), image);

  1016.                 CGImageRelease (image);

  1017.             }

  1018.         }

  1019.     }

  1020. 

  1021.     void repaint (const Rectangle<int>& area) override

  1022.     {

  1023.         // In 10.11 changes were made to the way the OS handles repaint regions, and it seems that it can

  1024.         // no longer be trusted to coalesce all the regions, or to even remember them all without losing

  1025.         // a few when there's a lot of activity.

  1026.         // As a work around for this, we use a RectangleList to do our own coalescing of regions before

  1027.         // asynchronously asking the OS to repaint them.

  1028.         deferredRepaints.add ((float) area.getX(), (float) area.getY(),

  1029.                               (float) area.getWidth(), (float) area.getHeight());

  1030. 

  1031.         if (isTimerRunning())

  1032.             return;

  1033. 

  1034.         auto now = Time::getMillisecondCounter();

  1035.         auto msSinceLastRepaint = (lastRepaintTime >= now) ? now - lastRepaintTime

  1036.                                                            : (std::numeric_limits<uint32>::max() - lastRepaintTime) + now;

  1037. 

  1038.         static uint32 minimumRepaintInterval = 1000 / 30; // 30fps

  1039. 

  1040.         // When windows are being resized, artificially throttling high-frequency repaints helps

  1041.         // to stop the event queue getting clogged, and keeps everything working smoothly.

  1042.         // For some reason Logic also needs this throttling to record parameter events correctly.

  1043.         if (msSinceLastRepaint < minimumRepaintInterval && shouldThrottleRepaint())

  1044.         {

  1045.             startTimer (static_cast<int> (minimumRepaintInterval - msSinceLastRepaint));

  1046.             return;

  1047.         }

  1048. 

  1049.         setNeedsDisplayRectangles();

  1050.     }

  1051. 

  1052.     static bool shouldThrottleRepaint()

  1053.     {

  1054.         return areAnyWindowsInLiveResize() || ! JUCEApplication::isStandaloneApp();

  1055.     }

  1056. 

  1057.     void timerCallback() override

  1058.     {

  1059.         setNeedsDisplayRectangles();

  1060.         stopTimer();

  1061.     }

  1062. 

  1063.     void setNeedsDisplayRectangles()

  1064.     {

  1065.         for (auto& i : deferredRepaints)

  1066.             [view setNeedsDisplayInRect: makeNSRect (i)];

  1067. 

  1068.         lastRepaintTime = Time::getMillisecondCounter();

  1069.         deferredRepaints.clear();

  1070.     }

  1071. 

  1072.     void performAnyPendingRepaintsNow() override

  1073.     {

  1074.         [view displayIfNeeded];

  1075.     }

  1076. 

  1077.     static bool areAnyWindowsInLiveResize() noexcept

  1078.     {

  1079.         for (NSWindow* w in [NSApp windows])

  1080.             if ([w inLiveResize])

  1081.                 return true;

  1082. 

  1083.         return false;

  1084.     }

  1085. 

  1086.     //==============================================================================

  1087.     bool isBlockedByModalComponent()

  1088.     {

  1089.         if (auto* modal = Component::getCurrentlyModalComponent())

  1090.         {

  1091.             if (insideToFrontCall == 0

  1092.                  && (! getComponent().isParentOf (modal))

  1093.                  && getComponent().isCurrentlyBlockedByAnotherModalComponent())

  1094.             {

  1095.                 return true;

  1096.             }

  1097.         }

  1098. 

  1099.         return false;

  1100.     }

  1101. 

  1102.     enum class KeyWindowChanged { no, yes };

  1103. 

  1104.     void sendModalInputAttemptIfBlocked (KeyWindowChanged keyChanged)

  1105.     {

  1106.         if (! isBlockedByModalComponent())

  1107.             return;

  1108. 

  1109.         if (auto* modal = Component::getCurrentlyModalComponent())

  1110.         {

  1111.             if (auto* otherPeer = modal->getPeer())

  1112.             {

  1113.                 const auto modalPeerIsTemporary = (otherPeer->getStyleFlags() & ComponentPeer::windowIsTemporary) != 0;

  1114. 

  1115.                 if (! modalPeerIsTemporary)

  1116.                     return;

  1117. 

  1118.                 // When a peer resigns key status, it might be because we just created a modal

  1119.                 // component that is now key.

  1120.                 // In this case, we should only dismiss the modal component if it isn't key,

  1121.                 // implying that a third window has become key.

  1122.                 const auto modalPeerIsKey = [NSApp keyWindow] == static_cast<NSViewComponentPeer*> (otherPeer)->window;

  1123. 

  1124.                 if (keyChanged == KeyWindowChanged::yes && modalPeerIsKey)

  1125.                     return;

  1126. 

  1127.                 modal->inputAttemptWhenModal();

  1128.             }

  1129.         }

  1130.     }

  1131. 

  1132.     bool canBecomeKeyWindow()

  1133.     {

  1134.         return component.isVisible() && (getStyleFlags() & ComponentPeer::windowIgnoresKeyPresses) == 0;

  1135.     }

  1136. 

  1137.     bool canBecomeMainWindow()

  1138.     {

  1139.         return component.isVisible() && dynamic_cast<ResizableWindow*> (&component) != nullptr;

  1140.     }

  1141. 

  1142.     bool worksWhenModal() const

  1143.     {

  1144.         // In plugins, the host could put our plugin window inside a modal window, so this

  1145.         // allows us to successfully open other popups. Feels like there could be edge-case

  1146.         // problems caused by this, so let us know if you spot any issues..

  1147.         return ! JUCEApplication::isStandaloneApp();

  1148.     }

  1149. 

  1150.     void becomeKeyWindow()

  1151.     {

  1152.         handleBroughtToFront();

  1153.         grabFocus();

  1154.     }

  1155. 

  1156.     void resignKeyWindow()

  1157.     {

  1158.         viewFocusLoss();

  1159.     }

  1160. 

  1161.     bool windowShouldClose()

  1162.     {

  1163.         if (! isValidPeer (this))

  1164.             return YES;

  1165. 

  1166.         handleUserClosingWindow();

  1167.         return NO;

  1168.     }

  1169. 

  1170.     void redirectMovedOrResized()

  1171.     {

  1172.         handleMovedOrResized();

  1173.     }

  1174. 

  1175.     void viewMovedToWindow()

  1176.     {

  1177.         if (isSharedWindow)

  1178.         {

  1179.             auto newWindow = [view window];

  1180.             bool shouldSetVisible = (window == nullptr && newWindow != nullptr);

  1181. 

  1182.             window = newWindow;

  1183. 

  1184.             if (shouldSetVisible)

  1185.                 getComponent().setVisible (true);

  1186.         }

  1187. 

  1188.         if (auto* currentWindow = [view window])

  1189.         {

  1190.             [notificationCenter addObserver: view

  1191.                                    selector: dismissModalsSelector

  1192.                                        name: NSWindowWillMoveNotification

  1193.                                      object: currentWindow];

  1194. 

  1195.             [notificationCenter addObserver: view

  1196.                                    selector: dismissModalsSelector

  1197.                                        name: NSWindowWillMiniaturizeNotification

  1198.                                      object: currentWindow];

  1199. 

  1200.             [notificationCenter addObserver: view

  1201.                                    selector: becomeKeySelector

  1202.                                        name: NSWindowDidBecomeKeyNotification

  1203.                                      object: currentWindow];

  1204. 

  1205.             [notificationCenter addObserver: view

  1206.                                    selector: resignKeySelector

  1207.                                        name: NSWindowDidResignKeyNotification

  1208.                                      object: currentWindow];

  1209.         }

  1210.     }

  1211. 

  1212.     void dismissModals()

  1213.     {

  1214.         if (hasNativeTitleBar() || isSharedWindow)

  1215.             sendModalInputAttemptIfBlocked (KeyWindowChanged::no);

  1216.     }

  1217. 

  1218.     void becomeKey()

  1219.     {

  1220.         component.repaint();

  1221.     }

  1222. 

  1223.     void resignKey()

  1224.     {

  1225.         viewFocusLoss();

  1226.         sendModalInputAttemptIfBlocked (KeyWindowChanged::yes);

  1227.     }

  1228. 

  1229.     void liveResizingStart()

  1230.     {

  1231.         if (constrainer == nullptr)

  1232.             return;

  1233. 

  1234.         constrainer->resizeStart();

  1235.         isFirstLiveResize = true;

  1236. 

  1237.         setFullScreenSizeConstraints (*constrainer);

  1238.     }

  1239. 

  1240.     void liveResizingEnd()

  1241.     {

  1242.         if (constrainer != nullptr)

  1243.             constrainer->resizeEnd();

  1244.     }

  1245. 

  1246.     NSRect constrainRect (const NSRect r)

  1247.     {

  1248.         if (constrainer == nullptr || isKioskMode() || isFullScreen())

  1249.             return r;

  1250. 

  1251.         const auto scale = getComponent().getDesktopScaleFactor();

  1252. 

  1253.         auto pos            = ScalingHelpers::unscaledScreenPosToScaled (scale, convertToRectInt (flippedScreenRect (r)));

  1254.         const auto original = ScalingHelpers::unscaledScreenPosToScaled (scale, convertToRectInt (flippedScreenRect ([window frame])));

  1255. 

  1256.         const auto screenBounds = Desktop::getInstance().getDisplays().getTotalBounds (true);

  1257. 

  1258.         const bool inLiveResize = [window inLiveResize];

  1259. 

  1260.         if (! inLiveResize || isFirstLiveResize)

  1261.         {

  1262.             isFirstLiveResize = false;

  1263. 

  1264.             isStretchingTop    = (pos.getY() != original.getY() && pos.getBottom() == original.getBottom());

  1265.             isStretchingLeft   = (pos.getX() != original.getX() && pos.getRight()  == original.getRight());

  1266.             isStretchingBottom = (pos.getY() == original.getY() && pos.getBottom() != original.getBottom());

  1267.             isStretchingRight  = (pos.getX() == original.getX() && pos.getRight()  != original.getRight());

  1268.         }

  1269. 

  1270.         constrainer->checkBounds (pos, original, screenBounds,

  1271.                                   isStretchingTop, isStretchingLeft, isStretchingBottom, isStretchingRight);

  1272. 

  1273.         return flippedScreenRect (makeNSRect (ScalingHelpers::scaledScreenPosToUnscaled (scale, pos)));

  1274.     }

  1275. 

  1276.     static void showArrowCursorIfNeeded()

  1277.     {

  1278.         auto& desktop = Desktop::getInstance();

  1279.         auto mouse = desktop.getMainMouseSource();

  1280. 

  1281.         if (mouse.getComponentUnderMouse() == nullptr

  1282.              && desktop.findComponentAt (mouse.getScreenPosition().roundToInt()) == nullptr)

  1283.         {

  1284.             [[NSCursor arrowCursor] set];

  1285.         }

  1286.     }

  1287. 

  1288.     static void updateModifiers (NSEvent* e)

  1289.     {

  1290.         updateModifiers ([e modifierFlags]);

  1291.     }

  1292. 

  1293.     static void updateModifiers (const NSUInteger flags)

  1294.     {

  1295.         int m = 0;

  1296. 

  1297.         if ((flags & NSEventModifierFlagShift) != 0)        m |= ModifierKeys::shiftModifier;

  1298.         if ((flags & NSEventModifierFlagControl) != 0)      m |= ModifierKeys::ctrlModifier;

  1299.         if ((flags & NSEventModifierFlagOption) != 0)       m |= ModifierKeys::altModifier;

  1300.         if ((flags & NSEventModifierFlagCommand) != 0)      m |= ModifierKeys::commandModifier;

  1301. 

  1302.         ModifierKeys::currentModifiers = ModifierKeys::currentModifiers.withOnlyMouseButtons().withFlags (m);

  1303.     }

  1304. 

  1305.     static void updateKeysDown (NSEvent* ev, bool isKeyDown)

  1306.     {

  1307.         updateModifiers (ev);

  1308. 

  1309.         if (auto keyCode = getKeyCodeFromEvent (ev))

  1310.         {

  1311.             if (isKeyDown)

  1312.                 keysCurrentlyDown.addIfNotAlreadyThere (keyCode);

  1313.             else

  1314.                 keysCurrentlyDown.removeFirstMatchingValue (keyCode);

  1315.         }

  1316.     }

  1317. 

  1318.     static int getKeyCodeFromEvent (NSEvent* ev)

  1319.     {

  1320.         // Unfortunately, charactersIgnoringModifiers does not ignore the shift key.

  1321.         // Using [ev keyCode] is not a solution either as this will,

  1322.         // for example, return VK_KEY_Y if the key is pressed which

  1323.         // is typically located at the Y key position on a QWERTY

  1324.         // keyboard. However, on international keyboards this might not

  1325.         // be the key labeled Y (for example, on German keyboards this key

  1326.         // has a Z label). Therefore, we need to query the current keyboard

  1327.         // layout to figure out what character the key would have produced

  1328.         // if the shift key was not pressed

  1329.         String unmodified;

  1330. 

  1331.        #if JUCE_SUPPORT_CARBON

  1332.         if (auto currentKeyboard = CFUniquePtr<TISInputSourceRef> (TISCopyCurrentKeyboardInputSource()))

  1333.         {

  1334.             if (auto layoutData = (CFDataRef) TISGetInputSourceProperty (currentKeyboard,

  1335.                                                                          kTISPropertyUnicodeKeyLayoutData))

  1336.             {

  1337.                 if (auto* layoutPtr = (const UCKeyboardLayout*) CFDataGetBytePtr (layoutData))

  1338.                 {

  1339.                     UInt32 keysDown = 0;

  1340.                     UniChar buffer[4];

  1341.                     UniCharCount actual;

  1342. 

  1343.                     if (UCKeyTranslate (layoutPtr, [ev keyCode], kUCKeyActionDown, 0, LMGetKbdType(),

  1344.                                         kUCKeyTranslateNoDeadKeysBit, &keysDown, sizeof (buffer) / sizeof (UniChar),

  1345.                                         &actual, buffer) == 0)

  1346.                         unmodified = String (CharPointer_UTF16 (reinterpret_cast<CharPointer_UTF16::CharType*> (buffer)), 4);

  1347.                 }

  1348.             }

  1349.         }

  1350. 

  1351.         // did the above layout conversion fail

  1352.         if (unmodified.isEmpty())

  1353.        #endif

  1354.         {

  1355.             unmodified = nsStringToJuce ([ev charactersIgnoringModifiers]);

  1356.         }

  1357. 

  1358.         auto keyCode = (int) unmodified[0];

  1359. 

  1360.         if (keyCode == 0x19) // (backwards-tab)

  1361.             keyCode = '\t';

  1362.         else if (keyCode == 0x03) // (enter)

  1363.             keyCode = '\r';

  1364.         else

  1365.             keyCode = (int) CharacterFunctions::toUpperCase ((juce_wchar) keyCode);

  1366. 

  1367.         // The purpose of the keyCode is to provide information about non-printing characters to facilitate

  1368.         // keyboard control over the application.

  1369.         //

  1370.         // So when keyCode is decoded as a printing character outside the ASCII range we need to replace it.

  1371.         // This holds when the keyCode is larger than 0xff and not part one of the two MacOS specific

  1372.         // non-printing ranges.

  1373.         if (keyCode > 0xff

  1374.             && ! (keyCode >= NSUpArrowFunctionKey && keyCode <= NSModeSwitchFunctionKey)

  1375.             && ! (keyCode >= extendedKeyModifier))

  1376.         {

  1377.             keyCode = translateVirtualToAsciiKeyCode ([ev keyCode]);

  1378.         }

  1379. 

  1380.         if (([ev modifierFlags] & NSEventModifierFlagNumericPad) != 0)

  1381.         {

  1382.             const int numPadConversions[] = { '0', KeyPress::numberPad0, '1', KeyPress::numberPad1,

  1383.                                               '2', KeyPress::numberPad2, '3', KeyPress::numberPad3,

  1384.                                               '4', KeyPress::numberPad4, '5', KeyPress::numberPad5,

  1385.                                               '6', KeyPress::numberPad6, '7', KeyPress::numberPad7,

  1386.                                               '8', KeyPress::numberPad8, '9', KeyPress::numberPad9,

  1387.                                               '+', KeyPress::numberPadAdd, '-', KeyPress::numberPadSubtract,

  1388.                                               '*', KeyPress::numberPadMultiply, '/', KeyPress::numberPadDivide,

  1389.                                               '.', KeyPress::numberPadDecimalPoint,

  1390.                                               ',', KeyPress::numberPadDecimalPoint, // (to deal with non-english kbds)

  1391.                                               '=', KeyPress::numberPadEquals };

  1392. 

  1393.             for (int i = 0; i < numElementsInArray (numPadConversions); i += 2)

  1394.                 if (keyCode == numPadConversions [i])

  1395.                     keyCode = numPadConversions [i + 1];

  1396.         }

  1397. 

  1398.         return keyCode;

  1399.     }

  1400. 

  1401.     static int64 getMouseTime (NSEvent* e) noexcept

  1402.     {

  1403.         return (Time::currentTimeMillis() - Time::getMillisecondCounter())

  1404.                  + (int64) ([e timestamp] * 1000.0);

  1405.     }

  1406. 

  1407.     static float getMousePressure (NSEvent* e) noexcept

  1408.     {

  1409.         @try

  1410.         {

  1411.             if (e.type != NSEventTypeMouseEntered && e.type != NSEventTypeMouseExited)

  1412.                 return (float) e.pressure;

  1413.         }

  1414.         @catch (NSException* e) {}

  1415.         @finally {}

  1416. 

  1417.         return 0.0f;

  1418.     }

  1419. 

  1420.     static Point<float> getMousePos (NSEvent* e, NSView* view)

  1421.     {

  1422.         NSPoint p = [view convertPoint: [e locationInWindow] fromView: nil];

  1423.         return { (float) p.x, (float) p.y };

  1424.     }

  1425. 

  1426.     static int getModifierForButtonNumber (const NSInteger num)

  1427.     {

  1428.         return num == 0 ? ModifierKeys::leftButtonModifier

  1429.                         : (num == 1 ? ModifierKeys::rightButtonModifier

  1430.                                     : (num == 2 ? ModifierKeys::middleButtonModifier : 0));

  1431.     }

  1432. 

  1433.     static unsigned int getNSWindowStyleMask (const int flags) noexcept

  1434.     {

  1435.         unsigned int style = (flags & windowHasTitleBar) != 0 ? NSWindowStyleMaskTitled

  1436.                                                               : NSWindowStyleMaskBorderless;

  1437. 

  1438.         if ((flags & windowHasMinimiseButton) != 0)  style |= NSWindowStyleMaskMiniaturizable;

  1439.         if ((flags & windowHasCloseButton) != 0)     style |= NSWindowStyleMaskClosable;

  1440.         if ((flags & windowIsResizable) != 0)        style |= NSWindowStyleMaskResizable;

  1441.         return style;

  1442.     }

  1443. 

  1444.     static NSArray* getSupportedDragTypes()

  1445.     {

  1446.         const auto type = []

  1447.         {

  1448.            #if defined (MAC_OS_X_VERSION_10_13) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_13

  1449.             if (@available (macOS 10.13, *))

  1450.                 return NSPasteboardTypeFileURL;

  1451.            #endif

  1452. 

  1453.             JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wdeprecated-declarations")

  1454.             return (NSString*) kUTTypeFileURL;

  1455.             JUCE_END_IGNORE_WARNINGS_GCC_LIKE

  1456.         }();

  1457. 

  1458.         return [NSArray arrayWithObjects: type, (NSString*) kPasteboardTypeFileURLPromise, NSPasteboardTypeString, nil];

  1459.     }

  1460. 

  1461.     BOOL sendDragCallback (bool (ComponentPeer::* callback) (const DragInfo&), id <NSDraggingInfo> sender)

  1462.     {

  1463.         NSPasteboard* pasteboard = [sender draggingPasteboard];

  1464.         NSString* contentType = [pasteboard availableTypeFromArray: getSupportedDragTypes()];

  1465. 

  1466.         if (contentType == nil)

  1467.             return false;

  1468. 

  1469.         const auto p = localToGlobal (convertToPointFloat ([view convertPoint: [sender draggingLocation] fromView: nil]));

  1470. 

  1471.         ComponentPeer::DragInfo dragInfo;

  1472.         dragInfo.position = ScalingHelpers::screenPosToLocalPos (component, p).roundToInt();

  1473. 

  1474.         if (contentType == NSPasteboardTypeString)

  1475.             dragInfo.text = nsStringToJuce ([pasteboard stringForType: NSPasteboardTypeString]);

  1476.         else

  1477.             dragInfo.files = getDroppedFiles (pasteboard, contentType);

  1478. 

  1479.         if (! dragInfo.isEmpty())

  1480.             return (this->*callback) (dragInfo);

  1481. 

  1482.         return false;

  1483.     }

  1484. 

  1485.     StringArray getDroppedFiles (NSPasteboard* pasteboard, NSString* contentType)

  1486.     {

  1487.         StringArray files;

  1488.         NSString* iTunesPasteboardType = nsStringLiteral ("CorePasteboardFlavorType 0x6974756E"); // 'itun'

  1489. 

  1490.         if ([contentType isEqualToString: (NSString*) kPasteboardTypeFileURLPromise]

  1491.              && [[pasteboard types] containsObject: iTunesPasteboardType])

  1492.         {

  1493.             id list = [pasteboard propertyListForType: iTunesPasteboardType];

  1494. 

  1495.             if ([list isKindOfClass: [NSDictionary class]])

  1496.             {

  1497.                 NSDictionary* iTunesDictionary = (NSDictionary*) list;

  1498.                 NSArray* tracks = [iTunesDictionary valueForKey: nsStringLiteral ("Tracks")];

  1499.                 NSEnumerator* enumerator = [tracks objectEnumerator];

  1500.                 NSDictionary* track;

  1501. 

  1502.                 while ((track = [enumerator nextObject]) != nil)

  1503.                 {

  1504.                     if (id value = [track valueForKey: nsStringLiteral ("Location")])

  1505.                     {

  1506.                         NSURL* url = [NSURL URLWithString: value];

  1507. 

  1508.                         if ([url isFileURL])

  1509.                             files.add (nsStringToJuce ([url path]));

  1510.                     }

  1511.                 }

  1512.             }

  1513.         }

  1514.         else

  1515.         {

  1516.             NSArray* items = [pasteboard readObjectsForClasses:@[[NSURL class]] options: nil];

  1517. 

  1518.             for (unsigned int i = 0; i < [items count]; ++i)

  1519.             {

  1520.                 NSURL* url = [items objectAtIndex: i];

  1521. 

  1522.                 if ([url isFileURL])

  1523.                     files.add (nsStringToJuce ([url path]));

  1524.             }

  1525.         }

  1526. 

  1527.         return files;

  1528.     }

  1529. 

  1530.     //==============================================================================

  1531.     void viewFocusGain()

  1532.     {

  1533.         if (currentlyFocusedPeer != this)

  1534.         {

  1535.             if (ComponentPeer::isValidPeer (currentlyFocusedPeer))

  1536.                 currentlyFocusedPeer->handleFocusLoss();

  1537. 

  1538.             currentlyFocusedPeer = this;

  1539.             handleFocusGain();

  1540.         }

  1541.     }

  1542. 

  1543.     void viewFocusLoss()

  1544.     {

  1545.         if (currentlyFocusedPeer == this)

  1546.         {

  1547.             currentlyFocusedPeer = nullptr;

  1548.             handleFocusLoss();

  1549.         }

  1550.     }

  1551. 

  1552.     bool isFocused() const override

  1553.     {

  1554.         return (isSharedWindow || ! JUCEApplication::isStandaloneApp())

  1555.                     ? this == currentlyFocusedPeer

  1556.                     : [window isKeyWindow];

  1557.     }

  1558. 

  1559.     void grabFocus() override

  1560.     {

  1561.         if (window != nil)

  1562.         {

  1563.             [window makeKeyWindow];

  1564.             [window makeFirstResponder: view];

  1565. 

  1566.             viewFocusGain();

  1567.         }

  1568.     }

  1569. 

  1570.     void textInputRequired (Point<int>, TextInputTarget&) override {}

  1571. 

  1572.     void dismissPendingTextInput() override

  1573.     {

  1574.         stringBeingComposed.clear();

  1575.         const auto* inputContext = [NSTextInputContext currentInputContext];

  1576. 

  1577.         if (inputContext != nil)

  1578.             [inputContext discardMarkedText];

  1579.     }

  1580. 

  1581.     void resetWindowPresentation()

  1582.     {

  1583.         if (hasNativeTitleBar())

  1584.         {

  1585.             [window setStyleMask: (NSViewComponentPeer::getNSWindowStyleMask (getStyleFlags()))];

  1586.             setTitle (getComponent().getName()); // required to force the OS to update the title

  1587.         }

  1588. 

  1589.         [NSApp setPresentationOptions: NSApplicationPresentationDefault];

  1590.         setCollectionBehaviour (isFullScreen());

  1591.     }

  1592. 

  1593.     void setHasChangedSinceSaved (bool b) override

  1594.     {

  1595.         if (! isSharedWindow)

  1596.             [window setDocumentEdited: b];

  1597.     }

  1598. 

  1599.     //==============================================================================

  1600.     NSWindow* window = nil;

  1601.     NSView* view = nil;

  1602.     WeakReference<Component> safeComponent;

  1603.     bool isSharedWindow = false;

  1604.    #if USE_COREGRAPHICS_RENDERING

  1605.     bool usingCoreGraphics = true;

  1606.    #else

  1607.     bool usingCoreGraphics = false;

  1608.    #endif

  1609.     bool isZooming = false, isFirstLiveResize = false, textWasInserted = false;

  1610.     bool isStretchingTop = false, isStretchingLeft = false, isStretchingBottom = false, isStretchingRight = false;

  1611.     bool windowRepresentsFile = false;

  1612.     bool isAlwaysOnTop = false, wasAlwaysOnTop = false;

  1613.     String stringBeingComposed;

  1614.     NSNotificationCenter* notificationCenter = nil;

  1615. 

  1616.     Rectangle<float> lastSizeBeforeZoom;

  1617.     RectangleList<float> deferredRepaints;

  1618.     uint32 lastRepaintTime;

  1619. 

  1620.     static ComponentPeer* currentlyFocusedPeer;

  1621.     static Array<int> keysCurrentlyDown;

  1622.     static int insideToFrontCall;

  1623. 

  1624.     static const SEL dismissModalsSelector;

  1625.     static const SEL frameChangedSelector;

  1626.     static const SEL asyncMouseDownSelector;

  1627.     static const SEL asyncMouseUpSelector;

  1628.     static const SEL becomeKeySelector;

  1629.     static const SEL resignKeySelector;

  1630. 

  1631. private:

  1632.     static NSView* createViewInstance();

  1633.     static NSWindow* createWindowInstance();

  1634. 

  1635.     void sendMouseEnterExit (NSEvent* ev)

  1636.     {

  1637.         if (auto* area = [ev trackingArea])

  1638.             if (! [[view trackingAreas] containsObject: area])

  1639.                 return;

  1640. 

  1641.         sendMouseEvent (ev);

  1642.     }

  1643. 

  1644.     static void setOwner (id viewOrWindow, NSViewComponentPeer* newOwner)

  1645.     {

  1646.         object_setInstanceVariable (viewOrWindow, "owner", newOwner);

  1647.     }

  1648. 

  1649.     void getClipRects (RectangleList<int>& clip, Point<int> offset, int clipW, int clipH)

  1650.     {

  1651.         const NSRect* rects = nullptr;

  1652.         NSInteger numRects = 0;

  1653.         [view getRectsBeingDrawn: &rects count: &numRects];

  1654. 

  1655.         const Rectangle<int> clipBounds (clipW, clipH);

  1656. 

  1657.         clip.ensureStorageAllocated ((int) numRects);

  1658. 

  1659.         for (int i = 0; i < numRects; ++i)

  1660.             clip.addWithoutMerging (clipBounds.getIntersection (Rectangle<int> (roundToInt (rects[i].origin.x) + offset.x,

  1661.                                                                                 roundToInt (rects[i].origin.y) + offset.y,

  1662.                                                                                 roundToInt (rects[i].size.width),

  1663.                                                                                 roundToInt (rects[i].size.height))));

  1664.     }

  1665. 

  1666.     static void appFocusChanged()

  1667.     {

  1668.         keysCurrentlyDown.clear();

  1669. 

  1670.         if (isValidPeer (currentlyFocusedPeer))

  1671.         {

  1672.             if (Process::isForegroundProcess())

  1673.             {

  1674.                 currentlyFocusedPeer->handleFocusGain();

  1675.                 ModalComponentManager::getInstance()->bringModalComponentsToFront();

  1676.             }

  1677.             else

  1678.             {

  1679.                 currentlyFocusedPeer->handleFocusLoss();

  1680.             }

  1681.         }

  1682.     }

  1683. 

  1684.     static bool checkEventBlockedByModalComps (NSEvent* e)

  1685.     {

  1686.         if (Component::getNumCurrentlyModalComponents() == 0)

  1687.             return false;

  1688. 

  1689.         NSWindow* const w = [e window];

  1690. 

  1691.         if (w == nil || [w worksWhenModal])

  1692.             return false;

  1693. 

  1694.         bool isKey = false, isInputAttempt = false;

  1695. 

  1696.         switch ([e type])

  1697.         {

  1698.             case NSEventTypeKeyDown:

  1699.             case NSEventTypeKeyUp:

  1700.                 isKey = isInputAttempt = true;

  1701.                 break;

  1702. 

  1703.             case NSEventTypeLeftMouseDown:

  1704.             case NSEventTypeRightMouseDown:

  1705.             case NSEventTypeOtherMouseDown:

  1706.                 isInputAttempt = true;

  1707.                 break;

  1708. 

  1709.             case NSEventTypeLeftMouseDragged:

  1710.             case NSEventTypeRightMouseDragged:

  1711.             case NSEventTypeLeftMouseUp:

  1712.             case NSEventTypeRightMouseUp:

  1713.             case NSEventTypeOtherMouseUp:

  1714.             case NSEventTypeOtherMouseDragged:

  1715.                 if (Desktop::getInstance().getDraggingMouseSource(0) != nullptr)

  1716.                     return false;

  1717.                 break;

  1718. 

  1719.             case NSEventTypeMouseMoved:

  1720.             case NSEventTypeMouseEntered:

  1721.             case NSEventTypeMouseExited:

  1722.             case NSEventTypeCursorUpdate:

  1723.             case NSEventTypeScrollWheel:

  1724.             case NSEventTypeTabletPoint:

  1725.             case NSEventTypeTabletProximity:

  1726.                 break;

  1727. 

  1728.             case NSEventTypeFlagsChanged:

  1729.             case NSEventTypeAppKitDefined:

  1730.             case NSEventTypeSystemDefined:

  1731.             case NSEventTypeApplicationDefined:

  1732.             case NSEventTypePeriodic:

  1733.             case NSEventTypeGesture:

  1734.             case NSEventTypeMagnify:

  1735.             case NSEventTypeSwipe:

  1736.             case NSEventTypeRotate:

  1737.             case NSEventTypeBeginGesture:

  1738.             case NSEventTypeEndGesture:

  1739.             case NSEventTypeQuickLook:

  1740.            #if JUCE_64BIT

  1741.             case NSEventTypeSmartMagnify:

  1742.             case NSEventTypePressure:

  1743.            #endif

  1744.           #if defined (MAC_OS_X_VERSION_10_12) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_12

  1745.            #if JUCE_64BIT

  1746.             case NSEventTypeDirectTouch:

  1747.            #endif

  1748.            #if defined (MAC_OS_X_VERSION_10_15) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_15

  1749.             case NSEventTypeChangeMode:

  1750.            #endif

  1751.           #endif

  1752.             default:

  1753.                 return false;

  1754.         }

  1755. 

  1756.         for (int i = ComponentPeer::getNumPeers(); --i >= 0;)

  1757.         {

  1758.             if (auto* peer = dynamic_cast<NSViewComponentPeer*> (ComponentPeer::getPeer (i)))

  1759.             {

  1760.                 if ([peer->view window] == w)

  1761.                 {

  1762.                     if (isKey)

  1763.                     {

  1764.                         if (peer->view == [w firstResponder])

  1765.                             return false;

  1766.                     }

  1767.                     else

  1768.                     {

  1769.                         if (peer->isSharedWindow

  1770.                                ? NSPointInRect ([peer->view convertPoint: [e locationInWindow] fromView: nil], [peer->view bounds])

  1771.                                : NSPointInRect ([e locationInWindow], NSMakeRect (0, 0, [w frame].size.width, [w frame].size.height)))

  1772.                             return false;

  1773.                     }

  1774.                 }

  1775.             }

  1776.         }

  1777. 

  1778.         if (isInputAttempt)

  1779.         {

  1780.             if (! [NSApp isActive])

  1781.                 [NSApp activateIgnoringOtherApps: YES];

  1782. 

  1783.             if (auto* modal = Component::getCurrentlyModalComponent())

  1784.                 modal->inputAttemptWhenModal();

  1785.         }

  1786. 

  1787.         return true;

  1788.     }

  1789. 

  1790.     void setFullScreenSizeConstraints (const ComponentBoundsConstrainer& c)

  1791.     {

  1792.         const auto minSize = NSMakeSize (static_cast<float> (c.getMinimumWidth()),

  1793.                                          0.0f);

  1794.         [window setMinFullScreenContentSize: minSize];

  1795.         [window setMaxFullScreenContentSize: NSMakeSize (100000, 100000)];

  1796.     }

  1797. 

  1798.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (NSViewComponentPeer)

  1799. };

  1800. 

  1801. int NSViewComponentPeer::insideToFrontCall = 0;

  1802. 

  1803. JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wundeclared-selector")

  1804. const SEL NSViewComponentPeer::dismissModalsSelector  = @selector (dismissModals);

  1805. const SEL NSViewComponentPeer::frameChangedSelector   = @selector (frameChanged:);

  1806. const SEL NSViewComponentPeer::asyncMouseDownSelector = @selector (asyncMouseDown:);

  1807. const SEL NSViewComponentPeer::asyncMouseUpSelector   = @selector (asyncMouseUp:);

  1808. const SEL NSViewComponentPeer::becomeKeySelector      = @selector (becomeKey:);

  1809. const SEL NSViewComponentPeer::resignKeySelector      = @selector (resignKey:);

  1810. JUCE_END_IGNORE_WARNINGS_GCC_LIKE

  1811. 

  1812. //==============================================================================

  1813. template <typename Base>

  1814. struct NSViewComponentPeerWrapper  : public Base

  1815. {

  1816.     explicit NSViewComponentPeerWrapper (const char* baseName)

  1817.         : Base (baseName)

  1818.     {

  1819.         Base::template addIvar<NSViewComponentPeer*> ("owner");

  1820.     }

  1821. 

  1822.     static NSViewComponentPeer* getOwner (id self)

  1823.     {

  1824.         return getIvar<NSViewComponentPeer*> (self, "owner");

  1825.     }

  1826. 

  1827.     static id getAccessibleChild (id self)

  1828.     {

  1829.         if (auto* owner = getOwner (self))

  1830.             if (auto* handler = owner->getComponent().getAccessibilityHandler())

  1831.                 return (id) handler->getNativeImplementation();

  1832. 

  1833.         return nil;

  1834.     }

  1835. };

  1836. 

  1837. struct JuceNSViewClass   : public NSViewComponentPeerWrapper<ObjCClass<NSView>>

  1838. {

  1839.     JuceNSViewClass()  : NSViewComponentPeerWrapper ("JUCEView_")

  1840.     {

  1841.         addMethod (@selector (isOpaque),                      isOpaque);

  1842.         addMethod (@selector (drawRect:),                     drawRect);

  1843.         addMethod (@selector (mouseDown:),                    mouseDown);

  1844.         addMethod (@selector (mouseUp:),                      mouseUp);

  1845.         addMethod (@selector (mouseDragged:),                 mouseDragged);

  1846.         addMethod (@selector (mouseMoved:),                   mouseMoved);

  1847.         addMethod (@selector (mouseEntered:),                 mouseEntered);

  1848.         addMethod (@selector (mouseExited:),                  mouseExited);

  1849.         addMethod (@selector (rightMouseDown:),               mouseDown);

  1850.         addMethod (@selector (rightMouseDragged:),            mouseDragged);

  1851.         addMethod (@selector (rightMouseUp:),                 mouseUp);

  1852.         addMethod (@selector (otherMouseDown:),               mouseDown);

  1853.         addMethod (@selector (otherMouseDragged:),            mouseDragged);

  1854.         addMethod (@selector (otherMouseUp:),                 mouseUp);

  1855.         addMethod (@selector (scrollWheel:),                  scrollWheel);

  1856.         addMethod (@selector (magnifyWithEvent:),             magnify);

  1857.         addMethod (@selector (acceptsFirstMouse:),            acceptsFirstMouse);

  1858.         addMethod (@selector (windowWillMiniaturize:),        windowWillMiniaturize);

  1859.         addMethod (@selector (windowDidDeminiaturize:),       windowDidDeminiaturize);

  1860.         addMethod (@selector (wantsDefaultClipping),          wantsDefaultClipping);

  1861.         addMethod (@selector (worksWhenModal),                worksWhenModal);

  1862.         addMethod (@selector (viewDidMoveToWindow),           viewDidMoveToWindow);

  1863.         addMethod (@selector (viewWillDraw),                  viewWillDraw);

  1864.         addMethod (@selector (keyDown:),                      keyDown);

  1865.         addMethod (@selector (keyUp:),                        keyUp);

  1866.         addMethod (@selector (insertText:),                   insertText);

  1867.         addMethod (@selector (doCommandBySelector:),          doCommandBySelector);

  1868.         addMethod (@selector (setMarkedText:selectedRange:),  setMarkedText);

  1869.         addMethod (@selector (unmarkText),                    unmarkText);

  1870.         addMethod (@selector (hasMarkedText),                 hasMarkedText);

  1871.         addMethod (@selector (conversationIdentifier),        conversationIdentifier);

  1872.         addMethod (@selector (attributedSubstringFromRange:), attributedSubstringFromRange);

  1873.         addMethod (@selector (markedRange),                   markedRange);

  1874.         addMethod (@selector (selectedRange),                 selectedRange);

  1875.         addMethod (@selector (firstRectForCharacterRange:),   firstRectForCharacterRange);

  1876.         addMethod (@selector (characterIndexForPoint:),       characterIndexForPoint);

  1877.         addMethod (@selector (validAttributesForMarkedText),  validAttributesForMarkedText);

  1878.         addMethod (@selector (flagsChanged:),                 flagsChanged);

  1879. 

  1880.         addMethod (@selector (becomeFirstResponder),          becomeFirstResponder);

  1881.         addMethod (@selector (resignFirstResponder),          resignFirstResponder);

  1882.         addMethod (@selector (acceptsFirstResponder),         acceptsFirstResponder);

  1883. 

  1884.         addMethod (@selector (draggingEntered:),              draggingEntered);

  1885.         addMethod (@selector (draggingUpdated:),              draggingUpdated);

  1886.         addMethod (@selector (draggingEnded:),                draggingEnded);

  1887.         addMethod (@selector (draggingExited:),               draggingExited);

  1888.         addMethod (@selector (prepareForDragOperation:),      prepareForDragOperation);

  1889.         addMethod (@selector (performDragOperation:),         performDragOperation);

  1890.         addMethod (@selector (concludeDragOperation:),        concludeDragOperation);

  1891. 

  1892.         addMethod (@selector (paste:),                        paste);

  1893.         addMethod (@selector (copy:),                         copy);

  1894.         addMethod (@selector (cut:),                          cut);

  1895.         addMethod (@selector (selectAll:),                    selectAll);

  1896. 

  1897.         addMethod (@selector (viewWillMoveToWindow:),         willMoveToWindow);

  1898. 

  1899.         addMethod (@selector (isAccessibilityElement),        getIsAccessibilityElement);

  1900.         addMethod (@selector (accessibilityChildren),         getAccessibilityChildren);

  1901.         addMethod (@selector (accessibilityHitTest:),         accessibilityHitTest);

  1902.         addMethod (@selector (accessibilityFocusedUIElement), getAccessibilityFocusedUIElement);

  1903. 

  1904.         // deprecated methods required for backwards compatibility

  1905.         addMethod (@selector (accessibilityIsIgnored),        getAccessibilityIsIgnored);

  1906.         addMethod (@selector (accessibilityAttributeValue:),  getAccessibilityAttributeValue);

  1907. 

  1908.         addMethod (@selector (isFlipped),                     isFlipped);

  1909. 

  1910.         addMethod (NSViewComponentPeer::dismissModalsSelector,  dismissModals);

  1911.         addMethod (NSViewComponentPeer::asyncMouseDownSelector, asyncMouseDown);

  1912.         addMethod (NSViewComponentPeer::asyncMouseUpSelector,   asyncMouseUp);

  1913.         addMethod (NSViewComponentPeer::frameChangedSelector,   frameChanged);

  1914.         addMethod (NSViewComponentPeer::becomeKeySelector,      becomeKey);

  1915.         addMethod (NSViewComponentPeer::resignKeySelector,      resignKey);

  1916. 

  1917.         addMethod (@selector (performKeyEquivalent:),           performKeyEquivalent);

  1918. 

  1919.         addProtocol (@protocol (NSTextInput));

  1920. 

  1921.         registerClass();

  1922.     }

  1923. 

  1924. private:

  1925.     static void mouseDown (id self, SEL s, NSEvent* ev)

  1926.     {

  1927.         if (JUCEApplicationBase::isStandaloneApp())

  1928.         {

  1929.             asyncMouseDown (self, s, ev);

  1930.         }

  1931.         else

  1932.         {

  1933.             // In some host situations, the host will stop modal loops from working

  1934.             // correctly if they're called from a mouse event, so we'll trigger

  1935.             // the event asynchronously..

  1936.             [self performSelectorOnMainThread: NSViewComponentPeer::asyncMouseDownSelector

  1937.                                    withObject: ev

  1938.                                 waitUntilDone: NO];

  1939.         }

  1940.     }

  1941. 

  1942.     static void mouseUp (id self, SEL s, NSEvent* ev)

  1943.     {

  1944.         if (JUCEApplicationBase::isStandaloneApp())

  1945.         {

  1946.             asyncMouseUp (self, s, ev);

  1947.         }

  1948.         else

  1949.         {

  1950.             // In some host situations, the host will stop modal loops from working

  1951.             // correctly if they're called from a mouse event, so we'll trigger

  1952.             // the event asynchronously..

  1953.             [self performSelectorOnMainThread: NSViewComponentPeer::asyncMouseUpSelector

  1954.                                    withObject: ev

  1955.                                 waitUntilDone: NO];

  1956.         }

  1957.     }

  1958. 

  1959.     static void asyncMouseDown   (id self, SEL, NSEvent* ev)   { callOnOwner (self, &NSViewComponentPeer::redirectMouseDown,        ev); }

  1960.     static void asyncMouseUp     (id self, SEL, NSEvent* ev)   { callOnOwner (self, &NSViewComponentPeer::redirectMouseUp,          ev); }

  1961.     static void mouseDragged     (id self, SEL, NSEvent* ev)   { callOnOwner (self, &NSViewComponentPeer::redirectMouseDrag,        ev); }

  1962.     static void mouseMoved       (id self, SEL, NSEvent* ev)   { callOnOwner (self, &NSViewComponentPeer::redirectMouseMove,        ev); }

  1963.     static void mouseEntered     (id self, SEL, NSEvent* ev)   { callOnOwner (self, &NSViewComponentPeer::redirectMouseEnter,       ev); }

  1964.     static void mouseExited      (id self, SEL, NSEvent* ev)   { callOnOwner (self, &NSViewComponentPeer::redirectMouseExit,        ev); }

  1965.     static void scrollWheel      (id self, SEL, NSEvent* ev)   { callOnOwner (self, &NSViewComponentPeer::redirectMouseWheel,       ev); }

  1966.     static void magnify          (id self, SEL, NSEvent* ev)   { callOnOwner (self, &NSViewComponentPeer::redirectMagnify,          ev); }

  1967.     static void copy             (id self, SEL, NSObject* s)   { callOnOwner (self, &NSViewComponentPeer::redirectCopy,             s);  }

  1968.     static void paste            (id self, SEL, NSObject* s)   { callOnOwner (self, &NSViewComponentPeer::redirectPaste,            s);  }

  1969.     static void cut              (id self, SEL, NSObject* s)   { callOnOwner (self, &NSViewComponentPeer::redirectCut,              s);  }

  1970.     static void selectAll        (id self, SEL, NSObject* s)   { callOnOwner (self, &NSViewComponentPeer::redirectSelectAll,        s);  }

  1971.     static void willMoveToWindow (id self, SEL, NSWindow* w)   { callOnOwner (self, &NSViewComponentPeer::redirectWillMoveToWindow, w);  }

  1972. 

  1973.     static BOOL acceptsFirstMouse (id, SEL, NSEvent*)          { return YES; }

  1974.     static BOOL wantsDefaultClipping (id, SEL)                 { return YES; } // (this is the default, but may want to customise it in future)

  1975.     static BOOL worksWhenModal (id self, SEL)                  { if (auto* p = getOwner (self)) return p->worksWhenModal(); return NO; }

  1976. 

  1977.     static void drawRect (id self, SEL, NSRect r)              { callOnOwner (self, &NSViewComponentPeer::drawRect, r); }

  1978.     static void frameChanged (id self, SEL, NSNotification*)   { callOnOwner (self, &NSViewComponentPeer::redirectMovedOrResized); }

  1979.     static void viewDidMoveToWindow (id self, SEL)             { callOnOwner (self, &NSViewComponentPeer::viewMovedToWindow); }

  1980.     static void dismissModals (id self, SEL)                   { callOnOwner (self, &NSViewComponentPeer::dismissModals); }

  1981.     static void becomeKey (id self, SEL)                       { callOnOwner (self, &NSViewComponentPeer::becomeKey); }

  1982.     static void resignKey (id self, SEL)                       { callOnOwner (self, &NSViewComponentPeer::resignKey); }

  1983. 

  1984.     static BOOL isFlipped (id, SEL)                            { return true; }

  1985. 

  1986.     static void viewWillDraw (id self, SEL)

  1987.     {

  1988.         // Without setting contentsFormat macOS Big Sur will always set the invalid area

  1989.         // to be the entire frame.

  1990.        #if defined (MAC_OS_X_VERSION_10_12) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_12

  1991.         if (@available (macOS 10.12, *))

  1992.         {

  1993.             CALayer* layer = ((NSView*) self).layer;

  1994.             layer.contentsFormat = kCAContentsFormatRGBA8Uint;

  1995.         }

  1996.        #endif

  1997. 

  1998.         sendSuperclassMessage<void> (self, @selector (viewWillDraw));

  1999.     }

  2000. 

  2001.     static void windowWillMiniaturize (id self, SEL, NSNotification*)

  2002.     {

  2003.         if (auto* p = getOwner (self))

  2004.         {

  2005.             if (p->isAlwaysOnTop)

  2006.             {

  2007.                 // there is a bug when restoring minimised always on top windows so we need

  2008.                 // to remove this behaviour before minimising and restore it afterwards

  2009.                 p->setAlwaysOnTop (false);

  2010.                 p->wasAlwaysOnTop = true;

  2011.             }

  2012.         }

  2013.     }

  2014. 

  2015.     static void windowDidDeminiaturize (id self, SEL, NSNotification*)

  2016.     {

  2017.         if (auto* p = getOwner (self))

  2018.         {

  2019.             if (p->wasAlwaysOnTop)

  2020.                 p->setAlwaysOnTop (true);

  2021. 

  2022.             p->redirectMovedOrResized();

  2023.         }

  2024.     }

  2025. 

  2026.     static BOOL isOpaque (id self, SEL)

  2027.     {

  2028.         auto* owner = getOwner (self);

  2029.         return owner == nullptr || owner->getComponent().isOpaque();

  2030.     }

  2031. 

  2032.     //==============================================================================

  2033.     static void keyDown (id self, SEL, NSEvent* ev)

  2034.     {

  2035.         if (auto* owner = getOwner (self))

  2036.         {

  2037.             auto* target = owner->findCurrentTextInputTarget();

  2038.             owner->textWasInserted = false;

  2039. 

  2040.             if (target != nullptr)

  2041.                 [(NSView*) self interpretKeyEvents: [NSArray arrayWithObject: ev]];

  2042.             else

  2043.                 owner->stringBeingComposed.clear();

  2044. 

  2045.             if (! (owner->textWasInserted || owner->redirectKeyDown (ev)))

  2046.                 sendSuperclassMessage<void> (self, @selector (keyDown:), ev);

  2047.         }

  2048.     }

  2049. 

  2050.     static void keyUp (id self, SEL, NSEvent* ev)

  2051.     {

  2052.         auto* owner = getOwner (self);

  2053. 

  2054.         if (! owner->redirectKeyUp (ev))

  2055.             sendSuperclassMessage<void> (self, @selector (keyUp:), ev);

  2056.     }

  2057. 

  2058.     //==============================================================================

  2059.     static void insertText (id self, SEL, id aString)

  2060.     {

  2061.         // This commits multi-byte text when return is pressed, or after every keypress for western keyboards

  2062.         if (auto* owner = getOwner (self))

  2063.         {

  2064.             NSString* newText = [aString isKindOfClass: [NSAttributedString class]] ? [aString string] : aString;

  2065. 

  2066.             if ([newText length] > 0)

  2067.             {

  2068.                 if (auto* target = owner->findCurrentTextInputTarget())

  2069.                 {

  2070.                     target->insertTextAtCaret (nsStringToJuce (newText));

  2071.                     owner->textWasInserted = true;

  2072.                 }

  2073.             }

  2074. 

  2075.             owner->stringBeingComposed.clear();

  2076.         }

  2077.     }

  2078. 

  2079.     static void doCommandBySelector (id, SEL, SEL) {}

  2080. 

  2081.     static void setMarkedText (id self, SEL, id aString, NSRange)

  2082.     {

  2083.         if (auto* owner = getOwner (self))

  2084.         {

  2085.             owner->stringBeingComposed = nsStringToJuce ([aString isKindOfClass: [NSAttributedString class]]

  2086.                                                            ? [aString string] : aString);

  2087. 

  2088.             if (auto* target = owner->findCurrentTextInputTarget())

  2089.             {

  2090.                 auto currentHighlight = target->getHighlightedRegion();

  2091.                 target->insertTextAtCaret (owner->stringBeingComposed);

  2092.                 target->setHighlightedRegion (currentHighlight.withLength (owner->stringBeingComposed.length()));

  2093.                 owner->textWasInserted = true;

  2094.             }

  2095.         }

  2096.     }

  2097. 

  2098.     static void unmarkText (id self, SEL)

  2099.     {

  2100.         if (auto* owner = getOwner (self))

  2101.         {

  2102.             if (owner->stringBeingComposed.isNotEmpty())

  2103.             {

  2104.                 if (auto* target = owner->findCurrentTextInputTarget())

  2105.                 {

  2106.                     target->insertTextAtCaret (owner->stringBeingComposed);

  2107.                     owner->textWasInserted = true;

  2108.                 }

  2109. 

  2110.                 owner->stringBeingComposed.clear();

  2111.             }

  2112.         }

  2113.     }

  2114. 

  2115.     static BOOL hasMarkedText (id self, SEL)

  2116.     {

  2117.         auto* owner = getOwner (self);

  2118.         return owner != nullptr && owner->stringBeingComposed.isNotEmpty();

  2119.     }

  2120. 

  2121.     static long conversationIdentifier (id self, SEL)

  2122.     {

  2123.         return (long) (pointer_sized_int) self;

  2124.     }

  2125. 

  2126.     static NSAttributedString* attributedSubstringFromRange (id self, SEL, NSRange theRange)

  2127.     {

  2128.         if (auto* owner = getOwner (self))

  2129.         {

  2130.             if (auto* target = owner->findCurrentTextInputTarget())

  2131.             {

  2132.                 Range<int> r ((int) theRange.location,

  2133.                               (int) (theRange.location + theRange.length));

  2134. 

  2135.                 return [[[NSAttributedString alloc] initWithString: juceStringToNS (target->getTextInRange (r))] autorelease];

  2136.             }

  2137.         }

  2138. 

  2139.         return nil;

  2140.     }

  2141. 

  2142.     static NSRange markedRange (id self, SEL)

  2143.     {

  2144.         if (auto* owner = getOwner (self))

  2145.             if (owner->stringBeingComposed.isNotEmpty())

  2146.                 return NSMakeRange (0, (NSUInteger) owner->stringBeingComposed.length());

  2147. 

  2148.         return NSMakeRange (NSNotFound, 0);

  2149.     }

  2150. 

  2151.     static NSRange selectedRange (id self, SEL)

  2152.     {

  2153.         if (auto* owner = getOwner (self))

  2154.         {

  2155.             if (auto* target = owner->findCurrentTextInputTarget())

  2156.             {

  2157.                 auto highlight = target->getHighlightedRegion();

  2158. 

  2159.                 if (! highlight.isEmpty())

  2160.                     return NSMakeRange ((NSUInteger) highlight.getStart(),

  2161.                                         (NSUInteger) highlight.getLength());

  2162.             }

  2163.         }

  2164. 

  2165.         return NSMakeRange (NSNotFound, 0);

  2166.     }

  2167. 

  2168.     static NSRect firstRectForCharacterRange (id self, SEL, NSRange)

  2169.     {

  2170.         if (auto* owner = getOwner (self))

  2171.             if (auto* comp = dynamic_cast<Component*> (owner->findCurrentTextInputTarget()))

  2172.                 return flippedScreenRect (makeNSRect (comp->getScreenBounds()));

  2173. 

  2174.         return NSZeroRect;

  2175.     }

  2176. 

  2177.     static NSUInteger characterIndexForPoint (id, SEL, NSPoint)     { return NSNotFound; }

  2178.     static NSArray* validAttributesForMarkedText (id, SEL)          { return [NSArray array]; }

  2179. 

  2180.     //==============================================================================

  2181.     static void flagsChanged (id self, SEL, NSEvent* ev)

  2182.     {

  2183.         callOnOwner (self, &NSViewComponentPeer::redirectModKeyChange, ev);

  2184.     }

  2185. 

  2186.     static BOOL becomeFirstResponder (id self, SEL)

  2187.     {

  2188.         callOnOwner (self, &NSViewComponentPeer::viewFocusGain);

  2189.         return YES;

  2190.     }

  2191. 

  2192.     static BOOL resignFirstResponder (id self, SEL)

  2193.     {

  2194.         callOnOwner (self, &NSViewComponentPeer::viewFocusLoss);

  2195.         return YES;

  2196.     }

  2197. 

  2198.     static BOOL acceptsFirstResponder (id self, SEL)

  2199.     {

  2200.         auto* owner = getOwner (self);

  2201.         return owner != nullptr && owner->canBecomeKeyWindow();

  2202.     }

  2203. 

  2204.     //==============================================================================

  2205.     static NSDragOperation draggingEntered (id self, SEL s, id<NSDraggingInfo> sender)

  2206.     {

  2207.         return draggingUpdated (self, s, sender);

  2208.     }

  2209. 

  2210.     static NSDragOperation draggingUpdated (id self, SEL, id<NSDraggingInfo> sender)

  2211.     {

  2212.         if (auto* owner = getOwner (self))

  2213.             if (owner->sendDragCallback (&NSViewComponentPeer::handleDragMove, sender))

  2214.                 return NSDragOperationGeneric;

  2215. 

  2216.         return NSDragOperationNone;

  2217.     }

  2218. 

  2219.     static void draggingEnded (id self, SEL s, id<NSDraggingInfo> sender)

  2220.     {

  2221.         draggingExited (self, s, sender);

  2222.     }

  2223. 

  2224.     static void draggingExited (id self, SEL, id<NSDraggingInfo> sender)

  2225.     {

  2226.         callOnOwner (self, &NSViewComponentPeer::sendDragCallback, &NSViewComponentPeer::handleDragExit, sender);

  2227.     }

  2228. 

  2229.     static BOOL prepareForDragOperation (id, SEL, id<NSDraggingInfo>)

  2230.     {

  2231.         return YES;

  2232.     }

  2233. 

  2234.     static BOOL performDragOperation (id self, SEL, id<NSDraggingInfo> sender)

  2235.     {

  2236.         auto* owner = getOwner (self);

  2237.         return owner != nullptr && owner->sendDragCallback (&NSViewComponentPeer::handleDragDrop, sender);

  2238.     }

  2239. 

  2240.     static void concludeDragOperation (id, SEL, id<NSDraggingInfo>) {}

  2241. 

  2242.     //==============================================================================

  2243.     static BOOL getIsAccessibilityElement (id, SEL)

  2244.     {

  2245.         return NO;

  2246.     }

  2247. 

  2248.     static NSArray* getAccessibilityChildren (id self, SEL)

  2249.     {

  2250.         return NSAccessibilityUnignoredChildrenForOnlyChild (getAccessibleChild (self));

  2251.     }

  2252. 

  2253.     static id accessibilityHitTest (id self, SEL, NSPoint point)

  2254.     {

  2255.         return [getAccessibleChild (self) accessibilityHitTest: point];

  2256.     }

  2257. 

  2258.     static id getAccessibilityFocusedUIElement (id self, SEL)

  2259.     {

  2260.         return [getAccessibleChild (self) accessibilityFocusedUIElement];

  2261.     }

  2262. 

  2263.     static BOOL getAccessibilityIsIgnored (id, SEL)

  2264.     {

  2265.         return YES;

  2266.     }

  2267. 

  2268.     static id getAccessibilityAttributeValue (id self, SEL, NSString* attribute)

  2269.     {

  2270.         if ([attribute isEqualToString: NSAccessibilityChildrenAttribute])

  2271.             return getAccessibilityChildren (self, {});

  2272. 

  2273.         return sendSuperclassMessage<id> (self, @selector (accessibilityAttributeValue:), attribute);

  2274.     }

  2275. 

  2276.     static bool tryPassingKeyEventToPeer (NSEvent* e)

  2277.     {

  2278.         if ([e type] != NSEventTypeKeyDown && [e type] != NSEventTypeKeyUp)

  2279.             return false;

  2280. 

  2281.         if (auto* focused = Component::getCurrentlyFocusedComponent())

  2282.         {

  2283.             if (auto* peer = dynamic_cast<NSViewComponentPeer*> (focused->getPeer()))

  2284.             {

  2285.                 return [e type] == NSEventTypeKeyDown ? peer->redirectKeyDown (e)

  2286.                                                       : peer->redirectKeyUp (e);

  2287.             }

  2288.         }

  2289. 

  2290.         return false;

  2291.     }

  2292. 

  2293.     static BOOL performKeyEquivalent (id self, SEL s, NSEvent* event)

  2294.     {

  2295.         // We try passing shortcut keys to the currently focused component first.

  2296.         // If the component doesn't want the event, we'll fall back to the superclass

  2297.         // implementation, which will pass the event to the main menu.

  2298.         if (tryPassingKeyEventToPeer (event))

  2299.             return YES;

  2300. 

  2301.         return sendSuperclassMessage<BOOL> (self, s, event);

  2302.     }

  2303. 

  2304.     template <typename Func, typename... Args>

  2305.     static void callOnOwner (id self, Func&& func, Args&&... args)

  2306.     {

  2307.         if (auto* owner = getOwner (self))

  2308.             (owner->*func) (std::forward<Args> (args)...);

  2309.     }

  2310. };

  2311. 

  2312. //==============================================================================

  2313. struct JuceNSWindowClass   : public NSViewComponentPeerWrapper<ObjCClass<NSWindow>>

  2314. {

  2315.     JuceNSWindowClass()  : NSViewComponentPeerWrapper ("JUCEWindow_")

  2316.     {

  2317.         addMethod (@selector (canBecomeKeyWindow),                  canBecomeKeyWindow);

  2318.         addMethod (@selector (canBecomeMainWindow),                 canBecomeMainWindow);

  2319.         addMethod (@selector (becomeKeyWindow),                     becomeKeyWindow);

  2320.         addMethod (@selector (resignKeyWindow),                     resignKeyWindow);

  2321.         addMethod (@selector (windowShouldClose:),                  windowShouldClose);

  2322.         addMethod (@selector (constrainFrameRect:toScreen:),        constrainFrameRect);

  2323.         addMethod (@selector (windowWillResize:toSize:),            windowWillResize);

  2324.         addMethod (@selector (windowDidExitFullScreen:),            windowDidExitFullScreen);

  2325.         addMethod (@selector (windowWillEnterFullScreen:),          windowWillEnterFullScreen);

  2326.         addMethod (@selector (windowWillExitFullScreen:),           windowWillExitFullScreen);

  2327.         addMethod (@selector (windowWillStartLiveResize:),          windowWillStartLiveResize);

  2328.         addMethod (@selector (windowDidEndLiveResize:),             windowDidEndLiveResize);

  2329.         addMethod (@selector (window:shouldPopUpDocumentPathMenu:), shouldPopUpPathMenu);

  2330.         addMethod (@selector (isFlipped),                           isFlipped);

  2331.         addMethod (@selector (windowWillUseStandardFrame:defaultFrame:), windowWillUseStandardFrame);

  2332.         addMethod (@selector (windowShouldZoom:toFrame:),                windowShouldZoomToFrame);

  2333. 

  2334.         addMethod (@selector (accessibilityTitle),                  getAccessibilityTitle);

  2335.         addMethod (@selector (accessibilityLabel),                  getAccessibilityLabel);

  2336.         addMethod (@selector (accessibilityTopLevelUIElement),      getAccessibilityWindow);

  2337.         addMethod (@selector (accessibilityWindow),                 getAccessibilityWindow);

  2338.         addMethod (@selector (accessibilityRole),                   getAccessibilityRole);

  2339.         addMethod (@selector (accessibilitySubrole),                getAccessibilitySubrole);

  2340. 

  2341.         addMethod (@selector (keyDown:),                            keyDown);

  2342. 

  2343.         addMethod (@selector (window:shouldDragDocumentWithEvent:from:withPasteboard:), shouldAllowIconDrag);

  2344. 

  2345.         addMethod (@selector (toggleFullScreen:),                                         toggleFullScreen);

  2346. 

  2347.         addProtocol (@protocol (NSWindowDelegate));

  2348. 

  2349.         registerClass();

  2350.     }

  2351. 

  2352. private:

  2353.     //==============================================================================

  2354.     static BOOL isFlipped (id, SEL) { return true; }

  2355. 

  2356.     // Key events will be processed by the peer's component.

  2357.     // If the component is unable to use the event, it will be re-sent

  2358.     // to performKeyEquivalent.

  2359.     // performKeyEquivalent will send the event to the view's superclass,

  2360.     // which will try passing the event to the main menu.

  2361.     // If the event still hasn't been processed, it will be passed to the

  2362.     // next responder in the chain, which will be the NSWindow for a peer

  2363.     // that is on the desktop.

  2364.     // If the NSWindow still doesn't handle the event, the Apple docs imply

  2365.     // that the event should be sent to the NSApp for processing, but this

  2366.     // doesn't seem to happen for keyDown events.

  2367.     // Instead, the NSWindow attempts to process the event, fails, and

  2368.     // triggers an annoying NSBeep.

  2369.     // Overriding keyDown to "handle" the event seems to suppress the beep.

  2370.     static void keyDown (id, SEL, NSEvent* ev)

  2371.     {

  2372.         ignoreUnused (ev);

  2373. 

  2374.        #if JUCE_DEBUG_UNHANDLED_KEYPRESSES

  2375.         DBG ("unhandled key down event with keycode: " << [ev keyCode]);

  2376.        #endif

  2377.     }

  2378. 

  2379.     static NSRect windowWillUseStandardFrame (id self, SEL, NSWindow* window, NSRect r)

  2380.     {

  2381.         if (auto* owner = getOwner (self))

  2382.         {

  2383.             if (auto* constrainer = owner->getConstrainer())

  2384.             {

  2385.                 if (auto* screen = [window screen])

  2386.                 {

  2387.                     const auto safeScreenBounds = convertToRectFloat (flippedScreenRect (owner->hasNativeTitleBar() ? r : [screen visibleFrame]));

  2388.                     const auto originalBounds = owner->getFrameSize().addedTo (owner->getComponent().getScreenBounds()).toFloat();

  2389.                     const auto expanded = originalBounds.withWidth  ((float) constrainer->getMaximumWidth())

  2390.                                                         .withHeight ((float) constrainer->getMaximumHeight());

  2391.                     const auto constrained = expanded.constrainedWithin (safeScreenBounds);

  2392. 

  2393.                     return flippedScreenRect (makeNSRect ([&]

  2394.                     {

  2395.                         if (constrained == owner->getBounds().toFloat())

  2396.                             return owner->lastSizeBeforeZoom.toFloat();

  2397. 

  2398.                         owner->lastSizeBeforeZoom = owner->getBounds().toFloat();

  2399.                         return constrained;

  2400.                     }()));

  2401.                 }

  2402.             }

  2403.         }

  2404. 

  2405.         return r;

  2406.     }

  2407. 

  2408.     static BOOL windowShouldZoomToFrame (id self, SEL, NSWindow*, NSRect)

  2409.     {

  2410.         if (auto* owner = getOwner (self))

  2411.             if (owner->hasNativeTitleBar() && (owner->getStyleFlags() & ComponentPeer::windowIsResizable) == 0)

  2412.                 return NO;

  2413. 

  2414.         return YES;

  2415.     }

  2416. 

  2417.     static BOOL canBecomeKeyWindow (id self, SEL)

  2418.     {

  2419.         auto* owner = getOwner (self);

  2420. 

  2421.         return owner != nullptr

  2422.                 && owner->canBecomeKeyWindow()

  2423.                 && ! owner->isBlockedByModalComponent();

  2424.     }

  2425. 

  2426.     static BOOL canBecomeMainWindow (id self, SEL)

  2427.     {

  2428.         auto* owner = getOwner (self);

  2429. 

  2430.         return owner != nullptr

  2431.                 && owner->canBecomeMainWindow()

  2432.                 && ! owner->isBlockedByModalComponent();

  2433.     }

  2434. 

  2435.     static void becomeKeyWindow (id self, SEL)

  2436.     {

  2437.         sendSuperclassMessage<void> (self, @selector (becomeKeyWindow));

  2438. 

  2439.         if (auto* owner = getOwner (self))

  2440.         {

  2441.             if (owner->canBecomeKeyWindow())

  2442.             {

  2443.                 owner->becomeKeyWindow();

  2444.                 return;

  2445.             }

  2446. 

  2447.             // this fixes a bug causing hidden windows to sometimes become visible when the app regains focus

  2448.             if (! owner->getComponent().isVisible())

  2449.                 [(NSWindow*) self orderOut: nil];

  2450.         }

  2451.     }

  2452. 

  2453.     static void resignKeyWindow (id self, SEL)

  2454.     {

  2455.         sendSuperclassMessage<void> (self, @selector (resignKeyWindow));

  2456. 

  2457.         if (auto* owner = getOwner (self))

  2458.             owner->resignKeyWindow();

  2459.     }

  2460. 

  2461.     static BOOL windowShouldClose (id self, SEL, id /*window*/)

  2462.     {

  2463.         auto* owner = getOwner (self);

  2464.         return owner == nullptr || owner->windowShouldClose();

  2465.     }

  2466. 

  2467.     static NSRect constrainFrameRect (id self, SEL, NSRect frameRect, NSScreen* screen)

  2468.     {

  2469.         if (auto* owner = getOwner (self))

  2470.         {

  2471.             frameRect = sendSuperclassMessage<NSRect, NSRect, NSScreen*> (self, @selector (constrainFrameRect:toScreen:),

  2472.                                                                           frameRect, screen);

  2473. 

  2474.             frameRect = owner->constrainRect (frameRect);

  2475.         }

  2476. 

  2477.         return frameRect;

  2478.     }

  2479. 

  2480.     static NSSize windowWillResize (id self, SEL, NSWindow*, NSSize proposedFrameSize)

  2481.     {

  2482.         auto* owner = getOwner (self);

  2483. 

  2484.         if (owner == nullptr || owner->isZooming)

  2485.             return proposedFrameSize;

  2486. 

  2487.         NSRect frameRect = flippedScreenRect ([(NSWindow*) self frame]);

  2488.         frameRect.size = proposedFrameSize;

  2489. 

  2490.         frameRect = owner->constrainRect (flippedScreenRect (frameRect));

  2491. 

  2492.         owner->dismissModals();

  2493. 

  2494.         return frameRect.size;

  2495.     }

  2496. 

  2497.     static void toggleFullScreen (id self, SEL name, id sender)

  2498.     {

  2499.         if (auto* owner = getOwner (self))

  2500.         {

  2501.             const auto isFullScreen = owner->isFullScreen();

  2502. 

  2503.             if (! isFullScreen)

  2504.                 owner->lastSizeBeforeZoom = owner->getBounds().toFloat();

  2505. 

  2506.             sendSuperclassMessage<void> (self, name, sender);

  2507. 

  2508.             if (isFullScreen)

  2509.             {

  2510.                 [NSApp setPresentationOptions: NSApplicationPresentationDefault];

  2511.                 owner->setBounds (owner->lastSizeBeforeZoom.toNearestInt(), false);

  2512.             }

  2513.         }

  2514.     }

  2515. 

  2516.     static void windowDidExitFullScreen (id self, SEL, NSNotification*)

  2517.     {

  2518.         if (auto* owner = getOwner (self))

  2519.             owner->resetWindowPresentation();

  2520.     }

  2521. 

  2522.     static void windowWillExitFullScreen (id self, SEL, NSNotification*)

  2523.     {

  2524.         // The exit-fullscreen animation looks bad on Monterey if the window isn't resizable...

  2525.         if (auto* owner = getOwner (self))

  2526.             if (auto* window = owner->window)

  2527.                 [window setStyleMask: [window styleMask] | NSWindowStyleMaskResizable];

  2528.     }

  2529. 

  2530.     static void windowWillEnterFullScreen (id self, SEL, NSNotification*)

  2531.     {

  2532.         if (SystemStats::getOperatingSystemType() <= SystemStats::MacOSX_10_9)

  2533.             return;

  2534. 

  2535.         if (auto* owner = getOwner (self))

  2536.             if (owner->hasNativeTitleBar() && (owner->getStyleFlags() & ComponentPeer::windowIsResizable) == 0)

  2537.                 [owner->window setStyleMask: NSWindowStyleMaskBorderless];

  2538.     }

  2539. 

  2540.     static void windowWillStartLiveResize (id self, SEL, NSNotification*)

  2541.     {

  2542.         if (auto* owner = getOwner (self))

  2543.             owner->liveResizingStart();

  2544.     }

  2545. 

  2546.     static void windowDidEndLiveResize (id self, SEL, NSNotification*)

  2547.     {

  2548.         if (auto* owner = getOwner (self))

  2549.             owner->liveResizingEnd();

  2550.     }

  2551. 

  2552.     static bool shouldPopUpPathMenu (id self, SEL, id /*window*/, NSMenu*)

  2553.     {

  2554.         if (auto* owner = getOwner (self))

  2555.             return owner->windowRepresentsFile;

  2556. 

  2557.         return false;

  2558.     }

  2559. 

  2560.     static bool shouldAllowIconDrag (id self, SEL, id /*window*/, NSEvent*, NSPoint, NSPasteboard*)

  2561.     {

  2562.         if (auto* owner = getOwner (self))

  2563.             return owner->windowRepresentsFile;

  2564. 

  2565.         return false;

  2566.     }

  2567. 

  2568.     static NSString* getAccessibilityTitle (id self, SEL)

  2569.     {

  2570.         return [self title];

  2571.     }

  2572. 

  2573.     static NSString* getAccessibilityLabel (id self, SEL)

  2574.     {

  2575.         return [getAccessibleChild (self) accessibilityLabel];

  2576.     }

  2577. 

  2578.     static id getAccessibilityWindow (id self, SEL)

  2579.     {

  2580.         return self;

  2581.     }

  2582. 

  2583.     static NSAccessibilityRole getAccessibilityRole (id, SEL)

  2584.     {

  2585.         return NSAccessibilityWindowRole;

  2586.     }

  2587. 

  2588.     static NSAccessibilityRole getAccessibilitySubrole (id self, SEL)

  2589.     {

  2590.         if (@available (macOS 10.10, *))

  2591.             return [getAccessibleChild (self) accessibilitySubrole];

  2592. 

  2593.         return nil;

  2594.     }

  2595. };

  2596. 

  2597. NSView* NSViewComponentPeer::createViewInstance()

  2598. {

  2599.     static JuceNSViewClass cls;

  2600.     return cls.createInstance();

  2601. }

  2602. 

  2603. NSWindow* NSViewComponentPeer::createWindowInstance()

  2604. {

  2605.     static JuceNSWindowClass cls;

  2606.     return cls.createInstance();

  2607. }

  2608. 

  2609. 

  2610. //==============================================================================

  2611. ComponentPeer* NSViewComponentPeer::currentlyFocusedPeer = nullptr;

  2612. Array<int> NSViewComponentPeer::keysCurrentlyDown;

  2613. 

  2614. //==============================================================================

  2615. bool KeyPress::isKeyCurrentlyDown (int keyCode)

  2616. {

  2617.     if (NSViewComponentPeer::keysCurrentlyDown.contains (keyCode))

  2618.         return true;

  2619. 

  2620.     if (keyCode >= 'A' && keyCode <= 'Z'

  2621.          && NSViewComponentPeer::keysCurrentlyDown.contains ((int) CharacterFunctions::toLowerCase ((juce_wchar) keyCode)))

  2622.         return true;

  2623. 

  2624.     if (keyCode >= 'a' && keyCode <= 'z'

  2625.          && NSViewComponentPeer::keysCurrentlyDown.contains ((int) CharacterFunctions::toUpperCase ((juce_wchar) keyCode)))

  2626.         return true;

  2627. 

  2628.     return false;

  2629. }

  2630. 

  2631. //==============================================================================

  2632. bool MouseInputSource::SourceList::addSource()

  2633. {

  2634.     if (sources.size() == 0)

  2635.     {

  2636.         addSource (0, MouseInputSource::InputSourceType::mouse);

  2637.         return true;

  2638.     }

  2639. 

  2640.     return false;

  2641. }

  2642. 

  2643. bool MouseInputSource::SourceList::canUseTouch()

  2644. {

  2645.     return false;

  2646. }

  2647. 

  2648. //==============================================================================

  2649. void Desktop::setKioskComponent (Component* kioskComp, bool shouldBeEnabled, bool allowMenusAndBars)

  2650. {

  2651.     auto* peer = dynamic_cast<NSViewComponentPeer*> (kioskComp->getPeer());

  2652.     jassert (peer != nullptr); // (this should have been checked by the caller)

  2653. 

  2654.     if (peer->hasNativeTitleBar())

  2655.     {

  2656.         if (shouldBeEnabled && ! allowMenusAndBars)

  2657.             [NSApp setPresentationOptions: NSApplicationPresentationHideDock | NSApplicationPresentationHideMenuBar];

  2658.         else if (! shouldBeEnabled)

  2659.             [NSApp setPresentationOptions: NSApplicationPresentationDefault];

  2660. 

  2661.         peer->setFullScreen (true);

  2662.     }

  2663.     else

  2664.     {

  2665.         if (shouldBeEnabled)

  2666.         {

  2667.             [NSApp setPresentationOptions: (allowMenusAndBars ? (NSApplicationPresentationAutoHideDock | NSApplicationPresentationAutoHideMenuBar)

  2668.                                                               : (NSApplicationPresentationHideDock | NSApplicationPresentationHideMenuBar))];

  2669. 

  2670.             kioskComp->setBounds (getDisplays().getDisplayForRect (kioskComp->getScreenBounds())->totalArea);

  2671.             peer->becomeKeyWindow();

  2672.         }

  2673.         else

  2674.         {

  2675.             peer->resetWindowPresentation();

  2676.         }

  2677.     }

  2678. }

  2679. 

  2680. void Desktop::allowedOrientationsChanged() {}

  2681. 

  2682. //==============================================================================

  2683. ComponentPeer* Component::createNewPeer (int styleFlags, void* windowToAttachTo)

  2684. {

  2685.     return new NSViewComponentPeer (*this, styleFlags, (NSView*) windowToAttachTo);

  2686. }

  2687. 

  2688. //==============================================================================

  2689. const int KeyPress::spaceKey        = ' ';

  2690. const int KeyPress::returnKey       = 0x0d;

  2691. const int KeyPress::escapeKey       = 0x1b;

  2692. const int KeyPress::backspaceKey    = 0x7f;

  2693. const int KeyPress::leftKey         = NSLeftArrowFunctionKey;

  2694. const int KeyPress::rightKey        = NSRightArrowFunctionKey;

  2695. const int KeyPress::upKey           = NSUpArrowFunctionKey;

  2696. const int KeyPress::downKey         = NSDownArrowFunctionKey;

  2697. const int KeyPress::pageUpKey       = NSPageUpFunctionKey;

  2698. const int KeyPress::pageDownKey     = NSPageDownFunctionKey;

  2699. const int KeyPress::endKey          = NSEndFunctionKey;

  2700. const int KeyPress::homeKey         = NSHomeFunctionKey;

  2701. const int KeyPress::deleteKey       = NSDeleteFunctionKey;

  2702. const int KeyPress::insertKey       = -1;

  2703. const int KeyPress::tabKey          = 9;

  2704. const int KeyPress::F1Key           = NSF1FunctionKey;

  2705. const int KeyPress::F2Key           = NSF2FunctionKey;

  2706. const int KeyPress::F3Key           = NSF3FunctionKey;

  2707. const int KeyPress::F4Key           = NSF4FunctionKey;

  2708. const int KeyPress::F5Key           = NSF5FunctionKey;

  2709. const int KeyPress::F6Key           = NSF6FunctionKey;

  2710. const int KeyPress::F7Key           = NSF7FunctionKey;

  2711. const int KeyPress::F8Key           = NSF8FunctionKey;

  2712. const int KeyPress::F9Key           = NSF9FunctionKey;

  2713. const int KeyPress::F10Key          = NSF10FunctionKey;

  2714. const int KeyPress::F11Key          = NSF11FunctionKey;

  2715. const int KeyPress::F12Key          = NSF12FunctionKey;

  2716. const int KeyPress::F13Key          = NSF13FunctionKey;

  2717. const int KeyPress::F14Key          = NSF14FunctionKey;

  2718. const int KeyPress::F15Key          = NSF15FunctionKey;

  2719. const int KeyPress::F16Key          = NSF16FunctionKey;

  2720. const int KeyPress::F17Key          = NSF17FunctionKey;

  2721. const int KeyPress::F18Key          = NSF18FunctionKey;

  2722. const int KeyPress::F19Key          = NSF19FunctionKey;

  2723. const int KeyPress::F20Key          = NSF20FunctionKey;

  2724. const int KeyPress::F21Key          = NSF21FunctionKey;

  2725. const int KeyPress::F22Key          = NSF22FunctionKey;

  2726. const int KeyPress::F23Key          = NSF23FunctionKey;

  2727. const int KeyPress::F24Key          = NSF24FunctionKey;

  2728. const int KeyPress::F25Key          = NSF25FunctionKey;

  2729. const int KeyPress::F26Key          = NSF26FunctionKey;

  2730. const int KeyPress::F27Key          = NSF27FunctionKey;

  2731. const int KeyPress::F28Key          = NSF28FunctionKey;

  2732. const int KeyPress::F29Key          = NSF29FunctionKey;

  2733. const int KeyPress::F30Key          = NSF30FunctionKey;

  2734. const int KeyPress::F31Key          = NSF31FunctionKey;

  2735. const int KeyPress::F32Key          = NSF32FunctionKey;

  2736. const int KeyPress::F33Key          = NSF33FunctionKey;

  2737. const int KeyPress::F34Key          = NSF34FunctionKey;

  2738. const int KeyPress::F35Key          = NSF35FunctionKey;

  2739. 

  2740. const int KeyPress::numberPad0              = extendedKeyModifier + 0x20;

  2741. const int KeyPress::numberPad1              = extendedKeyModifier + 0x21;

  2742. const int KeyPress::numberPad2              = extendedKeyModifier + 0x22;

  2743. const int KeyPress::numberPad3              = extendedKeyModifier + 0x23;

  2744. const int KeyPress::numberPad4              = extendedKeyModifier + 0x24;

  2745. const int KeyPress::numberPad5              = extendedKeyModifier + 0x25;

  2746. const int KeyPress::numberPad6              = extendedKeyModifier + 0x26;

  2747. const int KeyPress::numberPad7              = extendedKeyModifier + 0x27;

  2748. const int KeyPress::numberPad8              = extendedKeyModifier + 0x28;

  2749. const int KeyPress::numberPad9              = extendedKeyModifier + 0x29;

  2750. const int KeyPress::numberPadAdd            = extendedKeyModifier + 0x2a;

  2751. const int KeyPress::numberPadSubtract       = extendedKeyModifier + 0x2b;

  2752. const int KeyPress::numberPadMultiply       = extendedKeyModifier + 0x2c;

  2753. const int KeyPress::numberPadDivide         = extendedKeyModifier + 0x2d;

  2754. const int KeyPress::numberPadSeparator      = extendedKeyModifier + 0x2e;

  2755. const int KeyPress::numberPadDecimalPoint   = extendedKeyModifier + 0x2f;

  2756. const int KeyPress::numberPadEquals         = extendedKeyModifier + 0x30;

  2757. const int KeyPress::numberPadDelete         = extendedKeyModifier + 0x31;

  2758. const int KeyPress::playKey                 = extendedKeyModifier + 0x00;

  2759. const int KeyPress::stopKey                 = extendedKeyModifier + 0x01;

  2760. const int KeyPress::fastForwardKey          = extendedKeyModifier + 0x02;

  2761. const int KeyPress::rewindKey               = extendedKeyModifier + 0x03;

  2762. 

  2763. } // namespace juce