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.
13330 Commits
11 Branches
588MB
Tree: d048fdbc82
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd048fdbc82'
${ noResults }
JUCE/modules/juce_gui_basics/native/juce_mac_NSViewComponentPee...

2705 lines
102KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE library.

  5.    Copyright (c) 2022 - 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 7 End-User License

  11.    Agreement and JUCE Privacy Policy.

  12. 

  13.    End User License Agreement: www.juce.com/juce-7-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. #include "juce_mac_CGMetalLayerRenderer.h"

  27. 

  28. @interface NSEvent (DeviceDelta)

  29. - (float)deviceDeltaX;

  30. - (float)deviceDeltaY;

  31. @end

  32. 

  33. //==============================================================================

  34. namespace juce

  35. {

  36. 

  37. using AppFocusChangeCallback = void (*)();

  38. extern AppFocusChangeCallback appFocusChangeCallback;

  39. using CheckEventBlockedByModalComps = bool (*) (NSEvent*);

  40. extern CheckEventBlockedByModalComps isEventBlockedByModalComps;

  41. 

  42. //==============================================================================

  43. static void resetTrackingArea (NSView* view)

  44. {

  45.     const auto trackingAreas = [view trackingAreas];

  46. 

  47.     jassert ([trackingAreas count] <= 1);

  48. 

  49.     for (NSTrackingArea* area in trackingAreas)

  50.         [view removeTrackingArea: area];

  51. 

  52.     const auto options = NSTrackingMouseEnteredAndExited

  53.                          | NSTrackingMouseMoved

  54.                          | NSTrackingEnabledDuringMouseDrag

  55.                          | NSTrackingActiveAlways

  56.                          | NSTrackingInVisibleRect;

  57. 

  58.     const NSUniquePtr<NSTrackingArea> trackingArea { [[NSTrackingArea alloc] initWithRect: [view bounds]

  59.                                                                                   options: options

  60.                                                                                     owner: view

  61.                                                                                  userInfo: nil] };

  62. 

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

  64. }

  65. 

  66. static constexpr int translateVirtualToAsciiKeyCode (int keyCode) noexcept

  67. {

  68.     switch (keyCode)

  69.     {

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

  71.         case 0x00: return 'A';

  72.         case 0x01: return 'S';

  73.         case 0x02: return 'D';

  74.         case 0x03: return 'F';

  75.         case 0x04: return 'H';

  76.         case 0x05: return 'G';

  77.         case 0x06: return 'Z';

  78.         case 0x07: return 'X';

  79.         case 0x08: return 'C';

  80.         case 0x09: return 'V';

  81.         case 0x0B: return 'B';

  82.         case 0x0C: return 'Q';

  83.         case 0x0D: return 'W';

  84.         case 0x0E: return 'E';

  85.         case 0x0F: return 'R';

  86.         case 0x10: return 'Y';

  87.         case 0x11: return 'T';

  88.         case 0x12: return '1';

  89.         case 0x13: return '2';

  90.         case 0x14: return '3';

  91.         case 0x15: return '4';

  92.         case 0x16: return '6';

  93.         case 0x17: return '5';

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

  95.         case 0x19: return '9';

  96.         case 0x1A: return '7';

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

  98.         case 0x1C: return '8';

  99.         case 0x1D: return '0';

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

  101.         case 0x1F: return 'O';

  102.         case 0x20: return 'U';

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

  104.         case 0x22: return 'I';

  105.         case 0x23: return 'P';

  106.         case 0x25: return 'L';

  107.         case 0x26: return 'J';

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

  109.         case 0x28: return 'K';

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

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

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

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

  114.         case 0x2D: return 'N';

  115.         case 0x2E: return 'M';

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

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

  118. 

  119.         default:   return keyCode;

  120.     }

  121. }

  122. 

  123. constexpr int extendedKeyModifier = 0x30000;

  124. 

  125. //==============================================================================

  126. class NSViewComponentPeer  : public ComponentPeer

  127. {

  128. public:

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

  130.         : ComponentPeer (comp, windowStyleFlags),

  131.           safeComponent (&comp),

  132.           isSharedWindow (viewToAttachTo != nil),

  133.           lastRepaintTime (Time::getMillisecondCounter())

  134.     {

  135.         appFocusChangeCallback = appFocusChanged;

  136.         isEventBlockedByModalComps = checkEventBlockedByModalComps;

  137. 

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

  139. 

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

  141.         setOwner (view, this);

  142. 

  143.         [view registerForDraggedTypes: getSupportedDragTypes()];

  144. 

  145.         resetTrackingArea (view);

  146. 

  147.         scopedObservers.emplace_back (view, frameChangedSelector, NSViewFrameDidChangeNotification, view);

  148. 

  149.         [view setPostsFrameChangedNotifications: YES];

  150. 

  151.       #if USE_COREGRAPHICS_RENDERING

  152.        #if JUCE_COREGRAPHICS_RENDER_WITH_MULTIPLE_PAINT_CALLS

  153.         if (@available (macOS 10.14, *))

  154.             metalRenderer = std::make_unique<CoreGraphicsMetalLayerRenderer<NSView>> (view, getComponent().isOpaque());

  155.        #endif

  156.         if ((windowStyleFlags & ComponentPeer::windowRequiresSynchronousCoreGraphicsRendering) == 0)

  157.         {

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

  159.             {

  160.                 [view setWantsLayer: YES];

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

  162.             }

  163.         }

  164.       #endif

  165. 

  166.         if (isSharedWindow)

  167.         {

  168.             window = [viewToAttachTo window];

  169.             [viewToAttachTo addSubview: view];

  170.         }

  171.         else

  172.         {

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

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

  175.             r = flippedScreenRect (r);

  176. 

  177.             window = [createWindowInstance() initWithContentRect: r

  178.                                                        styleMask: getNSWindowStyleMask (windowStyleFlags)

  179.                                                          backing: NSBackingStoreBuffered

  180.                                                            defer: YES];

  181.             [window setColorSpace: [NSColorSpace sRGBColorSpace]];

  182.             setOwner (window, this);

  183. 

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

  185.                 [window setAccessibilityElement: YES];

  186. 

  187.             [window orderOut: nil];

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

  189. 

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

  191. 

  192.             if (! [window isOpaque])

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

  194. 

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

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

  197. 

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

  199. 

  200.             if (component.isAlwaysOnTop())

  201.                 setAlwaysOnTop (true);

  202. 

  203.             [window setContentView: view];

  204. 

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

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

  207.             [window setReleasedWhenClosed: YES];

  208.             [window retain];

  209. 

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

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

  212. 

  213.             setCollectionBehaviour (false);

  214. 

  215.             [window setRestorable: NO];

  216. 

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

  218.                 [window setTabbingMode: NSWindowTabbingModeDisallowed];

  219. 

  220.             scopedObservers.emplace_back (view, frameChangedSelector, NSWindowDidMoveNotification, window);

  221.             scopedObservers.emplace_back (view, frameChangedSelector, NSWindowDidMiniaturizeNotification, window);

  222.             scopedObservers.emplace_back (view, @selector (windowWillMiniaturize:), NSWindowWillMiniaturizeNotification, window);

  223.             scopedObservers.emplace_back (view, @selector (windowDidDeminiaturize:), NSWindowDidDeminiaturizeNotification, window);

  224.         }

  225. 

  226.         auto alpha = component.getAlpha();

  227. 

  228.         if (alpha < 1.0f)

  229.             setAlpha (alpha);

  230. 

  231.         setTitle (component.getName());

  232. 

  233.         getNativeRealtimeModifiers = []

  234.         {

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

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

  237. 

  238.             return ModifierKeys::currentModifiers;

  239.         };

  240.     }

  241. 

  242.     ~NSViewComponentPeer() override

  243.     {

  244.         scopedObservers.clear();

  245. 

  246.         setOwner (view, nullptr);

  247. 

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

  249.         {

  250.             redirectWillMoveToWindow (nullptr);

  251.             [view removeFromSuperview];

  252.         }

  253. 

  254.         if (! isSharedWindow)

  255.         {

  256.             setOwner (window, nullptr);

  257.             [window setContentView: nil];

  258.             [window close];

  259.             [window release];

  260.         }

  261. 

  262.         [view release];

  263.     }

  264. 

  265.     //==============================================================================

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

  267. 

  268.     void setVisible (bool shouldBeVisible) override

  269.     {

  270.         if (isSharedWindow)

  271.         {

  272.             if (shouldBeVisible)

  273.                 [view setHidden: false];

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

  275.                 [view setHidden: true];

  276.         }

  277.         else

  278.         {

  279.             if (shouldBeVisible)

  280.             {

  281.                 ++insideToFrontCall;

  282.                 [window orderFront: nil];

  283.                 --insideToFrontCall;

  284.                 handleBroughtToFront();

  285.             }

  286.             else

  287.             {

  288.                 [window orderOut: nil];

  289.             }

  290.         }

  291.     }

  292. 

  293.     void setTitle (const String& title) override

  294.     {

  295.         JUCE_AUTORELEASEPOOL

  296.         {

  297.             if (! isSharedWindow)

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

  299.         }

  300.     }

  301. 

  302.     bool setDocumentEditedStatus (bool edited) override

  303.     {

  304.         if (! hasNativeTitleBar())

  305.             return false;

  306. 

  307.         [window setDocumentEdited: edited];

  308.         return true;

  309.     }

  310. 

  311.     void setRepresentedFile (const File& file) override

  312.     {

  313.         if (! isSharedWindow)

  314.         {

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

  316.                                                                 ? file.getFullPathName()

  317.                                                                 : String())];

  318. 

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

  320.         }

  321.     }

  322. 

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

  324.     {

  325.         auto r = makeNSRect (newBounds);

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

  327. 

  328.         if (isSharedWindow)

  329.         {

  330.             [view setFrame: r];

  331.         }

  332.         else

  333.         {

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

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

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

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

  338. 

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

  340.                      display: isPre10_11];

  341.         }

  342. 

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

  344.         {

  345.             numFramesToSkipMetalRenderer = 5;

  346.             [view setNeedsDisplay: true];

  347.         }

  348.     }

  349. 

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

  351.     {

  352.         auto r = [view frame];

  353.         NSWindow* viewWindow = [view window];

  354. 

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

  356.         {

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

  358.             r = [viewWindow convertRectToScreen: r];

  359. 

  360.             r = flippedScreenRect (r);

  361.         }

  362. 

  363.         return convertToRectInt (r);

  364.     }

  365. 

  366.     Rectangle<int> getBounds() const override

  367.     {

  368.         return getBounds (! isSharedWindow);

  369.     }

  370. 

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

  372.     {

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

  374.     }

  375. 

  376.     using ComponentPeer::localToGlobal;

  377. 

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

  379.     {

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

  381.     }

  382. 

  383.     using ComponentPeer::globalToLocal;

  384. 

  385.     void setAlpha (float newAlpha) override

  386.     {

  387.         if (isSharedWindow)

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

  389.         else

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

  391.     }

  392. 

  393.     void setMinimised (bool shouldBeMinimised) override

  394.     {

  395.         if (! isSharedWindow)

  396.         {

  397.             if (shouldBeMinimised)

  398.                 [window miniaturize: nil];

  399.             else

  400.                 [window deminiaturize: nil];

  401.         }

  402.     }

  403. 

  404.     bool isMinimised() const override

  405.     {

  406.         return [window isMiniaturized];

  407.     }

  408. 

  409.     NSWindowCollectionBehavior getCollectionBehavior (bool forceFullScreen) const

  410.     {

  411.         if (forceFullScreen)

  412.             return NSWindowCollectionBehaviorFullScreenPrimary;

  413. 

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

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

  416. 

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

  418.              ? NSWindowCollectionBehaviorFullScreenPrimary

  419.              : fullScreenNone;

  420.     }

  421. 

  422.     void setCollectionBehaviour (bool forceFullScreen) const

  423.     {

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

  425.     }

  426. 

  427.     void setFullScreen (bool shouldBeFullScreen) override

  428.     {

  429.         if (isSharedWindow)

  430.             return;

  431. 

  432.         if (shouldBeFullScreen)

  433.             setCollectionBehaviour (true);

  434. 

  435.         if (isMinimised())

  436.             setMinimised (false);

  437. 

  438.         if (shouldBeFullScreen != isFullScreen())

  439.             [window toggleFullScreen: nil];

  440.     }

  441. 

  442.     bool isFullScreen() const override

  443.     {

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

  445.     }

  446. 

  447.     bool isKioskMode() const override

  448.     {

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

  450.     }

  451. 

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

  453.     {

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

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

  456. 

  457.         return true;

  458.     }

  459. 

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

  461.     {

  462.         NSRect viewFrame = [view frame];

  463. 

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

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

  466.             return false;

  467. 

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

  469.         {

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

  471.             {

  472.                 NSRect windowFrame = [viewWindow frame];

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

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

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

  476. 

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

  478.                     return false;

  479. 

  480.             }

  481.         }

  482. 

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

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

  485. 

  486.         return trueIfInAChildWindow ? (v != nil)

  487.                                     : (v == view);

  488.     }

  489. 

  490.     OptionalBorderSize getFrameSizeIfPresent() const override

  491.     {

  492.         if (! isSharedWindow)

  493.         {

  494.             BorderSize<int> b;

  495. 

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

  497.             NSRect w = [window frame];

  498. 

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

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

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

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

  503. 

  504.             return OptionalBorderSize { b };

  505.         }

  506. 

  507.         return {};

  508.     }

  509. 

  510.     BorderSize<int> getFrameSize() const override

  511.     {

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

  513.             return *frameSize;

  514. 

  515.         return {};

  516.     }

  517. 

  518.     bool hasNativeTitleBar() const

  519.     {

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

  521.     }

  522. 

  523.     bool setAlwaysOnTop (bool alwaysOnTop) override

  524.     {

  525.         if (! isSharedWindow)

  526.         {

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

  528.                                                                                         : NSFloatingWindowLevel)

  529.                                           : NSNormalWindowLevel];

  530. 

  531.             isAlwaysOnTop = alwaysOnTop;

  532.         }

  533. 

  534.         return true;

  535.     }

  536. 

  537.     void toFront (bool makeActiveWindow) override

  538.     {

  539.         if (isSharedWindow)

  540.         {

  541.             NSView* superview = [view superview];

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

  543. 

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

  545. 

  546.             if (! isFrontmost)

  547.             {

  548.                 [view retain];

  549.                 [subviews removeObject: view];

  550.                 [subviews addObject: view];

  551. 

  552.                 [superview setSubviews: subviews];

  553.                 [view release];

  554.             }

  555.         }

  556. 

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

  558.         {

  559.             ++insideToFrontCall;

  560. 

  561.             if (makeActiveWindow)

  562.                 [window makeKeyAndOrderFront: nil];

  563.             else

  564.                 [window orderFront: nil];

  565. 

  566.             if (insideToFrontCall <= 1)

  567.             {

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

  569.                 handleBroughtToFront();

  570.             }

  571. 

  572.             --insideToFrontCall;

  573.         }

  574.     }

  575. 

  576.     void toBehind (ComponentPeer* other) override

  577.     {

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

  579.         {

  580.             if (isSharedWindow)

  581.             {

  582.                 NSView* superview = [view superview];

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

  584. 

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

  586. 

  587.                 if (otherViewIndex == NSNotFound)

  588.                     return;

  589. 

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

  591. 

  592.                 if (! isBehind)

  593.                 {

  594.                     [view retain];

  595.                     [subviews removeObject: view];

  596.                     [subviews insertObject: view

  597.                                    atIndex: otherViewIndex];

  598. 

  599.                     [superview setSubviews: subviews];

  600.                     [view release];

  601.                 }

  602.             }

  603.             else if (component.isVisible())

  604.             {

  605.                 [window orderWindow: NSWindowBelow

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

  607.             }

  608.         }

  609.         else

  610.         {

  611.             jassertfalse; // wrong type of window?

  612.         }

  613.     }

  614. 

  615.     void setIcon (const Image& newIcon) override

  616.     {

  617.         if (! isSharedWindow)

  618.         {

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

  620.             if (! windowRepresentsFile)

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

  622. 

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

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

  625.         }

  626.     }

  627. 

  628.     StringArray getAvailableRenderingEngines() override

  629.     {

  630.         StringArray s ("Software Renderer");

  631. 

  632.        #if USE_COREGRAPHICS_RENDERING

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

  634.        #endif

  635. 

  636.         return s;

  637.     }

  638. 

  639.     int getCurrentRenderingEngine() const override

  640.     {

  641.         return usingCoreGraphics ? 1 : 0;

  642.     }

  643. 

  644.     void setCurrentRenderingEngine (int index) override

  645.     {

  646.        #if USE_COREGRAPHICS_RENDERING

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

  648.         {

  649.             usingCoreGraphics = index > 0;

  650.             [view setNeedsDisplay: true];

  651.         }

  652.        #else

  653.         ignoreUnused (index);

  654.        #endif

  655.     }

  656. 

  657.     void redirectMouseDown (NSEvent* ev)

  658.     {

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

  660.             Process::makeForegroundProcess();

  661. 

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

  663.         sendMouseEvent (ev);

  664.     }

  665. 

  666.     void redirectMouseUp (NSEvent* ev)

  667.     {

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

  669.         sendMouseEvent (ev);

  670.         showArrowCursorIfNeeded();

  671.     }

  672. 

  673.     void redirectMouseDrag (NSEvent* ev)

  674.     {

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

  676.         sendMouseEvent (ev);

  677.     }

  678. 

  679.     void redirectMouseMove (NSEvent* ev)

  680.     {

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

  682. 

  683.         NSPoint windowPos = [ev locationInWindow];

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

  685. 

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

  687.             sendMouseEvent (ev);

  688.         else

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

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

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

  692. 

  693.         showArrowCursorIfNeeded();

  694.     }

  695. 

  696.     void redirectMouseEnter (NSEvent* ev)

  697.     {

  698.         sendMouseEnterExit (ev);

  699.     }

  700. 

  701.     void redirectMouseExit (NSEvent* ev)

  702.     {

  703.         sendMouseEnterExit (ev);

  704.     }

  705. 

  706.     static float checkDeviceDeltaReturnValue (float v) noexcept

  707.     {

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

  709.         v *= 0.5f / 256.0f;

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

  711.     }

  712. 

  713.     void redirectMouseWheel (NSEvent* ev)

  714.     {

  715.         updateModifiers (ev);

  716. 

  717.         MouseWheelDetails wheel;

  718.         wheel.deltaX = 0;

  719.         wheel.deltaY = 0;

  720.         wheel.isReversed = false;

  721.         wheel.isSmooth = false;

  722.         wheel.isInertial = false;

  723. 

  724.         @try

  725.         {

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

  727.                 wheel.isReversed = [ev isDirectionInvertedFromDevice];

  728. 

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

  730. 

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

  732.             {

  733.                 if ([ev hasPreciseScrollingDeltas])

  734.                 {

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

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

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

  738.                     wheel.isSmooth = true;

  739.                 }

  740.             }

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

  742.             {

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

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

  745.             }

  746.         }

  747.         @catch (...)

  748.         {}

  749. 

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

  751.         {

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

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

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

  755.         }

  756. 

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

  758.     }

  759. 

  760.     void redirectMagnify (NSEvent* ev)

  761.     {

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

  763. 

  764.         if (invScale > 0.0f)

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

  766.     }

  767. 

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

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

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

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

  772. 

  773.     void redirectWillMoveToWindow (NSWindow* newWindow)

  774.     {

  775.         windowObservers.clear();

  776. 

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

  778.         {

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

  780.                 comp->setVisible (false);

  781.         }

  782.     }

  783. 

  784.     void sendMouseEvent (NSEvent* ev)

  785.     {

  786.         updateModifiers (ev);

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

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

  789.     }

  790. 

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

  792.     {

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

  794.         auto keyCode = getKeyCodeFromEvent (ev);

  795. 

  796.        #if JUCE_DEBUG_KEYCODES

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

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

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

  800.        #endif

  801. 

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

  803.         {

  804.             if (isKeyDown)

  805.             {

  806.                 bool used = false;

  807. 

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

  809.                 {

  810.                     auto textCharacter = u.getAndAdvance();

  811. 

  812.                     switch (keyCode)

  813.                     {

  814.                         case NSLeftArrowFunctionKey:

  815.                         case NSRightArrowFunctionKey:

  816.                         case NSUpArrowFunctionKey:

  817.                         case NSDownArrowFunctionKey:

  818.                         case NSPageUpFunctionKey:

  819.                         case NSPageDownFunctionKey:

  820.                         case NSEndFunctionKey:

  821.                         case NSHomeFunctionKey:

  822.                         case NSDeleteFunctionKey:

  823.                             textCharacter = 0;

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

  825. 

  826.                         default:

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

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

  829.                                 textCharacter = 0;

  830.                             break;

  831.                     }

  832. 

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

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

  835.                 }

  836. 

  837.                 return used;

  838.             }

  839. 

  840.             if (handleKeyUpOrDown (false))

  841.                 return true;

  842.         }

  843. 

  844.         return false;

  845.     }

  846. 

  847.     bool redirectKeyDown (NSEvent* ev)

  848.     {

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

  850.         // our event object gets lost)

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

  852. 

  853.         updateKeysDown (ev, true);

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

  855. 

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

  857.         {

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

  859.             updateKeysDown (ev, false);

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

  861.         }

  862. 

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

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

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

  866.             used = true;

  867. 

  868.         return used;

  869.     }

  870. 

  871.     bool redirectKeyUp (NSEvent* ev)

  872.     {

  873.         updateKeysDown (ev, false);

  874.         return handleKeyEvent (ev, false)

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

  876.     }

  877. 

  878.     void redirectModKeyChange (NSEvent* ev)

  879.     {

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

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

  882. 

  883.         keysCurrentlyDown.clear();

  884.         handleKeyUpOrDown (true);

  885. 

  886.         updateModifiers (ev);

  887.         handleModifierKeysChange();

  888.     }

  889. 

  890.     //==============================================================================

  891.     void drawRect (NSRect r)

  892.     {

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

  894.             return;

  895. 

  896.         auto cg = []

  897.         {

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

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

  900. 

  901.             JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wdeprecated-declarations")

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

  903.             JUCE_END_IGNORE_WARNINGS_GCC_LIKE

  904.         }();

  905. 

  906.         drawRectWithContext (cg, r);

  907.     }

  908. 

  909.     void drawRectWithContext (CGContextRef cg, NSRect r)

  910.     {

  911.         if (! component.isOpaque())

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

  913. 

  914.         float displayScale = 1.0f;

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

  916. 

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

  918.             displayScale = (float) screen.backingScaleFactor;

  919. 

  920.         auto invalidateTransparentWindowShadow = [this]

  921.         {

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

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

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

  925.                 [window invalidateShadow];

  926.         };

  927. 

  928.        #if USE_COREGRAPHICS_RENDERING && JUCE_COREGRAPHICS_RENDER_WITH_MULTIPLE_PAINT_CALLS

  929.         // This was a workaround for a CGContext not having a way of finding whether a rectangle

  930.         // falls within its clip region. However Apple removed the capability of

  931.         // [view getRectsBeingDrawn: ...] sometime around 10.13, so on later versions of macOS

  932.         // numRects will always be 1 and you'll need to use a CoreGraphicsMetalLayerRenderer

  933.         // to avoid CoreGraphics consolidating disparate rects.

  934.         if (usingCoreGraphics && metalRenderer == nullptr)

  935.         {

  936.             const NSRect* rects = nullptr;

  937.             NSInteger numRects = 0;

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

  939. 

  940.             if (numRects > 1)

  941.             {

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

  943.                 {

  944.                     NSRect rect = rects[i];

  945.                     CGContextSaveGState (cg);

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

  947.                     renderRect (cg, rect, displayScale);

  948.                     CGContextRestoreGState (cg);

  949.                 }

  950. 

  951.                 invalidateTransparentWindowShadow();

  952.                 return;

  953.             }

  954.         }

  955.        #endif

  956. 

  957.         renderRect (cg, r, displayScale);

  958.         invalidateTransparentWindowShadow();

  959.     }

  960. 

  961.     void renderRect (CGContextRef cg, NSRect r, float displayScale)

  962.     {

  963.        #if USE_COREGRAPHICS_RENDERING

  964.         if (usingCoreGraphics)

  965.         {

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

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

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

  969.             handlePaint (context);

  970.         }

  971.         else

  972.        #endif

  973.         {

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

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

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

  977. 

  978.             RectangleList<int> clip;

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

  980. 

  981.             if (! clip.isEmpty())

  982.             {

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

  984.                             roundToInt (clipW * displayScale),

  985.                             roundToInt (clipH * displayScale),

  986.                             ! component.isOpaque());

  987. 

  988.                 {

  989.                     auto intScale = roundToInt (displayScale);

  990. 

  991.                     if (intScale != 1)

  992.                         clip.scaleAll (intScale);

  993. 

  994.                     auto context = component.getLookAndFeel()

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

  996. 

  997.                     if (intScale != 1)

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

  999. 

  1000.                     handlePaint (*context);

  1001.                 }

  1002. 

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

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

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

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

  1007.                 CGImageRelease (image);

  1008.             }

  1009.         }

  1010.     }

  1011. 

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

  1013.     {

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

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

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

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

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

  1019.         deferredRepaints.add (area.toFloat());

  1020.     }

  1021. 

  1022.     static bool shouldThrottleRepaint()

  1023.     {

  1024.         return areAnyWindowsInLiveResize();

  1025.     }

  1026. 

  1027.     void setNeedsDisplayRectangles()

  1028.     {

  1029.         if (deferredRepaints.isEmpty())

  1030.             return;

  1031. 

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

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

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

  1035. 

  1036.         constexpr uint32 minimumRepaintInterval = 1000 / 30; // 30fps

  1037. 

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

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

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

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

  1042.             return;

  1043. 

  1044.         if (metalRenderer != nullptr)

  1045.         {

  1046.             auto setDeferredRepaintsToWholeFrame = [this]

  1047.             {

  1048.                 const auto frameSize = view.frame.size;

  1049.                 deferredRepaints = Rectangle<float> { (float) frameSize.width, (float) frameSize.height };

  1050.             };

  1051. 

  1052.             // If we are resizing we need to fall back to synchronous drawing to avoid artefacts

  1053.             if ([window inLiveResize] || numFramesToSkipMetalRenderer > 0)

  1054.             {

  1055.                 if (metalRenderer->isAttachedToView (view))

  1056.                 {

  1057.                     metalRenderer->detach();

  1058.                     setDeferredRepaintsToWholeFrame();

  1059.                 }

  1060. 

  1061.                 if (numFramesToSkipMetalRenderer > 0)

  1062.                     --numFramesToSkipMetalRenderer;

  1063.             }

  1064.             else

  1065.             {

  1066.                 if (! metalRenderer->isAttachedToView (view))

  1067.                 {

  1068.                     metalRenderer->attach (view, getComponent().isOpaque());

  1069.                     setDeferredRepaintsToWholeFrame();

  1070.                 }

  1071.             }

  1072.         }

  1073. 

  1074.         auto dispatchRectangles = [this]

  1075.         {

  1076.            if (metalRenderer != nullptr && metalRenderer->isAttachedToView (view))

  1077.                return metalRenderer->drawRectangleList (view,

  1078.                                                         (float) [[view window] backingScaleFactor],

  1079.                                                         [this] (CGContextRef ctx, CGRect r) { drawRectWithContext (ctx, r); },

  1080.                                                         deferredRepaints);

  1081. 

  1082.             for (auto& i : deferredRepaints)

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

  1084. 

  1085.             return true;

  1086.         };

  1087. 

  1088.         if (dispatchRectangles())

  1089.         {

  1090.             lastRepaintTime = Time::getMillisecondCounter();

  1091.             deferredRepaints.clear();

  1092.         }

  1093.     }

  1094. 

  1095.     void performAnyPendingRepaintsNow() override

  1096.     {

  1097.         [view displayIfNeeded];

  1098.     }

  1099. 

  1100.     static bool areAnyWindowsInLiveResize() noexcept

  1101.     {

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

  1103.             if ([w inLiveResize])

  1104.                 return true;

  1105. 

  1106.         return false;

  1107.     }

  1108. 

  1109.     //==============================================================================

  1110.     bool isBlockedByModalComponent()

  1111.     {

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

  1113.         {

  1114.             if (insideToFrontCall == 0

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

  1116.                  && getComponent().isCurrentlyBlockedByAnotherModalComponent())

  1117.             {

  1118.                 return true;

  1119.             }

  1120.         }

  1121. 

  1122.         return false;

  1123.     }

  1124. 

  1125.     enum class KeyWindowChanged { no, yes };

  1126. 

  1127.     void sendModalInputAttemptIfBlocked (KeyWindowChanged keyChanged)

  1128.     {

  1129.         if (! isBlockedByModalComponent())

  1130.             return;

  1131. 

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

  1133.         {

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

  1135.             {

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

  1137. 

  1138.                 if (! modalPeerIsTemporary)

  1139.                     return;

  1140. 

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

  1142.                 // component that is now key.

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

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

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

  1146. 

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

  1148.                     return;

  1149. 

  1150.                 modal->inputAttemptWhenModal();

  1151.             }

  1152.         }

  1153.     }

  1154. 

  1155.     bool canBecomeKeyWindow()

  1156.     {

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

  1158.     }

  1159. 

  1160.     bool canBecomeMainWindow()

  1161.     {

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

  1163.     }

  1164. 

  1165.     bool worksWhenModal() const

  1166.     {

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

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

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

  1170.         return ! JUCEApplication::isStandaloneApp();

  1171.     }

  1172. 

  1173.     void becomeKeyWindow()

  1174.     {

  1175.         handleBroughtToFront();

  1176.         grabFocus();

  1177.     }

  1178. 

  1179.     void resignKeyWindow()

  1180.     {

  1181.         viewFocusLoss();

  1182.     }

  1183. 

  1184.     bool windowShouldClose()

  1185.     {

  1186.         if (! isValidPeer (this))

  1187.             return YES;

  1188. 

  1189.         handleUserClosingWindow();

  1190.         return NO;

  1191.     }

  1192. 

  1193.     void redirectMovedOrResized()

  1194.     {

  1195.         handleMovedOrResized();

  1196.         setNeedsDisplayRectangles();

  1197.     }

  1198. 

  1199.     void viewMovedToWindow()

  1200.     {

  1201.         if (isSharedWindow)

  1202.         {

  1203.             auto newWindow = [view window];

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

  1205. 

  1206.             window = newWindow;

  1207. 

  1208.             if (shouldSetVisible)

  1209.                 getComponent().setVisible (true);

  1210.         }

  1211. 

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

  1213.         {

  1214.             windowObservers.emplace_back (view, dismissModalsSelector, NSWindowWillMoveNotification, currentWindow);

  1215.             windowObservers.emplace_back (view, dismissModalsSelector, NSWindowWillMiniaturizeNotification, currentWindow);

  1216.             windowObservers.emplace_back (view, becomeKeySelector, NSWindowDidBecomeKeyNotification, currentWindow);

  1217.             windowObservers.emplace_back (view, resignKeySelector, NSWindowDidResignKeyNotification, currentWindow);

  1218.         }

  1219.     }

  1220. 

  1221.     void dismissModals()

  1222.     {

  1223.         if (hasNativeTitleBar() || isSharedWindow)

  1224.             sendModalInputAttemptIfBlocked (KeyWindowChanged::no);

  1225.     }

  1226. 

  1227.     void becomeKey()

  1228.     {

  1229.         component.repaint();

  1230.     }

  1231. 

  1232.     void resignKey()

  1233.     {

  1234.         viewFocusLoss();

  1235.         sendModalInputAttemptIfBlocked (KeyWindowChanged::yes);

  1236.     }

  1237. 

  1238.     void liveResizingStart()

  1239.     {

  1240.         if (constrainer == nullptr)

  1241.             return;

  1242. 

  1243.         constrainer->resizeStart();

  1244.         isFirstLiveResize = true;

  1245. 

  1246.         setFullScreenSizeConstraints (*constrainer);

  1247.     }

  1248. 

  1249.     void liveResizingEnd()

  1250.     {

  1251.         if (constrainer != nullptr)

  1252.             constrainer->resizeEnd();

  1253.     }

  1254. 

  1255.     NSRect constrainRect (const NSRect r)

  1256.     {

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

  1258.             return r;

  1259. 

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

  1261. 

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

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

  1264. 

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

  1266. 

  1267.         const bool inLiveResize = [window inLiveResize];

  1268. 

  1269.         if (! inLiveResize || isFirstLiveResize)

  1270.         {

  1271.             isFirstLiveResize = false;

  1272. 

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

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

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

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

  1277.         }

  1278. 

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

  1280.                                   isStretchingTop, isStretchingLeft, isStretchingBottom, isStretchingRight);

  1281. 

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

  1283.     }

  1284. 

  1285.     static void showArrowCursorIfNeeded()

  1286.     {

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

  1288.         auto mouse = desktop.getMainMouseSource();

  1289. 

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

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

  1292.         {

  1293.             [[NSCursor arrowCursor] set];

  1294.         }

  1295.     }

  1296. 

  1297.     static void updateModifiers (NSEvent* e)

  1298.     {

  1299.         updateModifiers ([e modifierFlags]);

  1300.     }

  1301. 

  1302.     static void updateModifiers (const NSUInteger flags)

  1303.     {

  1304.         int m = 0;

  1305. 

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

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

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

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

  1310. 

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

  1312.     }

  1313. 

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

  1315.     {

  1316.         updateModifiers (ev);

  1317. 

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

  1319.         {

  1320.             if (isKeyDown)

  1321.                 keysCurrentlyDown.addIfNotAlreadyThere (keyCode);

  1322.             else

  1323.                 keysCurrentlyDown.removeFirstMatchingValue (keyCode);

  1324.         }

  1325.     }

  1326. 

  1327.     static int getKeyCodeFromEvent (NSEvent* ev)

  1328.     {

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

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

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

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

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

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

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

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

  1337.         // if the shift key was not pressed

  1338.         String unmodified = nsStringToJuce ([ev charactersIgnoringModifiers]);

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

  1340. 

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

  1342.             keyCode = '\t';

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

  1344.             keyCode = '\r';

  1345.         else

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

  1347. 

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

  1349.         // keyboard control over the application.

  1350.         //

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

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

  1353.         // non-printing ranges.

  1354.         if (keyCode > 0xff

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

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

  1357.         {

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

  1359.         }

  1360. 

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

  1362.         {

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

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

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

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

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

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

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

  1370.                                               '.', KeyPress::numberPadDecimalPoint,

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

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

  1373. 

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

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

  1376.                     keyCode = numPadConversions [i + 1];

  1377.         }

  1378. 

  1379.         return keyCode;

  1380.     }

  1381. 

  1382.     static int64 getMouseTime (NSEvent* e) noexcept

  1383.     {

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

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

  1386.     }

  1387. 

  1388.     static float getMousePressure (NSEvent* e) noexcept

  1389.     {

  1390.         @try

  1391.         {

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

  1393.                 return (float) e.pressure;

  1394.         }

  1395.         @catch (NSException* e) {}

  1396.         @finally {}

  1397. 

  1398.         return 0.0f;

  1399.     }

  1400. 

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

  1402.     {

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

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

  1405.     }

  1406. 

  1407.     static int getModifierForButtonNumber (const NSInteger num)

  1408.     {

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

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

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

  1412.     }

  1413. 

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

  1415.     {

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

  1417.                                                               : NSWindowStyleMaskBorderless;

  1418. 

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

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

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

  1422.         return style;

  1423.     }

  1424. 

  1425.     static NSArray* getSupportedDragTypes()

  1426.     {

  1427.         const auto type = []

  1428.         {

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

  1430.                 return NSPasteboardTypeFileURL;

  1431. 

  1432.             JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wdeprecated-declarations")

  1433.             return (NSString*) kUTTypeFileURL;

  1434.             JUCE_END_IGNORE_WARNINGS_GCC_LIKE

  1435.         }();

  1436. 

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

  1438.     }

  1439. 

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

  1441.     {

  1442.         NSPasteboard* pasteboard = [sender draggingPasteboard];

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

  1444. 

  1445.         if (contentType == nil)

  1446.             return false;

  1447. 

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

  1449. 

  1450.         ComponentPeer::DragInfo dragInfo;

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

  1452. 

  1453.         if (contentType == NSPasteboardTypeString)

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

  1455.         else

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

  1457. 

  1458.         if (! dragInfo.isEmpty())

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

  1460. 

  1461.         return false;

  1462.     }

  1463. 

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

  1465.     {

  1466.         StringArray files;

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

  1468. 

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

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

  1471.         {

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

  1473. 

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

  1475.             {

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

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

  1478.                 NSEnumerator* enumerator = [tracks objectEnumerator];

  1479.                 NSDictionary* track;

  1480. 

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

  1482.                 {

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

  1484.                     {

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

  1486. 

  1487.                         if ([url isFileURL])

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

  1489.                     }

  1490.                 }

  1491.             }

  1492.         }

  1493.         else

  1494.         {

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

  1496. 

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

  1498.             {

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

  1500. 

  1501.                 if ([url isFileURL])

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

  1503.             }

  1504.         }

  1505. 

  1506.         return files;

  1507.     }

  1508. 

  1509.     //==============================================================================

  1510.     void viewFocusGain()

  1511.     {

  1512.         if (currentlyFocusedPeer != this)

  1513.         {

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

  1515.                 currentlyFocusedPeer->handleFocusLoss();

  1516. 

  1517.             currentlyFocusedPeer = this;

  1518.             handleFocusGain();

  1519.         }

  1520.     }

  1521. 

  1522.     void viewFocusLoss()

  1523.     {

  1524.         if (currentlyFocusedPeer == this)

  1525.         {

  1526.             currentlyFocusedPeer = nullptr;

  1527.             handleFocusLoss();

  1528.         }

  1529.     }

  1530. 

  1531.     bool isFocused() const override

  1532.     {

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

  1534.                     ? this == currentlyFocusedPeer

  1535.                     : [window isKeyWindow];

  1536.     }

  1537. 

  1538.     void grabFocus() override

  1539.     {

  1540.         if (window != nil)

  1541.         {

  1542.             [window makeKeyWindow];

  1543.             [window makeFirstResponder: view];

  1544. 

  1545.             viewFocusGain();

  1546.         }

  1547.     }

  1548. 

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

  1550. 

  1551.     void closeInputMethodContext() override

  1552.     {

  1553.         stringBeingComposed.clear();

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

  1555. 

  1556.         if (inputContext != nil)

  1557.             [inputContext discardMarkedText];

  1558.     }

  1559. 

  1560.     void resetWindowPresentation()

  1561.     {

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

  1563. 

  1564.         if (hasNativeTitleBar())

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

  1566. 

  1567.         [NSApp setPresentationOptions: NSApplicationPresentationDefault];

  1568.         setCollectionBehaviour (isFullScreen());

  1569.     }

  1570. 

  1571.     void setHasChangedSinceSaved (bool b) override

  1572.     {

  1573.         if (! isSharedWindow)

  1574.             [window setDocumentEdited: b];

  1575.     }

  1576. 

  1577.     //==============================================================================

  1578.     NSWindow* window = nil;

  1579.     NSView* view = nil;

  1580.     WeakReference<Component> safeComponent;

  1581.     bool isSharedWindow = false;

  1582.    #if USE_COREGRAPHICS_RENDERING

  1583.     bool usingCoreGraphics = true;

  1584.    #else

  1585.     bool usingCoreGraphics = false;

  1586.    #endif

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

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

  1589.     bool windowRepresentsFile = false;

  1590.     bool isAlwaysOnTop = false, wasAlwaysOnTop = false;

  1591.     String stringBeingComposed;

  1592. 

  1593.     Rectangle<float> lastSizeBeforeZoom;

  1594.     RectangleList<float> deferredRepaints;

  1595.     uint32 lastRepaintTime;

  1596. 

  1597.     static ComponentPeer* currentlyFocusedPeer;

  1598.     static Array<int> keysCurrentlyDown;

  1599.     static int insideToFrontCall;

  1600. 

  1601.     static const SEL dismissModalsSelector;

  1602.     static const SEL frameChangedSelector;

  1603.     static const SEL asyncMouseDownSelector;

  1604.     static const SEL asyncMouseUpSelector;

  1605.     static const SEL becomeKeySelector;

  1606.     static const SEL resignKeySelector;

  1607. 

  1608. private:

  1609.     JUCE_DECLARE_WEAK_REFERENCEABLE (NSViewComponentPeer)

  1610. 

  1611.     // Note: the OpenGLContext also has a SharedResourcePointer<PerScreenDisplayLinks> to

  1612.     // avoid unnecessarily duplicating display-link threads.

  1613.     SharedResourcePointer<PerScreenDisplayLinks> sharedDisplayLinks;

  1614. 

  1615.     class AsyncRepainter : private AsyncUpdater

  1616.     {

  1617.     public:

  1618.         explicit AsyncRepainter (NSViewComponentPeer& o) : owner (o) {}

  1619.         ~AsyncRepainter() override { cancelPendingUpdate(); }

  1620. 

  1621.         void markUpdated (const CGDirectDisplayID x)

  1622.         {

  1623.             {

  1624.                 const std::scoped_lock lock { mutex };

  1625. 

  1626.                 if (std::find (backgroundDisplays.cbegin(), backgroundDisplays.cend(), x) == backgroundDisplays.cend())

  1627.                     backgroundDisplays.push_back (x);

  1628.             }

  1629. 

  1630.             triggerAsyncUpdate();

  1631.         }

  1632. 

  1633.     private:

  1634.         void handleAsyncUpdate() override

  1635.         {

  1636.             {

  1637.                 const std::scoped_lock lock { mutex };

  1638.                 mainThreadDisplays = backgroundDisplays;

  1639.                 backgroundDisplays.clear();

  1640.             }

  1641. 

  1642.             for (const auto& display : mainThreadDisplays)

  1643.                 if (auto* peerView = owner.view)

  1644.                     if (auto* peerWindow = [peerView window])

  1645.                         if (display == ScopedDisplayLink::getDisplayIdForScreen ([peerWindow screen]))

  1646.                             owner.setNeedsDisplayRectangles();

  1647.         }

  1648. 

  1649.         NSViewComponentPeer& owner;

  1650.         std::mutex mutex;

  1651.         std::vector<CGDirectDisplayID> backgroundDisplays, mainThreadDisplays;

  1652.     };

  1653. 

  1654.     AsyncRepainter asyncRepainter { *this };

  1655. 

  1656.     /*  Creates a function object that can be called from an arbitrary thread (probably a CVLink

  1657.         thread). When called, this function object will trigger a call to setNeedsDisplayRectangles

  1658.         as soon as possible on the main thread, for any peers currently on the provided NSScreen.

  1659.     */

  1660.     PerScreenDisplayLinks::Connection connection

  1661.     {

  1662.         sharedDisplayLinks->registerFactory ([this] (CGDirectDisplayID display)

  1663.         {

  1664.             return [this, display] { asyncRepainter.markUpdated (display); };

  1665.         })

  1666.     };

  1667. 

  1668.     static NSView* createViewInstance();

  1669.     static NSWindow* createWindowInstance();

  1670. 

  1671.     void sendMouseEnterExit (NSEvent* ev)

  1672.     {

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

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

  1675.                 return;

  1676. 

  1677.         sendMouseEvent (ev);

  1678.     }

  1679. 

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

  1681.     {

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

  1683.     }

  1684. 

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

  1686.     {

  1687.         const NSRect* rects = nullptr;

  1688.         NSInteger numRects = 0;

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

  1690. 

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

  1692. 

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

  1694. 

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

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

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

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

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

  1700.     }

  1701. 

  1702.     static void appFocusChanged()

  1703.     {

  1704.         keysCurrentlyDown.clear();

  1705. 

  1706.         if (isValidPeer (currentlyFocusedPeer))

  1707.         {

  1708.             if (Process::isForegroundProcess())

  1709.             {

  1710.                 currentlyFocusedPeer->handleFocusGain();

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

  1712.             }

  1713.             else

  1714.             {

  1715.                 currentlyFocusedPeer->handleFocusLoss();

  1716.             }

  1717.         }

  1718.     }

  1719. 

  1720.     static bool checkEventBlockedByModalComps (NSEvent* e)

  1721.     {

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

  1723.             return false;

  1724. 

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

  1726. 

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

  1728.             return false;

  1729. 

  1730.         bool isKey = false, isInputAttempt = false;

  1731. 

  1732.         switch ([e type])

  1733.         {

  1734.             case NSEventTypeKeyDown:

  1735.             case NSEventTypeKeyUp:

  1736.                 isKey = isInputAttempt = true;

  1737.                 break;

  1738. 

  1739.             case NSEventTypeLeftMouseDown:

  1740.             case NSEventTypeRightMouseDown:

  1741.             case NSEventTypeOtherMouseDown:

  1742.                 isInputAttempt = true;

  1743.                 break;

  1744. 

  1745.             case NSEventTypeLeftMouseDragged:

  1746.             case NSEventTypeRightMouseDragged:

  1747.             case NSEventTypeLeftMouseUp:

  1748.             case NSEventTypeRightMouseUp:

  1749.             case NSEventTypeOtherMouseUp:

  1750.             case NSEventTypeOtherMouseDragged:

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

  1752.                     return false;

  1753.                 break;

  1754. 

  1755.             case NSEventTypeMouseMoved:

  1756.             case NSEventTypeMouseEntered:

  1757.             case NSEventTypeMouseExited:

  1758.             case NSEventTypeCursorUpdate:

  1759.             case NSEventTypeScrollWheel:

  1760.             case NSEventTypeTabletPoint:

  1761.             case NSEventTypeTabletProximity:

  1762.                 break;

  1763. 

  1764.             case NSEventTypeFlagsChanged:

  1765.             case NSEventTypeAppKitDefined:

  1766.             case NSEventTypeSystemDefined:

  1767.             case NSEventTypeApplicationDefined:

  1768.             case NSEventTypePeriodic:

  1769.             case NSEventTypeGesture:

  1770.             case NSEventTypeMagnify:

  1771.             case NSEventTypeSwipe:

  1772.             case NSEventTypeRotate:

  1773.             case NSEventTypeBeginGesture:

  1774.             case NSEventTypeEndGesture:

  1775.             case NSEventTypeQuickLook:

  1776.            #if JUCE_64BIT

  1777.             case NSEventTypeSmartMagnify:

  1778.             case NSEventTypePressure:

  1779.             case NSEventTypeDirectTouch:

  1780.            #endif

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

  1782.             case NSEventTypeChangeMode:

  1783.            #endif

  1784.             default:

  1785.                 return false;

  1786.         }

  1787. 

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

  1789.         {

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

  1791.             {

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

  1793.                 {

  1794.                     if (isKey)

  1795.                     {

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

  1797.                             return false;

  1798.                     }

  1799.                     else

  1800.                     {

  1801.                         if (peer->isSharedWindow

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

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

  1804.                             return false;

  1805.                     }

  1806.                 }

  1807.             }

  1808.         }

  1809. 

  1810.         if (isInputAttempt)

  1811.         {

  1812.             if (! [NSApp isActive])

  1813.                 [NSApp activateIgnoringOtherApps: YES];

  1814. 

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

  1816.                 modal->inputAttemptWhenModal();

  1817.         }

  1818. 

  1819.         return true;

  1820.     }

  1821. 

  1822.     void setFullScreenSizeConstraints (const ComponentBoundsConstrainer& c)

  1823.     {

  1824.         if (@available (macOS 10.11, *))

  1825.         {

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

  1827.                                              0.0f);

  1828.             [window setMinFullScreenContentSize: minSize];

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

  1830.         }

  1831.     }

  1832. 

  1833.     //==============================================================================

  1834.     int numFramesToSkipMetalRenderer = 0;

  1835.     std::unique_ptr<CoreGraphicsMetalLayerRenderer<NSView>> metalRenderer;

  1836. 

  1837.     std::vector<ScopedNotificationCenterObserver> scopedObservers;

  1838.     std::vector<ScopedNotificationCenterObserver> windowObservers;

  1839. 

  1840.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (NSViewComponentPeer)

  1841. };

  1842. 

  1843. int NSViewComponentPeer::insideToFrontCall = 0;

  1844. 

  1845. JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wundeclared-selector")

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

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

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

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

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

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

  1852. JUCE_END_IGNORE_WARNINGS_GCC_LIKE

  1853. 

  1854. //==============================================================================

  1855. template <typename Base>

  1856. struct NSViewComponentPeerWrapper  : public Base

  1857. {

  1858.     explicit NSViewComponentPeerWrapper (const char* baseName)

  1859.         : Base (baseName)

  1860.     {

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

  1862.     }

  1863. 

  1864.     static NSViewComponentPeer* getOwner (id self)

  1865.     {

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

  1867.     }

  1868. 

  1869.     static id getAccessibleChild (id self)

  1870.     {

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

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

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

  1874. 

  1875.         return nil;

  1876.     }

  1877. };

  1878. 

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

  1880. {

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

  1882.     {

  1883.         addMethod (@selector (isOpaque), [] (id self, SEL)

  1884.         {

  1885.             auto* owner = getOwner (self);

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

  1887.         });

  1888. 

  1889.         addMethod (@selector (updateTrackingAreas), [] (id self, SEL)

  1890.         {

  1891.             sendSuperclassMessage<void> (self, @selector (updateTrackingAreas));

  1892. 

  1893.             resetTrackingArea (static_cast<NSView*> (self));

  1894.         });

  1895. 

  1896.         addMethod (@selector (becomeFirstResponder), [] (id self, SEL)

  1897.         {

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

  1899.             return YES;

  1900.         });

  1901. 

  1902.         addMethod (@selector (resignFirstResponder), [] (id self, SEL)

  1903.         {

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

  1905.             return YES;

  1906.         });

  1907. 

  1908.         addMethod (NSViewComponentPeer::dismissModalsSelector,  [] (id self, SEL)                    { callOnOwner (self, &NSViewComponentPeer::dismissModals); });

  1909.         addMethod (NSViewComponentPeer::frameChangedSelector,   [] (id self, SEL, NSNotification*)   { callOnOwner (self, &NSViewComponentPeer::redirectMovedOrResized); });

  1910.         addMethod (NSViewComponentPeer::becomeKeySelector,      [] (id self, SEL)                    { callOnOwner (self, &NSViewComponentPeer::becomeKey); });

  1911.         addMethod (NSViewComponentPeer::resignKeySelector,      [] (id self, SEL)                    { callOnOwner (self, &NSViewComponentPeer::resignKey); });

  1912. 

  1913.         addMethod (@selector (paste:),                          [] (id self, SEL, NSObject* s)       { callOnOwner (self, &NSViewComponentPeer::redirectPaste,            s);  });

  1914.         addMethod (@selector (copy:),                           [] (id self, SEL, NSObject* s)       { callOnOwner (self, &NSViewComponentPeer::redirectCopy,             s);  });

  1915.         addMethod (@selector (cut:),                            [] (id self, SEL, NSObject* s)       { callOnOwner (self, &NSViewComponentPeer::redirectCut,              s);  });

  1916.         addMethod (@selector (selectAll:),                      [] (id self, SEL, NSObject* s)       { callOnOwner (self, &NSViewComponentPeer::redirectSelectAll,        s);  });

  1917. 

  1918.         addMethod (@selector (viewWillMoveToWindow:),           [] (id self, SEL, NSWindow* w)       { callOnOwner (self, &NSViewComponentPeer::redirectWillMoveToWindow, w); });

  1919. 

  1920.         addMethod (@selector (drawRect:),                       [] (id self, SEL, NSRect r)          { callOnOwner (self, &NSViewComponentPeer::drawRect, r); });

  1921.         addMethod (@selector (viewDidMoveToWindow),             [] (id self, SEL)                    { callOnOwner (self, &NSViewComponentPeer::viewMovedToWindow); });

  1922.         addMethod (@selector (flagsChanged:),                   [] (id self, SEL, NSEvent* ev)       { callOnOwner (self, &NSViewComponentPeer::redirectModKeyChange, ev); });

  1923.         addMethod (@selector (mouseMoved:),                     [] (id self, SEL, NSEvent* ev)       { callOnOwner (self, &NSViewComponentPeer::redirectMouseMove,    ev); });

  1924.         addMethod (@selector (mouseEntered:),                   [] (id self, SEL, NSEvent* ev)       { callOnOwner (self, &NSViewComponentPeer::redirectMouseEnter,   ev); });

  1925.         addMethod (@selector (mouseExited:),                    [] (id self, SEL, NSEvent* ev)       { callOnOwner (self, &NSViewComponentPeer::redirectMouseExit,    ev); });

  1926.         addMethod (@selector (scrollWheel:),                    [] (id self, SEL, NSEvent* ev)       { callOnOwner (self, &NSViewComponentPeer::redirectMouseWheel,   ev); });

  1927.         addMethod (@selector (magnifyWithEvent:),               [] (id self, SEL, NSEvent* ev)       { callOnOwner (self, &NSViewComponentPeer::redirectMagnify,      ev); });

  1928. 

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

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

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

  1932. 

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

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

  1935. 

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

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

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

  1939. 

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

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

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

  1943. 

  1944.         addMethod (@selector (draggingEntered:),                draggingUpdated);

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

  1946. 

  1947.         addMethod (@selector (draggingEnded:),                  draggingExited);

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

  1949. 

  1950.         addMethod (@selector (acceptsFirstMouse:), [] (id, SEL, NSEvent*) { return YES; });

  1951. 

  1952.         addMethod (@selector (windowWillMiniaturize:), [] (id self, SEL, NSNotification*)

  1953.         {

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

  1955.             {

  1956.                 if (p->isAlwaysOnTop)

  1957.                 {

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

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

  1960.                     p->setAlwaysOnTop (false);

  1961.                     p->wasAlwaysOnTop = true;

  1962.                 }

  1963.             }

  1964.         });

  1965. 

  1966.         addMethod (@selector (windowDidDeminiaturize:), [] (id self, SEL, NSNotification*)

  1967.         {

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

  1969.             {

  1970.                 if (p->wasAlwaysOnTop)

  1971.                     p->setAlwaysOnTop (true);

  1972. 

  1973.                 p->redirectMovedOrResized();

  1974.             }

  1975.         });

  1976. 

  1977.         addMethod (@selector (wantsDefaultClipping), [] (id, SEL) { return YES; }); // (this is the default, but may want to customise it in future)

  1978. 

  1979.         addMethod (@selector (worksWhenModal), [] (id self, SEL)

  1980.         {

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

  1982.                 return p->worksWhenModal();

  1983. 

  1984.             return false;

  1985.         });

  1986. 

  1987.         addMethod (@selector (viewWillDraw), [] (id self, SEL)

  1988.         {

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

  1990.             // to be the entire frame.

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

  1992.             {

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

  1994.                 layer.contentsFormat = kCAContentsFormatRGBA8Uint;

  1995.             }

  1996. 

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

  1998.         });

  1999. 

  2000.         addMethod (@selector (keyDown:), [] (id self, SEL, NSEvent* ev)

  2001.         {

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

  2003.             {

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

  2005.                 owner->textWasInserted = false;

  2006. 

  2007.                 if (target != nullptr)

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

  2009.                 else

  2010.                     owner->stringBeingComposed.clear();

  2011. 

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

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

  2014.             }

  2015.         });

  2016. 

  2017.         addMethod (@selector (keyUp:), [] (id self, SEL, NSEvent* ev)

  2018.         {

  2019.             auto* owner = getOwner (self);

  2020. 

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

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

  2023.         });

  2024. 

  2025.         addMethod (@selector (insertText:), [] (id self, SEL, id aString)

  2026.         {

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

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

  2029.             {

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

  2031. 

  2032.                 if ([newText length] > 0)

  2033.                 {

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

  2035.                     {

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

  2037.                         owner->textWasInserted = true;

  2038.                     }

  2039.                 }

  2040. 

  2041.                 owner->stringBeingComposed.clear();

  2042.             }

  2043.         });

  2044. 

  2045.         addMethod (@selector (doCommandBySelector:), [] (id, SEL, SEL) {});

  2046. 

  2047.         addMethod (@selector (setMarkedText:selectedRange:), [] (id self, SEL, id aString, NSRange)

  2048.         {

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

  2050.             {

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

  2052.                                                              ? [aString string] : aString);

  2053. 

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

  2055.                 {

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

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

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

  2059.                     owner->textWasInserted = true;

  2060.                 }

  2061.             }

  2062.         });

  2063. 

  2064.         addMethod (@selector (unmarkText), [] (id self, SEL)

  2065.         {

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

  2067.             {

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

  2069.                 {

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

  2071.                     {

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

  2073.                         owner->textWasInserted = true;

  2074.                     }

  2075. 

  2076.                     owner->stringBeingComposed.clear();

  2077.                 }

  2078.             }

  2079.         });

  2080. 

  2081.         addMethod (@selector (hasMarkedText), [] (id self, SEL)

  2082.         {

  2083.             auto* owner = getOwner (self);

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

  2085.         });

  2086. 

  2087.         addMethod (@selector (conversationIdentifier), [] (id self, SEL)

  2088.         {

  2089.             return (long) (pointer_sized_int) self;

  2090.         });

  2091. 

  2092.         addMethod (@selector (attributedSubstringFromRange:), [] (id self, SEL, NSRange theRange) -> NSAttributedString*

  2093.         {

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

  2095.             {

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

  2097.                 {

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

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

  2100. 

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

  2102.                 }

  2103.             }

  2104. 

  2105.             return nil;

  2106.         });

  2107. 

  2108.         addMethod (@selector (markedRange), [] (id self, SEL)

  2109.         {

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

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

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

  2113. 

  2114.             return NSMakeRange (NSNotFound, 0);

  2115.         });

  2116. 

  2117.         addMethod (@selector (selectedRange), [] (id self, SEL)

  2118.         {

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

  2120.             {

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

  2122.                 {

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

  2124. 

  2125.                     if (! highlight.isEmpty())

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

  2127.                                             (NSUInteger) highlight.getLength());

  2128.                 }

  2129.             }

  2130. 

  2131.             return NSMakeRange (NSNotFound, 0);

  2132.         });

  2133. 

  2134.         addMethod (@selector (firstRectForCharacterRange:), [] (id self, SEL, NSRange)

  2135.         {

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

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

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

  2139. 

  2140.             return NSZeroRect;

  2141.         });

  2142. 

  2143.         addMethod (@selector (characterIndexForPoint:), [] (id, SEL, NSPoint) { return NSNotFound; });

  2144. 

  2145.         addMethod (@selector (validAttributesForMarkedText), [] (id, SEL) { return [NSArray array]; });

  2146. 

  2147.         addMethod (@selector (acceptsFirstResponder), [] (id self, SEL)

  2148.         {

  2149.             auto* owner = getOwner (self);

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

  2151.         });

  2152. 

  2153.         addMethod (@selector (prepareForDragOperation:), [] (id, SEL, id<NSDraggingInfo>) { return YES; });

  2154. 

  2155.         addMethod (@selector (performDragOperation:), [] (id self, SEL, id<NSDraggingInfo> sender)

  2156.         {

  2157.             auto* owner = getOwner (self);

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

  2159.         });

  2160. 

  2161.         addMethod (@selector (concludeDragOperation:), [] (id, SEL, id<NSDraggingInfo>) {});

  2162. 

  2163.         addMethod (@selector (isAccessibilityElement), [] (id, SEL) { return NO; });

  2164. 

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

  2166. 

  2167.         addMethod (@selector (accessibilityHitTest:), [] (id self, SEL, NSPoint point)

  2168.         {

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

  2170.         });

  2171. 

  2172.         addMethod (@selector (accessibilityFocusedUIElement), [] (id self, SEL)

  2173.         {

  2174.             return [getAccessibleChild (self) accessibilityFocusedUIElement];

  2175.         });

  2176. 

  2177.         // deprecated methods required for backwards compatibility

  2178.         addMethod (@selector (accessibilityIsIgnored), [] (id, SEL) { return YES; });

  2179. 

  2180.         addMethod (@selector (accessibilityAttributeValue:), [] (id self, SEL, NSString* attribute) -> id

  2181.         {

  2182.             if ([attribute isEqualToString: NSAccessibilityChildrenAttribute])

  2183.                 return getAccessibilityChildren (self, {});

  2184. 

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

  2186.         });

  2187. 

  2188.         addMethod (@selector (isFlipped), [] (id, SEL) { return true; });

  2189. 

  2190.         addMethod (@selector (performKeyEquivalent:), [] (id self, SEL s, NSEvent* event)

  2191.         {

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

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

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

  2195.             if (tryPassingKeyEventToPeer (event))

  2196.                 return YES;

  2197. 

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

  2199.         });

  2200. 

  2201.         addProtocol (@protocol (NSTextInput));

  2202. 

  2203.         registerClass();

  2204.     }

  2205. 

  2206. private:

  2207.     static void updateTrackingAreas (id self, SEL)

  2208.     {

  2209.         sendSuperclassMessage<void> (self, @selector (updateTrackingAreas));

  2210. 

  2211.         resetTrackingArea (static_cast<NSView*> (self));

  2212.     }

  2213. 

  2214.     static bool tryPassingKeyEventToPeer (NSEvent* e)

  2215.     {

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

  2217.             return false;

  2218. 

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

  2220.         {

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

  2222.             {

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

  2224.                                                       : peer->redirectKeyUp (e);

  2225.             }

  2226.         }

  2227. 

  2228.         return false;

  2229.     }

  2230. 

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

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

  2233.     {

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

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

  2236.     }

  2237. 

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

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

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

  2241.     static void draggingExited (id self, SEL, id<NSDraggingInfo> sender) { callOnOwner (self, &NSViewComponentPeer::sendDragCallback, &NSViewComponentPeer::handleDragExit, sender); }

  2242. 

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

  2244.     {

  2245.         if (JUCEApplicationBase::isStandaloneApp())

  2246.         {

  2247.             asyncMouseDown (self, s, ev);

  2248.         }

  2249.         else

  2250.         {

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

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

  2253.             // the event asynchronously..

  2254.             [self performSelectorOnMainThread: NSViewComponentPeer::asyncMouseDownSelector

  2255.                                    withObject: ev

  2256.                                 waitUntilDone: NO];

  2257.         }

  2258.     }

  2259. 

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

  2261.     {

  2262.         if (JUCEApplicationBase::isStandaloneApp())

  2263.         {

  2264.             asyncMouseUp (self, s, ev);

  2265.         }

  2266.         else

  2267.         {

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

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

  2270.             // the event asynchronously..

  2271.             [self performSelectorOnMainThread: NSViewComponentPeer::asyncMouseUpSelector

  2272.                                    withObject: ev

  2273.                                 waitUntilDone: NO];

  2274.         }

  2275.     }

  2276. 

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

  2278.     {

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

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

  2281.                 return NSDragOperationGeneric;

  2282. 

  2283.         return NSDragOperationNone;

  2284.     }

  2285. 

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

  2287.     {

  2288.         return NSAccessibilityUnignoredChildrenForOnlyChild (getAccessibleChild (self));

  2289.     }

  2290. };

  2291. 

  2292. //==============================================================================

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

  2294. {

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

  2296.     {

  2297.         addMethod (@selector (canBecomeKeyWindow), [] (id self, SEL)

  2298.         {

  2299.             auto* owner = getOwner (self);

  2300. 

  2301.             return owner != nullptr

  2302.                    && owner->canBecomeKeyWindow()

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

  2304.         });

  2305. 

  2306.         addMethod (@selector (canBecomeMainWindow), [] (id self, SEL)

  2307.         {

  2308.             auto* owner = getOwner (self);

  2309. 

  2310.             return owner != nullptr

  2311.                    && owner->canBecomeMainWindow()

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

  2313.         });

  2314. 

  2315.         addMethod (@selector (becomeKeyWindow), [] (id self, SEL)

  2316.         {

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

  2318. 

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

  2320.             {

  2321.                 if (owner->canBecomeKeyWindow())

  2322.                 {

  2323.                     owner->becomeKeyWindow();

  2324.                     return;

  2325.                 }

  2326. 

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

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

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

  2330.             }

  2331.         });

  2332. 

  2333.         addMethod (@selector (resignKeyWindow), [] (id self, SEL)

  2334.         {

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

  2336. 

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

  2338.                 owner->resignKeyWindow();

  2339.         });

  2340. 

  2341.         addMethod (@selector (windowShouldClose:), [] (id self, SEL, id /*window*/)

  2342.         {

  2343.             auto* owner = getOwner (self);

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

  2345.         });

  2346. 

  2347.         addMethod (@selector (constrainFrameRect:toScreen:), [] (id self, SEL, NSRect frameRect, NSScreen* screen)

  2348.         {

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

  2350.             {

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

  2352.                                                                               frameRect, screen);

  2353. 

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

  2355.             }

  2356. 

  2357.             return frameRect;

  2358.         });

  2359. 

  2360.         addMethod (@selector (windowWillResize:toSize:), [] (id self, SEL, NSWindow*, NSSize proposedFrameSize)

  2361.         {

  2362.             auto* owner = getOwner (self);

  2363. 

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

  2365.                 return proposedFrameSize;

  2366. 

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

  2368.             frameRect.size = proposedFrameSize;

  2369. 

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

  2371. 

  2372.             owner->dismissModals();

  2373. 

  2374.             return frameRect.size;

  2375.         });

  2376. 

  2377.         addMethod (@selector (windowDidExitFullScreen:), [] (id self, SEL, NSNotification*)

  2378.         {

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

  2380.                 owner->resetWindowPresentation();

  2381.         });

  2382. 

  2383.         addMethod (@selector (windowWillEnterFullScreen:), [] (id self, SEL, NSNotification*)

  2384.         {

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

  2386.                 return;

  2387. 

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

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

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

  2391.         });

  2392. 

  2393.         addMethod (@selector (windowWillExitFullScreen:), [] (id self, SEL, NSNotification*)

  2394.         {

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

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

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

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

  2399.         });

  2400. 

  2401.         addMethod (@selector (windowWillStartLiveResize:), [] (id self, SEL, NSNotification*)

  2402.         {

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

  2404.                 owner->liveResizingStart();

  2405.         });

  2406. 

  2407.         addMethod (@selector (windowDidEndLiveResize:), [] (id self, SEL, NSNotification*)

  2408.         {

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

  2410.                 owner->liveResizingEnd();

  2411.         });

  2412. 

  2413.         addMethod (@selector (window:shouldPopUpDocumentPathMenu:), [] (id self, SEL, id /*window*/, NSMenu*)

  2414.         {

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

  2416.                 return owner->windowRepresentsFile;

  2417. 

  2418.             return false;

  2419.         });

  2420. 

  2421.         addMethod (@selector (isFlipped), [] (id, SEL) { return true; });

  2422. 

  2423.         addMethod (@selector (windowWillUseStandardFrame:defaultFrame:), [] (id self, SEL, NSWindow* window, NSRect r)

  2424.         {

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

  2426.             {

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

  2428.                 {

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

  2430.                     {

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

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

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

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

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

  2436. 

  2437.                         return flippedScreenRect (makeNSRect ([&]

  2438.                                                               {

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

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

  2441. 

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

  2443.                                                                   return constrained;

  2444.                                                               }()));

  2445.                     }

  2446.                 }

  2447.             }

  2448. 

  2449.             return r;

  2450.         });

  2451. 

  2452.         addMethod (@selector (windowShouldZoom:toFrame:), [] (id self, SEL, NSWindow*, NSRect)

  2453.         {

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

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

  2456.                     return NO;

  2457. 

  2458.             return YES;

  2459.         });

  2460. 

  2461.         addMethod (@selector (accessibilityTitle), [] (id self, SEL) { return [self title]; });

  2462. 

  2463.         addMethod (@selector (accessibilityLabel), [] (id self, SEL) { return [getAccessibleChild (self) accessibilityLabel]; });

  2464. 

  2465.         addMethod (@selector (accessibilityRole), [] (id, SEL) { return NSAccessibilityWindowRole; });

  2466. 

  2467.         addMethod (@selector (accessibilitySubrole), [] (id self, SEL) -> NSAccessibilitySubrole

  2468.         {

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

  2470.                 return [getAccessibleChild (self) accessibilitySubrole];

  2471. 

  2472.             return nil;

  2473.         });

  2474. 

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

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

  2477.         // to performKeyEquivalent.

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

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

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

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

  2482.         // that is on the desktop.

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

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

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

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

  2487.         // triggers an annoying NSBeep.

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

  2489.         addMethod (@selector (keyDown:), [] (id, SEL, NSEvent* ev)

  2490.         {

  2491.             ignoreUnused (ev);

  2492. 

  2493.            #if JUCE_DEBUG_UNHANDLED_KEYPRESSES

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

  2495.            #endif

  2496.         });

  2497. 

  2498.         addMethod (@selector (window:shouldDragDocumentWithEvent:from:withPasteboard:), [] (id self, SEL, id /*window*/, NSEvent*, NSPoint, NSPasteboard*)

  2499.         {

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

  2501.                 return owner->windowRepresentsFile;

  2502. 

  2503.             return false;

  2504.         });

  2505. 

  2506.         addMethod (@selector (toggleFullScreen:), [] (id self, SEL name, id sender)

  2507.         {

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

  2509.             {

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

  2511. 

  2512.                 if (! isFullScreen)

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

  2514. 

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

  2516. 

  2517.                 if (isFullScreen)

  2518.                 {

  2519.                     [NSApp setPresentationOptions: NSApplicationPresentationDefault];

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

  2521.                 }

  2522.             }

  2523.         });

  2524. 

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

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

  2527. 

  2528.         addProtocol (@protocol (NSWindowDelegate));

  2529. 

  2530.         registerClass();

  2531.     }

  2532. 

  2533. private:

  2534.     //==============================================================================

  2535.     static id getAccessibilityWindow (id self, SEL) { return self; }

  2536. };

  2537. 

  2538. NSView* NSViewComponentPeer::createViewInstance()

  2539. {

  2540.     static JuceNSViewClass cls;

  2541.     return cls.createInstance();

  2542. }

  2543. 

  2544. NSWindow* NSViewComponentPeer::createWindowInstance()

  2545. {

  2546.     static JuceNSWindowClass cls;

  2547.     return cls.createInstance();

  2548. }

  2549. 

  2550. 

  2551. //==============================================================================

  2552. ComponentPeer* NSViewComponentPeer::currentlyFocusedPeer = nullptr;

  2553. Array<int> NSViewComponentPeer::keysCurrentlyDown;

  2554. 

  2555. //==============================================================================

  2556. bool KeyPress::isKeyCurrentlyDown (int keyCode)

  2557. {

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

  2559.         return true;

  2560. 

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

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

  2563.         return true;

  2564. 

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

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

  2567.         return true;

  2568. 

  2569.     return false;

  2570. }

  2571. 

  2572. //==============================================================================

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

  2574. {

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

  2576.     {

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

  2578.         return true;

  2579.     }

  2580. 

  2581.     return false;

  2582. }

  2583. 

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

  2585. {

  2586.     return false;

  2587. }

  2588. 

  2589. //==============================================================================

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

  2591. {

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

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

  2594. 

  2595.     if (peer->hasNativeTitleBar())

  2596.     {

  2597.         if (shouldBeEnabled && ! allowMenusAndBars)

  2598.             [NSApp setPresentationOptions: NSApplicationPresentationHideDock | NSApplicationPresentationHideMenuBar];

  2599.         else if (! shouldBeEnabled)

  2600.             [NSApp setPresentationOptions: NSApplicationPresentationDefault];

  2601. 

  2602.         peer->setFullScreen (true);

  2603.     }

  2604.     else

  2605.     {

  2606.         if (shouldBeEnabled)

  2607.         {

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

  2609.                                                               : (NSApplicationPresentationHideDock | NSApplicationPresentationHideMenuBar))];

  2610. 

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

  2612.             peer->becomeKeyWindow();

  2613.         }

  2614.         else

  2615.         {

  2616.             peer->resetWindowPresentation();

  2617.         }

  2618.     }

  2619. }

  2620. 

  2621. void Desktop::allowedOrientationsChanged() {}

  2622. 

  2623. //==============================================================================

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

  2625. {

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

  2627. }

  2628. 

  2629. //==============================================================================

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

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

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

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

  2634. const int KeyPress::leftKey         = NSLeftArrowFunctionKey;

  2635. const int KeyPress::rightKey        = NSRightArrowFunctionKey;

  2636. const int KeyPress::upKey           = NSUpArrowFunctionKey;

  2637. const int KeyPress::downKey         = NSDownArrowFunctionKey;

  2638. const int KeyPress::pageUpKey       = NSPageUpFunctionKey;

  2639. const int KeyPress::pageDownKey     = NSPageDownFunctionKey;

  2640. const int KeyPress::endKey          = NSEndFunctionKey;

  2641. const int KeyPress::homeKey         = NSHomeFunctionKey;

  2642. const int KeyPress::deleteKey       = NSDeleteFunctionKey;

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

  2644. const int KeyPress::tabKey          = 9;

  2645. const int KeyPress::F1Key           = NSF1FunctionKey;

  2646. const int KeyPress::F2Key           = NSF2FunctionKey;

  2647. const int KeyPress::F3Key           = NSF3FunctionKey;

  2648. const int KeyPress::F4Key           = NSF4FunctionKey;

  2649. const int KeyPress::F5Key           = NSF5FunctionKey;

  2650. const int KeyPress::F6Key           = NSF6FunctionKey;

  2651. const int KeyPress::F7Key           = NSF7FunctionKey;

  2652. const int KeyPress::F8Key           = NSF8FunctionKey;

  2653. const int KeyPress::F9Key           = NSF9FunctionKey;

  2654. const int KeyPress::F10Key          = NSF10FunctionKey;

  2655. const int KeyPress::F11Key          = NSF11FunctionKey;

  2656. const int KeyPress::F12Key          = NSF12FunctionKey;

  2657. const int KeyPress::F13Key          = NSF13FunctionKey;

  2658. const int KeyPress::F14Key          = NSF14FunctionKey;

  2659. const int KeyPress::F15Key          = NSF15FunctionKey;

  2660. const int KeyPress::F16Key          = NSF16FunctionKey;

  2661. const int KeyPress::F17Key          = NSF17FunctionKey;

  2662. const int KeyPress::F18Key          = NSF18FunctionKey;

  2663. const int KeyPress::F19Key          = NSF19FunctionKey;

  2664. const int KeyPress::F20Key          = NSF20FunctionKey;

  2665. const int KeyPress::F21Key          = NSF21FunctionKey;

  2666. const int KeyPress::F22Key          = NSF22FunctionKey;

  2667. const int KeyPress::F23Key          = NSF23FunctionKey;

  2668. const int KeyPress::F24Key          = NSF24FunctionKey;

  2669. const int KeyPress::F25Key          = NSF25FunctionKey;

  2670. const int KeyPress::F26Key          = NSF26FunctionKey;

  2671. const int KeyPress::F27Key          = NSF27FunctionKey;

  2672. const int KeyPress::F28Key          = NSF28FunctionKey;

  2673. const int KeyPress::F29Key          = NSF29FunctionKey;

  2674. const int KeyPress::F30Key          = NSF30FunctionKey;

  2675. const int KeyPress::F31Key          = NSF31FunctionKey;

  2676. const int KeyPress::F32Key          = NSF32FunctionKey;

  2677. const int KeyPress::F33Key          = NSF33FunctionKey;

  2678. const int KeyPress::F34Key          = NSF34FunctionKey;

  2679. const int KeyPress::F35Key          = NSF35FunctionKey;

  2680. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  2703. 

  2704. } // namespace juce