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.
13829 Commits
11 Branches
1.8GB
Tree: 3387ca362c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '3387ca362c'
${ noResults }
JUCE/modules/juce_gui_basics/native/juce_NSViewComponentPeer_ma...

2997 lines
116KB
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_CGMetalLayerRenderer_mac.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.                          | NSTrackingActiveAlways

  55.                          | NSTrackingInVisibleRect;

  56. 

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

  58.                                                                                   options: options

  59.                                                                                     owner: view

  60.                                                                                  userInfo: nil] };

  61. 

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

  63. }

  64. 

  65. static constexpr int translateVirtualToAsciiKeyCode (int keyCode) noexcept

  66. {

  67.     switch (keyCode)

  68.     {

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

  70.         case 0x00: return 'A';

  71.         case 0x01: return 'S';

  72.         case 0x02: return 'D';

  73.         case 0x03: return 'F';

  74.         case 0x04: return 'H';

  75.         case 0x05: return 'G';

  76.         case 0x06: return 'Z';

  77.         case 0x07: return 'X';

  78.         case 0x08: return 'C';

  79.         case 0x09: return 'V';

  80.         case 0x0B: return 'B';

  81.         case 0x0C: return 'Q';

  82.         case 0x0D: return 'W';

  83.         case 0x0E: return 'E';

  84.         case 0x0F: return 'R';

  85.         case 0x10: return 'Y';

  86.         case 0x11: return 'T';

  87.         case 0x12: return '1';

  88.         case 0x13: return '2';

  89.         case 0x14: return '3';

  90.         case 0x15: return '4';

  91.         case 0x16: return '6';

  92.         case 0x17: return '5';

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

  94.         case 0x19: return '9';

  95.         case 0x1A: return '7';

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

  97.         case 0x1C: return '8';

  98.         case 0x1D: return '0';

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

  100.         case 0x1F: return 'O';

  101.         case 0x20: return 'U';

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

  103.         case 0x22: return 'I';

  104.         case 0x23: return 'P';

  105.         case 0x25: return 'L';

  106.         case 0x26: return 'J';

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

  108.         case 0x28: return 'K';

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

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

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

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

  113.         case 0x2D: return 'N';

  114.         case 0x2E: return 'M';

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

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

  117. 

  118.         default:   return keyCode;

  119.     }

  120. }

  121. 

  122. constexpr int extendedKeyModifier = 0x30000;

  123. 

  124. //==============================================================================

  125. class JuceCALayerDelegate : public ObjCClass<NSObject<CALayerDelegate>>

  126. {

  127. public:

  128.     struct Callback

  129.     {

  130.         virtual ~Callback() = default;

  131.         virtual void displayLayer (CALayer*) = 0;

  132.     };

  133. 

  134.     static NSObject<CALayerDelegate>* construct (Callback* owner)

  135.     {

  136.         static JuceCALayerDelegate cls;

  137.         auto* result = cls.createInstance();

  138.         setOwner (result, owner);

  139.         return result;

  140.     }

  141. 

  142. private:

  143.     JuceCALayerDelegate()

  144.         : ObjCClass ("JuceCALayerDelegate_")

  145.     {

  146.         addIvar<Callback*> ("owner");

  147. 

  148.         addMethod (@selector (displayLayer:), [] (id self, SEL, CALayer* layer)

  149.         {

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

  151.                 owner->displayLayer (layer);

  152.         });

  153. 

  154.         addProtocol (@protocol (CALayerDelegate));

  155. 

  156.         registerClass();

  157.     }

  158. 

  159.     static Callback* getOwner (id self)

  160.     {

  161.         return getIvar<Callback*> (self, "owner");

  162.     }

  163. 

  164.     static void setOwner (id self, Callback* newOwner)

  165.     {

  166.         object_setInstanceVariable (self, "owner", newOwner);

  167.     }

  168. };

  169. 

  170. //==============================================================================

  171. class NSViewComponentPeer  : public ComponentPeer,

  172.                              private JuceCALayerDelegate::Callback

  173. {

  174. public:

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

  176.         : ComponentPeer (comp, windowStyleFlags),

  177.           safeComponent (&comp),

  178.           isSharedWindow (viewToAttachTo != nil),

  179.           lastRepaintTime (Time::getMillisecondCounter())

  180.     {

  181.         appFocusChangeCallback = appFocusChanged;

  182.         isEventBlockedByModalComps = checkEventBlockedByModalComps;

  183. 

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

  185. 

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

  187.         setOwner (view, this);

  188. 

  189.         [view registerForDraggedTypes: getSupportedDragTypes()];

  190. 

  191.         resetTrackingArea (view);

  192. 

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

  194. 

  195.         [view setPostsFrameChangedNotifications: YES];

  196. 

  197.       #if USE_COREGRAPHICS_RENDERING

  198.         // Creating a metal renderer may fail on some systems.

  199.         // We need to try creating the renderer before first creating a backing layer

  200.         // so that we know whether to use a metal layer or the system default layer

  201.         // (setWantsLayer: YES will call through to makeBackingLayer, where we check

  202.         // whether metalRenderer is non-null).

  203.         // The system overwrites the layer delegate set during makeBackingLayer,

  204.         // so that must be set separately, after the layer has been created and

  205.         // configured.

  206.        #if JUCE_COREGRAPHICS_RENDER_WITH_MULTIPLE_PAINT_CALLS

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

  208.         {

  209.             metalRenderer = CoreGraphicsMetalLayerRenderer::create();

  210.             layerDelegate.reset (JuceCALayerDelegate::construct (this));

  211.         }

  212.        #endif

  213. 

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

  215.         {

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

  217.             {

  218.                 [view setWantsLayer: YES];

  219.                 [view setLayerContentsRedrawPolicy: NSViewLayerContentsRedrawDuringViewResize];

  220.                 [view layer].drawsAsynchronously = YES;

  221.             }

  222.         }

  223. 

  224.        #if JUCE_COREGRAPHICS_RENDER_WITH_MULTIPLE_PAINT_CALLS

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

  226.             if (metalRenderer != nullptr)

  227.                 view.layer.delegate = layerDelegate.get();

  228.        #endif

  229.       #endif

  230. 

  231.         if (isSharedWindow)

  232.         {

  233.             window = [viewToAttachTo window];

  234.             [viewToAttachTo addSubview: view];

  235.         }

  236.         else

  237.         {

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

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

  240.             r = flippedScreenRect (r);

  241. 

  242.             window = [createWindowInstance() initWithContentRect: r

  243.                                                        styleMask: getNSWindowStyleMask (windowStyleFlags)

  244.                                                          backing: NSBackingStoreBuffered

  245.                                                            defer: YES];

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

  247.             setOwner (window, this);

  248. 

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

  250.                 [window setAccessibilityElement: YES];

  251. 

  252.             [window orderOut: nil];

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

  254. 

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

  256. 

  257.             if (! [window isOpaque])

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

  259. 

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

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

  262. 

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

  264. 

  265.             if (component.isAlwaysOnTop())

  266.                 setAlwaysOnTop (true);

  267. 

  268.             [window setContentView: view];

  269. 

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

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

  272.             [window setReleasedWhenClosed: YES];

  273.             [window retain];

  274. 

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

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

  277. 

  278.             setCollectionBehaviour (false);

  279. 

  280.             [window setRestorable: NO];

  281. 

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

  283.                 [window setTabbingMode: NSWindowTabbingModeDisallowed];

  284. 

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

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

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

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

  289.         }

  290. 

  291.         auto alpha = component.getAlpha();

  292. 

  293.         if (alpha < 1.0f)

  294.             setAlpha (alpha);

  295. 

  296.         setTitle (component.getName());

  297. 

  298.         getNativeRealtimeModifiers = []

  299.         {

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

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

  302. 

  303.             return ModifierKeys::currentModifiers;

  304.         };

  305.     }

  306. 

  307.     ~NSViewComponentPeer() override

  308.     {

  309.         scopedObservers.clear();

  310. 

  311.         setOwner (view, nullptr);

  312. 

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

  314.         {

  315.             redirectWillMoveToWindow (nullptr);

  316.             [view removeFromSuperview];

  317.         }

  318. 

  319.         if (! isSharedWindow)

  320.         {

  321.             setOwner (window, nullptr);

  322.             [window setContentView: nil];

  323.             [window close];

  324.             [window release];

  325.         }

  326. 

  327.         [view release];

  328.     }

  329. 

  330.     //==============================================================================

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

  332. 

  333.     void setVisible (bool shouldBeVisible) override

  334.     {

  335.         if (isSharedWindow)

  336.         {

  337.             if (shouldBeVisible)

  338.                 [view setHidden: false];

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

  340.                 [view setHidden: true];

  341.         }

  342.         else

  343.         {

  344.             if (shouldBeVisible)

  345.             {

  346.                 ++insideToFrontCall;

  347.                 [window orderFront: nil];

  348.                 --insideToFrontCall;

  349.                 handleBroughtToFront();

  350.             }

  351.             else

  352.             {

  353.                 [window orderOut: nil];

  354.             }

  355.         }

  356.     }

  357. 

  358.     void setTitle (const String& title) override

  359.     {

  360.         JUCE_AUTORELEASEPOOL

  361.         {

  362.             if (! isSharedWindow)

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

  364.         }

  365.     }

  366. 

  367.     bool setDocumentEditedStatus (bool edited) override

  368.     {

  369.         if (! hasNativeTitleBar())

  370.             return false;

  371. 

  372.         [window setDocumentEdited: edited];

  373.         return true;

  374.     }

  375. 

  376.     void setRepresentedFile (const File& file) override

  377.     {

  378.         if (! isSharedWindow)

  379.         {

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

  381.                                                                 ? file.getFullPathName()

  382.                                                                 : String())];

  383. 

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

  385.         }

  386.     }

  387. 

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

  389.     {

  390.         auto r = makeNSRect (newBounds);

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

  392. 

  393.         if (isSharedWindow)

  394.         {

  395.             [view setFrame: r];

  396.         }

  397.         else

  398.         {

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

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

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

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

  403. 

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

  405.                      display: isPre10_11];

  406.         }

  407. 

  408.         if (! CGSizeEqualToSize (oldViewSize, r.size))

  409.             [view setNeedsDisplay: true];

  410.     }

  411. 

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

  413.     {

  414.         auto r = [view frame];

  415.         NSWindow* viewWindow = [view window];

  416. 

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

  418.         {

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

  420.             r = [viewWindow convertRectToScreen: r];

  421. 

  422.             r = flippedScreenRect (r);

  423.         }

  424. 

  425.         return convertToRectInt (r);

  426.     }

  427. 

  428.     Rectangle<int> getBounds() const override

  429.     {

  430.         return getBounds (! isSharedWindow);

  431.     }

  432. 

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

  434.     {

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

  436.     }

  437. 

  438.     using ComponentPeer::localToGlobal;

  439. 

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

  441.     {

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

  443.     }

  444. 

  445.     using ComponentPeer::globalToLocal;

  446. 

  447.     void setAlpha (float newAlpha) override

  448.     {

  449.         if (isSharedWindow)

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

  451.         else

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

  453.     }

  454. 

  455.     void setMinimised (bool shouldBeMinimised) override

  456.     {

  457.         if (! isSharedWindow)

  458.         {

  459.             if (shouldBeMinimised)

  460.                 [window miniaturize: nil];

  461.             else

  462.                 [window deminiaturize: nil];

  463.         }

  464.     }

  465. 

  466.     bool isMinimised() const override

  467.     {

  468.         return [window isMiniaturized];

  469.     }

  470. 

  471.     NSWindowCollectionBehavior getCollectionBehavior (bool forceFullScreen) const

  472.     {

  473.         if (forceFullScreen)

  474.             return NSWindowCollectionBehaviorFullScreenPrimary;

  475. 

  476.         // Some SDK versions don't define NSWindowCollectionBehaviorFullScreenAuxiliary

  477.         constexpr auto fullScreenAux = (NSUInteger) (1 << 8);

  478. 

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

  480.              ? NSWindowCollectionBehaviorFullScreenPrimary

  481.              : fullScreenAux;

  482.     }

  483. 

  484.     void setCollectionBehaviour (bool forceFullScreen) const

  485.     {

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

  487.     }

  488. 

  489.     void setFullScreen (bool shouldBeFullScreen) override

  490.     {

  491.         if (isSharedWindow)

  492.             return;

  493. 

  494.         if (shouldBeFullScreen)

  495.             setCollectionBehaviour (true);

  496. 

  497.         if (isMinimised())

  498.             setMinimised (false);

  499. 

  500.         if (shouldBeFullScreen != isFullScreen())

  501.             [window toggleFullScreen: nil];

  502.     }

  503. 

  504.     bool isFullScreen() const override

  505.     {

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

  507.     }

  508. 

  509.     bool isKioskMode() const override

  510.     {

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

  512.     }

  513. 

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

  515.     {

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

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

  518. 

  519.         return true;

  520.     }

  521. 

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

  523.     {

  524.         NSRect viewFrame = [view frame];

  525. 

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

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

  528.             return false;

  529. 

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

  531.         {

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

  533.             {

  534.                 NSRect windowFrame = [viewWindow frame];

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

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

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

  538. 

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

  540.                     return false;

  541. 

  542.             }

  543.         }

  544. 

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

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

  547. 

  548.         return trueIfInAChildWindow ? (v != nil)

  549.                                     : (v == view);

  550.     }

  551. 

  552.     OptionalBorderSize getFrameSizeIfPresent() const override

  553.     {

  554.         if (! isSharedWindow)

  555.         {

  556.             BorderSize<int> b;

  557. 

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

  559.             NSRect w = [window frame];

  560. 

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

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

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

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

  565. 

  566.             return OptionalBorderSize { b };

  567.         }

  568. 

  569.         return {};

  570.     }

  571. 

  572.     BorderSize<int> getFrameSize() const override

  573.     {

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

  575.             return *frameSize;

  576. 

  577.         return {};

  578.     }

  579. 

  580.     bool hasNativeTitleBar() const

  581.     {

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

  583.     }

  584. 

  585.     bool setAlwaysOnTop (bool alwaysOnTop) override

  586.     {

  587.         if (! isSharedWindow)

  588.         {

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

  590.                                                                                         : NSFloatingWindowLevel)

  591.                                           : NSNormalWindowLevel];

  592. 

  593.             isAlwaysOnTop = alwaysOnTop;

  594.         }

  595. 

  596.         return true;

  597.     }

  598. 

  599.     void toFront (bool makeActiveWindow) override

  600.     {

  601.         if (isSharedWindow)

  602.         {

  603.             NSView* superview = [view superview];

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

  605. 

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

  607. 

  608.             if (! isFrontmost)

  609.             {

  610.                 [view retain];

  611.                 [subviews removeObject: view];

  612.                 [subviews addObject: view];

  613. 

  614.                 [superview setSubviews: subviews];

  615.                 [view release];

  616.             }

  617.         }

  618. 

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

  620.         {

  621.             ++insideToFrontCall;

  622. 

  623.             if (makeActiveWindow && ! inBecomeKeyWindow && [window canBecomeKeyWindow])

  624.                 [window makeKeyAndOrderFront: nil];

  625.             else

  626.                 [window orderFront: nil];

  627. 

  628.             if (insideToFrontCall <= 1)

  629.             {

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

  631.                 handleBroughtToFront();

  632.             }

  633. 

  634.             --insideToFrontCall;

  635.         }

  636.     }

  637. 

  638.     void toBehind (ComponentPeer* other) override

  639.     {

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

  641.         {

  642.             if (isSharedWindow)

  643.             {

  644.                 NSView* superview = [view superview];

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

  646. 

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

  648. 

  649.                 if (otherViewIndex == NSNotFound)

  650.                     return;

  651. 

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

  653. 

  654.                 if (! isBehind)

  655.                 {

  656.                     [view retain];

  657.                     [subviews removeObject: view];

  658.                     [subviews insertObject: view

  659.                                    atIndex: otherViewIndex];

  660. 

  661.                     [superview setSubviews: subviews];

  662.                     [view release];

  663.                 }

  664.             }

  665.             else if (component.isVisible())

  666.             {

  667.                 [window orderWindow: NSWindowBelow

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

  669.             }

  670.         }

  671.         else

  672.         {

  673.             jassertfalse; // wrong type of window?

  674.         }

  675.     }

  676. 

  677.     void setIcon (const Image& newIcon) override

  678.     {

  679.         if (! isSharedWindow)

  680.         {

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

  682.             if (! windowRepresentsFile)

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

  684. 

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

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

  687.         }

  688.     }

  689. 

  690.     StringArray getAvailableRenderingEngines() override

  691.     {

  692.         StringArray s ("Software Renderer");

  693. 

  694.        #if USE_COREGRAPHICS_RENDERING

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

  696.        #endif

  697. 

  698.         return s;

  699.     }

  700. 

  701.     int getCurrentRenderingEngine() const override

  702.     {

  703.         return usingCoreGraphics ? 1 : 0;

  704.     }

  705. 

  706.     void setCurrentRenderingEngine ([[maybe_unused]] int index) override

  707.     {

  708.        #if USE_COREGRAPHICS_RENDERING

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

  710.         {

  711.             usingCoreGraphics = index > 0;

  712.             [view setNeedsDisplay: true];

  713.         }

  714.        #endif

  715.     }

  716. 

  717.     void redirectMouseDown (NSEvent* ev)

  718.     {

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

  720.             Process::makeForegroundProcess();

  721. 

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

  723.         sendMouseEvent (ev);

  724.     }

  725. 

  726.     void redirectMouseUp (NSEvent* ev)

  727.     {

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

  729.         sendMouseEvent (ev);

  730.         showArrowCursorIfNeeded();

  731.     }

  732. 

  733.     void redirectMouseDrag (NSEvent* ev)

  734.     {

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

  736.         sendMouseEvent (ev);

  737.     }

  738. 

  739.     void redirectMouseMove (NSEvent* ev)

  740.     {

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

  742. 

  743.         NSPoint windowPos = [ev locationInWindow];

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

  745. 

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

  747.             sendMouseEvent (ev);

  748.         else

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

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

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

  752. 

  753.         showArrowCursorIfNeeded();

  754.     }

  755. 

  756.     void redirectMouseEnter (NSEvent* ev)

  757.     {

  758.         sendMouseEnterExit (ev);

  759.     }

  760. 

  761.     void redirectMouseExit (NSEvent* ev)

  762.     {

  763.         sendMouseEnterExit (ev);

  764.     }

  765. 

  766.     static float checkDeviceDeltaReturnValue (float v) noexcept

  767.     {

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

  769.         v *= 0.5f / 256.0f;

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

  771.     }

  772. 

  773.     void redirectMouseWheel (NSEvent* ev)

  774.     {

  775.         updateModifiers (ev);

  776. 

  777.         MouseWheelDetails wheel;

  778.         wheel.deltaX = 0;

  779.         wheel.deltaY = 0;

  780.         wheel.isReversed = false;

  781.         wheel.isSmooth = false;

  782.         wheel.isInertial = false;

  783. 

  784.         @try

  785.         {

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

  787.                 wheel.isReversed = [ev isDirectionInvertedFromDevice];

  788. 

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

  790. 

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

  792.             {

  793.                 if ([ev hasPreciseScrollingDeltas])

  794.                 {

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

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

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

  798.                     wheel.isSmooth = true;

  799.                 }

  800.             }

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

  802.             {

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

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

  805.             }

  806.         }

  807.         @catch (...)

  808.         {}

  809. 

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

  811.         {

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

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

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

  815.         }

  816. 

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

  818.     }

  819. 

  820.     void redirectMagnify (NSEvent* ev)

  821.     {

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

  823. 

  824.         if (invScale > 0.0f)

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

  826.     }

  827. 

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

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

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

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

  832. 

  833.     void redirectWillMoveToWindow (NSWindow* newWindow)

  834.     {

  835.         windowObservers.clear();

  836. 

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

  838.         {

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

  840.                 comp->setVisible (false);

  841.         }

  842.     }

  843. 

  844.     void sendMouseEvent (NSEvent* ev)

  845.     {

  846.         updateModifiers (ev);

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

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

  849.     }

  850. 

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

  852.     {

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

  854.         auto keyCode = getKeyCodeFromEvent (ev);

  855. 

  856.        #if JUCE_DEBUG_KEYCODES

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

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

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

  860.        #endif

  861. 

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

  863.         {

  864.             if (isKeyDown)

  865.             {

  866.                 bool used = false;

  867. 

  868.                 for (auto textCharacter : unicode)

  869.                 {

  870.                     switch (keyCode)

  871.                     {

  872.                         case NSLeftArrowFunctionKey:

  873.                         case NSRightArrowFunctionKey:

  874.                         case NSUpArrowFunctionKey:

  875.                         case NSDownArrowFunctionKey:

  876.                         case NSPageUpFunctionKey:

  877.                         case NSPageDownFunctionKey:

  878.                         case NSEndFunctionKey:

  879.                         case NSHomeFunctionKey:

  880.                         case NSDeleteFunctionKey:

  881.                             textCharacter = 0;

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

  883. 

  884.                         default:

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

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

  887.                                 textCharacter = 0;

  888.                             break;

  889.                     }

  890. 

  891.                     used |= handleKeyUpOrDown (true);

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

  893.                 }

  894. 

  895.                 return used;

  896.             }

  897. 

  898.             if (handleKeyUpOrDown (false))

  899.                 return true;

  900.         }

  901. 

  902.         return false;

  903.     }

  904. 

  905.     bool redirectKeyDown (NSEvent* ev)

  906.     {

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

  908.         // our event object gets lost)

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

  910. 

  911.         updateKeysDown (ev, true);

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

  913. 

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

  915.         {

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

  917.             updateKeysDown (ev, false);

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

  919.         }

  920. 

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

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

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

  924.             used = true;

  925. 

  926.         return used;

  927.     }

  928. 

  929.     bool redirectKeyUp (NSEvent* ev)

  930.     {

  931.         updateKeysDown (ev, false);

  932.         return handleKeyEvent (ev, false)

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

  934.     }

  935. 

  936.     void redirectModKeyChange (NSEvent* ev)

  937.     {

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

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

  940. 

  941.         keysCurrentlyDown.clear();

  942.         handleKeyUpOrDown (true);

  943. 

  944.         updateModifiers (ev);

  945.         handleModifierKeysChange();

  946.     }

  947. 

  948.     //==============================================================================

  949.     void drawRect (NSRect r)

  950.     {

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

  952.             return;

  953. 

  954.         auto cg = []

  955.         {

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

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

  958. 

  959.             JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wdeprecated-declarations")

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

  961.             JUCE_END_IGNORE_WARNINGS_GCC_LIKE

  962.         }();

  963. 

  964.         drawRectWithContext (cg, r);

  965.     }

  966. 

  967.     void drawRectWithContext (CGContextRef cg, NSRect r)

  968.     {

  969.         if (! component.isOpaque())

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

  971. 

  972.         float displayScale = 1.0f;

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

  974. 

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

  976.             displayScale = (float) screen.backingScaleFactor;

  977. 

  978.         auto invalidateTransparentWindowShadow = [this]

  979.         {

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

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

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

  983.                 [window invalidateShadow];

  984.         };

  985. 

  986.        #if USE_COREGRAPHICS_RENDERING && JUCE_COREGRAPHICS_RENDER_WITH_MULTIPLE_PAINT_CALLS

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

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

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

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

  991.         // to avoid CoreGraphics consolidating disparate rects.

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

  993.         {

  994.             const NSRect* rects = nullptr;

  995.             NSInteger numRects = 0;

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

  997. 

  998.             if (numRects > 1)

  999.             {

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

  1001.                 {

  1002.                     NSRect rect = rects[i];

  1003.                     CGContextSaveGState (cg);

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

  1005.                     renderRect (cg, rect, displayScale);

  1006.                     CGContextRestoreGState (cg);

  1007.                 }

  1008. 

  1009.                 invalidateTransparentWindowShadow();

  1010.                 return;

  1011.             }

  1012.         }

  1013.        #endif

  1014. 

  1015.         renderRect (cg, r, displayScale);

  1016.         invalidateTransparentWindowShadow();

  1017.     }

  1018. 

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

  1020.     {

  1021.        #if USE_COREGRAPHICS_RENDERING

  1022.         if (usingCoreGraphics)

  1023.         {

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

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

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

  1027.             handlePaint (context);

  1028.         }

  1029.         else

  1030.        #endif

  1031.         {

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

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

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

  1035. 

  1036.             RectangleList<int> clip;

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

  1038. 

  1039.             if (! clip.isEmpty())

  1040.             {

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

  1042.                             roundToInt (clipW * displayScale),

  1043.                             roundToInt (clipH * displayScale),

  1044.                             ! component.isOpaque());

  1045. 

  1046.                 {

  1047.                     auto intScale = roundToInt (displayScale);

  1048. 

  1049.                     if (intScale != 1)

  1050.                         clip.scaleAll (intScale);

  1051. 

  1052.                     auto context = component.getLookAndFeel()

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

  1054. 

  1055.                     if (intScale != 1)

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

  1057. 

  1058.                     handlePaint (*context);

  1059.                 }

  1060. 

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

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

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

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

  1065.                 CGImageRelease (image);

  1066.             }

  1067.         }

  1068.     }

  1069. 

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

  1071.     {

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

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

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

  1075.         // As a workaround for this, we use a RectangleList to do our own coalescing of regions before

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

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

  1078.     }

  1079. 

  1080.     static bool shouldThrottleRepaint()

  1081.     {

  1082.         return areAnyWindowsInLiveResize();

  1083.     }

  1084. 

  1085.     void onVBlank()

  1086.     {

  1087.         vBlankListeners.call ([] (auto& l) { l.onVBlank(); });

  1088.         setNeedsDisplayRectangles();

  1089.     }

  1090. 

  1091.     void setNeedsDisplayRectangles()

  1092.     {

  1093.         if (deferredRepaints.isEmpty())

  1094.             return;

  1095. 

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

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

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

  1099. 

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

  1101. 

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

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

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

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

  1106.             return;

  1107. 

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

  1109.         const Rectangle currentBounds { (float) frameSize.width, (float) frameSize.height };

  1110. 

  1111.         for (auto& i : deferredRepaints)

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

  1113. 

  1114.         lastRepaintTime = Time::getMillisecondCounter();

  1115. 

  1116.        #if JUCE_COREGRAPHICS_RENDER_WITH_MULTIPLE_PAINT_CALLS

  1117.         if (metalRenderer == nullptr)

  1118.        #endif

  1119.             deferredRepaints.clear();

  1120.     }

  1121. 

  1122.     void performAnyPendingRepaintsNow() override

  1123.     {

  1124.         [view displayIfNeeded];

  1125.     }

  1126. 

  1127.     static bool areAnyWindowsInLiveResize() noexcept

  1128.     {

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

  1130.             if ([w inLiveResize])

  1131.                 return true;

  1132. 

  1133.         return false;

  1134.     }

  1135. 

  1136.     //==============================================================================

  1137.     bool isBlockedByModalComponent()

  1138.     {

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

  1140.         {

  1141.             if (insideToFrontCall == 0

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

  1143.                  && getComponent().isCurrentlyBlockedByAnotherModalComponent())

  1144.             {

  1145.                 return true;

  1146.             }

  1147.         }

  1148. 

  1149.         return false;

  1150.     }

  1151. 

  1152.     enum class KeyWindowChanged { no, yes };

  1153. 

  1154.     void sendModalInputAttemptIfBlocked (KeyWindowChanged keyChanged)

  1155.     {

  1156.         if (! isBlockedByModalComponent())

  1157.             return;

  1158. 

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

  1160.         {

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

  1162.             {

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

  1164. 

  1165.                 if (! modalPeerIsTemporary)

  1166.                     return;

  1167. 

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

  1169.                 // component that is now key.

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

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

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

  1173. 

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

  1175.                     return;

  1176. 

  1177.                 modal->inputAttemptWhenModal();

  1178.             }

  1179.         }

  1180.     }

  1181. 

  1182.     bool canBecomeKeyWindow()

  1183.     {

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

  1185.     }

  1186. 

  1187.     bool canBecomeMainWindow()

  1188.     {

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

  1190.     }

  1191. 

  1192.     bool worksWhenModal() const

  1193.     {

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

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

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

  1197.         return ! JUCEApplication::isStandaloneApp();

  1198.     }

  1199. 

  1200.     void becomeKeyWindow()

  1201.     {

  1202.         handleBroughtToFront();

  1203.         grabFocus();

  1204.     }

  1205. 

  1206.     void resignKeyWindow()

  1207.     {

  1208.         viewFocusLoss();

  1209.     }

  1210. 

  1211.     bool windowShouldClose()

  1212.     {

  1213.         if (! isValidPeer (this))

  1214.             return YES;

  1215. 

  1216.         handleUserClosingWindow();

  1217.         return NO;

  1218.     }

  1219. 

  1220.     void redirectMovedOrResized()

  1221.     {

  1222.         handleMovedOrResized();

  1223.         setNeedsDisplayRectangles();

  1224.     }

  1225. 

  1226.     void viewMovedToWindow()

  1227.     {

  1228.         if (isSharedWindow)

  1229.         {

  1230.             auto newWindow = [view window];

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

  1232. 

  1233.             window = newWindow;

  1234. 

  1235.             if (shouldSetVisible)

  1236.                 getComponent().setVisible (true);

  1237.         }

  1238. 

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

  1240.         {

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

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

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

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

  1245.         }

  1246.     }

  1247. 

  1248.     void dismissModals()

  1249.     {

  1250.         if (hasNativeTitleBar() || isSharedWindow)

  1251.             sendModalInputAttemptIfBlocked (KeyWindowChanged::no);

  1252.     }

  1253. 

  1254.     void becomeKey()

  1255.     {

  1256.         component.repaint();

  1257.     }

  1258. 

  1259.     void resignKey()

  1260.     {

  1261.         viewFocusLoss();

  1262.         sendModalInputAttemptIfBlocked (KeyWindowChanged::yes);

  1263.     }

  1264. 

  1265.     void liveResizingStart()

  1266.     {

  1267.         if (constrainer == nullptr)

  1268.             return;

  1269. 

  1270.         constrainer->resizeStart();

  1271.         isFirstLiveResize = true;

  1272. 

  1273.         setFullScreenSizeConstraints (*constrainer);

  1274.     }

  1275. 

  1276.     void liveResizingEnd()

  1277.     {

  1278.         if (constrainer != nullptr)

  1279.             constrainer->resizeEnd();

  1280.     }

  1281. 

  1282.     NSRect constrainRect (const NSRect r)

  1283.     {

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

  1285.             return r;

  1286. 

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

  1288. 

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

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

  1291. 

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

  1293. 

  1294.         const bool inLiveResize = [window inLiveResize];

  1295. 

  1296.         if (! inLiveResize || isFirstLiveResize)

  1297.         {

  1298.             isFirstLiveResize = false;

  1299. 

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

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

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

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

  1304.         }

  1305. 

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

  1307.                                   isStretchingTop, isStretchingLeft, isStretchingBottom, isStretchingRight);

  1308. 

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

  1310.     }

  1311. 

  1312.     static void showArrowCursorIfNeeded()

  1313.     {

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

  1315.         auto mouse = desktop.getMainMouseSource();

  1316. 

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

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

  1319.         {

  1320.             [[NSCursor arrowCursor] set];

  1321.         }

  1322.     }

  1323. 

  1324.     static void updateModifiers (NSEvent* e)

  1325.     {

  1326.         updateModifiers ([e modifierFlags]);

  1327.     }

  1328. 

  1329.     static void updateModifiers (const NSUInteger flags)

  1330.     {

  1331.         int m = 0;

  1332. 

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

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

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

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

  1337. 

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

  1339.     }

  1340. 

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

  1342.     {

  1343.         updateModifiers (ev);

  1344. 

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

  1346.         {

  1347.             if (isKeyDown)

  1348.                 keysCurrentlyDown.insert (keyCode);

  1349.             else

  1350.                 keysCurrentlyDown.erase (keyCode);

  1351.         }

  1352.     }

  1353. 

  1354.     static int getKeyCodeFromEvent (NSEvent* ev)

  1355.     {

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

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

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

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

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

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

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

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

  1364.         // if the shift key was not pressed

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

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

  1367. 

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

  1369.             keyCode = '\t';

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

  1371.             keyCode = '\r';

  1372.         else

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

  1374. 

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

  1376.         // keyboard control over the application.

  1377.         //

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

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

  1380.         // non-printing ranges.

  1381.         if (keyCode > 0xff

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

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

  1384.         {

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

  1386.         }

  1387. 

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

  1389.         {

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

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

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

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

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

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

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

  1397.                                               '.', KeyPress::numberPadDecimalPoint,

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

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

  1400. 

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

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

  1403.                     keyCode = numPadConversions [i + 1];

  1404.         }

  1405. 

  1406.         return keyCode;

  1407.     }

  1408. 

  1409.     static int64 getMouseTime (NSEvent* e) noexcept

  1410.     {

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

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

  1413.     }

  1414. 

  1415.     static float getMousePressure (NSEvent* e) noexcept

  1416.     {

  1417.         @try

  1418.         {

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

  1420.                 return (float) e.pressure;

  1421.         }

  1422.         @catch (NSException* e) {}

  1423.         @finally {}

  1424. 

  1425.         return 0.0f;

  1426.     }

  1427. 

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

  1429.     {

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

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

  1432.     }

  1433. 

  1434.     static int getModifierForButtonNumber (const NSInteger num)

  1435.     {

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

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

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

  1439.     }

  1440. 

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

  1442.     {

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

  1444.                                                               : NSWindowStyleMaskBorderless;

  1445. 

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

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

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

  1449.         return style;

  1450.     }

  1451. 

  1452.     static NSArray* getSupportedDragTypes()

  1453.     {

  1454.         const auto type = []

  1455.         {

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

  1457.                 return NSPasteboardTypeFileURL;

  1458. 

  1459.             JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wdeprecated-declarations")

  1460.             return (NSString*) kUTTypeFileURL;

  1461.             JUCE_END_IGNORE_WARNINGS_GCC_LIKE

  1462.         }();

  1463. 

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

  1465.     }

  1466. 

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

  1468.     {

  1469.         NSPasteboard* pasteboard = [sender draggingPasteboard];

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

  1471. 

  1472.         if (contentType == nil)

  1473.             return false;

  1474. 

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

  1476. 

  1477.         ComponentPeer::DragInfo dragInfo;

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

  1479. 

  1480.         if (contentType == NSPasteboardTypeString)

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

  1482.         else

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

  1484. 

  1485.         if (! dragInfo.isEmpty())

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

  1487. 

  1488.         return false;

  1489.     }

  1490. 

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

  1492.     {

  1493.         StringArray files;

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

  1495. 

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

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

  1498.         {

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

  1500. 

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

  1502.             {

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

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

  1505.                 NSEnumerator* enumerator = [tracks objectEnumerator];

  1506.                 NSDictionary* track;

  1507. 

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

  1509.                 {

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

  1511.                     {

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

  1513. 

  1514.                         if ([url isFileURL])

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

  1516.                     }

  1517.                 }

  1518.             }

  1519.         }

  1520.         else

  1521.         {

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

  1523. 

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

  1525.             {

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

  1527. 

  1528.                 if ([url isFileURL])

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

  1530.             }

  1531.         }

  1532. 

  1533.         return files;

  1534.     }

  1535. 

  1536.     //==============================================================================

  1537.     void viewFocusGain()

  1538.     {

  1539.         if (currentlyFocusedPeer != this)

  1540.         {

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

  1542.                 currentlyFocusedPeer->handleFocusLoss();

  1543. 

  1544.             currentlyFocusedPeer = this;

  1545.             handleFocusGain();

  1546.         }

  1547.     }

  1548. 

  1549.     void viewFocusLoss()

  1550.     {

  1551.         if (currentlyFocusedPeer == this)

  1552.         {

  1553.             currentlyFocusedPeer = nullptr;

  1554.             handleFocusLoss();

  1555.         }

  1556.     }

  1557. 

  1558.     bool isFocused() const override

  1559.     {

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

  1561.                     ? this == currentlyFocusedPeer

  1562.                     : [window isKeyWindow];

  1563.     }

  1564. 

  1565.     void grabFocus() override

  1566.     {

  1567.         if (window != nil)

  1568.         {

  1569.             if (! inBecomeKeyWindow && [window canBecomeKeyWindow])

  1570.                 [window makeKeyWindow];

  1571. 

  1572.             [window makeFirstResponder: view];

  1573. 

  1574.             viewFocusGain();

  1575.         }

  1576.     }

  1577. 

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

  1579. 

  1580.     void closeInputMethodContext() override

  1581.     {

  1582.         stringBeingComposed.clear();

  1583. 

  1584.         if (const auto* inputContext = [view inputContext])

  1585.             [inputContext discardMarkedText];

  1586.     }

  1587. 

  1588.     void resetWindowPresentation()

  1589.     {

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

  1591. 

  1592.         if (hasNativeTitleBar())

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

  1594. 

  1595.         [NSApp setPresentationOptions: NSApplicationPresentationDefault];

  1596.         setCollectionBehaviour (isFullScreen());

  1597.     }

  1598. 

  1599.     void setHasChangedSinceSaved (bool b) override

  1600.     {

  1601.         if (! isSharedWindow)

  1602.             [window setDocumentEdited: b];

  1603.     }

  1604. 

  1605.     bool sendEventToInputContextOrComponent (NSEvent* ev)

  1606.     {

  1607.         // In the case that an event was processed unsuccessfully in performKeyEquivalent and then

  1608.         // posted back to keyDown by the system, this check will ensure that we don't attempt to

  1609.         // process the same event a second time.

  1610.         const auto newEvent = KeyEventAttributes::make (ev);

  1611. 

  1612.         if (std::exchange (lastSeenKeyEvent, newEvent) == newEvent)

  1613.             return false;

  1614. 

  1615.         // We assume that the event will be handled by the IME.

  1616.         // Occasionally, the inputContext may be sent key events like cmd+Q, which it will turn

  1617.         // into a noop: call and forward to doCommandBySelector:.

  1618.         // In this case, the event will be extracted from keyEventBeingHandled and passed to the

  1619.         // focused component, and viewCannotHandleEvent will be set depending on whether the event

  1620.         // was handled by the component.

  1621.         // If the event was *not* handled by the component, and was also not consumed completely by

  1622.         // the IME, it's important to return the event to the system for further handling, so that

  1623.         // the main menu works as expected.

  1624.         viewCannotHandleEvent = false;

  1625.         keyEventBeingHandled.reset ([ev retain]);

  1626.         const WeakReference ref { this };

  1627.         // redirectKeyDown may delete this peer!

  1628.         const ScopeGuard scope { [&ref] { if (ref != nullptr) ref->keyEventBeingHandled = nullptr; } };

  1629. 

  1630.         const auto handled = [&]() -> bool

  1631.         {

  1632.             if (auto* target = findCurrentTextInputTarget())

  1633.                 if (const auto* inputContext = [view inputContext])

  1634.                     return [inputContext handleEvent: ev] && ! viewCannotHandleEvent;

  1635. 

  1636.             return false;

  1637.         }();

  1638. 

  1639.         if (handled)

  1640.             return true;

  1641. 

  1642.         stringBeingComposed.clear();

  1643.         return redirectKeyDown (ev);

  1644.     }

  1645. 

  1646.     //==============================================================================

  1647.     class KeyEventAttributes

  1648.     {

  1649.         auto tie() const

  1650.         {

  1651.             return std::tie (type,

  1652.                              modifierFlags,

  1653.                              timestamp,

  1654.                              windowNumber,

  1655.                              characters,

  1656.                              charactersIgnoringModifiers,

  1657.                              keyCode,

  1658.                              isRepeat);

  1659.         }

  1660. 

  1661.     public:

  1662.         static std::optional<KeyEventAttributes> make (NSEvent* event)

  1663.         {

  1664.             const auto type = [event type];

  1665. 

  1666.             if (type != NSEventTypeKeyDown && type != NSEventTypeKeyUp)

  1667.                 return {};

  1668. 

  1669.             return KeyEventAttributes

  1670.             {

  1671.                 type,

  1672.                 [event modifierFlags],

  1673.                 [event timestamp],

  1674.                 [event windowNumber],

  1675.                 nsStringToJuce ([event characters]),

  1676.                 nsStringToJuce ([event charactersIgnoringModifiers]),

  1677.                 [event keyCode],

  1678.                 static_cast<bool> ([event isARepeat])

  1679.             };

  1680.         }

  1681. 

  1682.         bool operator== (const KeyEventAttributes& other) const { return tie() == other.tie(); }

  1683.         bool operator!= (const KeyEventAttributes& other) const { return tie() != other.tie(); }

  1684. 

  1685.     private:

  1686.         KeyEventAttributes (NSEventType typeIn,

  1687.                             NSEventModifierFlags flagsIn,

  1688.                             NSTimeInterval timestampIn,

  1689.                             NSInteger windowNumberIn,

  1690.                             String charactersIn,

  1691.                             String charactersIgnoringModifiersIn,

  1692.                             unsigned short keyCodeIn,

  1693.                             bool isRepeatIn)

  1694.             : type (typeIn),

  1695.               modifierFlags (flagsIn),

  1696.               timestamp (timestampIn),

  1697.               windowNumber (windowNumberIn),

  1698.               characters (charactersIn),

  1699.               charactersIgnoringModifiers (charactersIgnoringModifiersIn),

  1700.               keyCode (keyCodeIn),

  1701.               isRepeat (isRepeatIn)

  1702.         {}

  1703. 

  1704.         NSEventType type;

  1705.         NSEventModifierFlags modifierFlags;

  1706.         NSTimeInterval timestamp;

  1707.         NSInteger windowNumber;

  1708.         String characters;

  1709.         String charactersIgnoringModifiers;

  1710.         unsigned short keyCode;

  1711.         bool isRepeat;

  1712.     };

  1713. 

  1714.     NSWindow* window = nil;

  1715.     NSView* view = nil;

  1716.     WeakReference<Component> safeComponent;

  1717.     bool isSharedWindow = false;

  1718.    #if USE_COREGRAPHICS_RENDERING

  1719.     bool usingCoreGraphics = true;

  1720.    #else

  1721.     bool usingCoreGraphics = false;

  1722.    #endif

  1723.     NSUniquePtr<NSEvent> keyEventBeingHandled;

  1724.     bool isFirstLiveResize = false, viewCannotHandleEvent = false;

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

  1726.     bool windowRepresentsFile = false;

  1727.     bool isAlwaysOnTop = false, wasAlwaysOnTop = false, inBecomeKeyWindow = false;

  1728.     String stringBeingComposed;

  1729.     int startOfMarkedTextInTextInputTarget = 0;

  1730. 

  1731.     Rectangle<float> lastSizeBeforeZoom;

  1732.     RectangleList<float> deferredRepaints;

  1733.     uint32 lastRepaintTime;

  1734. 

  1735.     std::optional<KeyEventAttributes> lastSeenKeyEvent;

  1736. 

  1737.     static inline ComponentPeer* currentlyFocusedPeer;

  1738.     static inline std::set<int> keysCurrentlyDown;

  1739.     static inline int insideToFrontCall;

  1740. 

  1741.     JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wundeclared-selector")

  1742.     static inline const auto dismissModalsSelector  = @selector (dismissModals);

  1743.     static inline const auto frameChangedSelector   = @selector (frameChanged:);

  1744.     static inline const auto asyncMouseDownSelector = @selector (asyncMouseDown:);

  1745.     static inline const auto asyncMouseUpSelector   = @selector (asyncMouseUp:);

  1746.     static inline const auto becomeKeySelector      = @selector (becomeKey:);

  1747.     static inline const auto resignKeySelector      = @selector (resignKey:);

  1748.     JUCE_END_IGNORE_WARNINGS_GCC_LIKE

  1749. 

  1750.    #if JUCE_COREGRAPHICS_RENDER_WITH_MULTIPLE_PAINT_CALLS

  1751.     std::unique_ptr<CoreGraphicsMetalLayerRenderer> metalRenderer;

  1752.     NSUniquePtr<NSObject<CALayerDelegate>> layerDelegate;

  1753.    #endif

  1754. 

  1755. private:

  1756.     JUCE_DECLARE_WEAK_REFERENCEABLE (NSViewComponentPeer)

  1757. 

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

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

  1760.     SharedResourcePointer<PerScreenDisplayLinks> sharedDisplayLinks;

  1761. 

  1762.     class AsyncRepainter : private AsyncUpdater

  1763.     {

  1764.     public:

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

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

  1767. 

  1768.         void markUpdated (const CGDirectDisplayID x)

  1769.         {

  1770.             {

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

  1772. 

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

  1774.                     backgroundDisplays.push_back (x);

  1775.             }

  1776. 

  1777.             triggerAsyncUpdate();

  1778.         }

  1779. 

  1780.     private:

  1781.         void handleAsyncUpdate() override

  1782.         {

  1783.             {

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

  1785.                 mainThreadDisplays = backgroundDisplays;

  1786.                 backgroundDisplays.clear();

  1787.             }

  1788. 

  1789.             for (const auto& display : mainThreadDisplays)

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

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

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

  1793.                             owner.onVBlank();

  1794.         }

  1795. 

  1796.         NSViewComponentPeer& owner;

  1797.         std::mutex mutex;

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

  1799.     };

  1800. 

  1801.     AsyncRepainter asyncRepainter { *this };

  1802. 

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

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

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

  1806.     */

  1807.     PerScreenDisplayLinks::Connection connection

  1808.     {

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

  1810.         {

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

  1812.         })

  1813.     };

  1814. 

  1815.     static NSView* createViewInstance();

  1816.     static NSWindow* createWindowInstance();

  1817. 

  1818.     void sendMouseEnterExit (NSEvent* ev)

  1819.     {

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

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

  1822.                 return;

  1823. 

  1824.         if ([NSEvent pressedMouseButtons] == 0)

  1825.             sendMouseEvent (ev);

  1826.     }

  1827. 

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

  1829.     {

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

  1831.     }

  1832. 

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

  1834.     {

  1835.         const NSRect* rects = nullptr;

  1836.         NSInteger numRects = 0;

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

  1838. 

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

  1840. 

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

  1842. 

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

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

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

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

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

  1848.     }

  1849. 

  1850.     static void appFocusChanged()

  1851.     {

  1852.         keysCurrentlyDown.clear();

  1853. 

  1854.         if (isValidPeer (currentlyFocusedPeer))

  1855.         {

  1856.             if (Process::isForegroundProcess())

  1857.             {

  1858.                 currentlyFocusedPeer->handleFocusGain();

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

  1860.             }

  1861.             else

  1862.             {

  1863.                 currentlyFocusedPeer->handleFocusLoss();

  1864.             }

  1865.         }

  1866.     }

  1867. 

  1868.     static bool checkEventBlockedByModalComps (NSEvent* e)

  1869.     {

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

  1871.             return false;

  1872. 

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

  1874. 

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

  1876.             return false;

  1877. 

  1878.         bool isKey = false, isInputAttempt = false;

  1879. 

  1880.         switch ([e type])

  1881.         {

  1882.             case NSEventTypeKeyDown:

  1883.             case NSEventTypeKeyUp:

  1884.                 isKey = isInputAttempt = true;

  1885.                 break;

  1886. 

  1887.             case NSEventTypeLeftMouseDown:

  1888.             case NSEventTypeRightMouseDown:

  1889.             case NSEventTypeOtherMouseDown:

  1890.                 isInputAttempt = true;

  1891.                 break;

  1892. 

  1893.             case NSEventTypeLeftMouseDragged:

  1894.             case NSEventTypeRightMouseDragged:

  1895.             case NSEventTypeLeftMouseUp:

  1896.             case NSEventTypeRightMouseUp:

  1897.             case NSEventTypeOtherMouseUp:

  1898.             case NSEventTypeOtherMouseDragged:

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

  1900.                     return false;

  1901.                 break;

  1902. 

  1903.             case NSEventTypeMouseMoved:

  1904.             case NSEventTypeMouseEntered:

  1905.             case NSEventTypeMouseExited:

  1906.             case NSEventTypeCursorUpdate:

  1907.             case NSEventTypeScrollWheel:

  1908.             case NSEventTypeTabletPoint:

  1909.             case NSEventTypeTabletProximity:

  1910.                 break;

  1911. 

  1912.             case NSEventTypeFlagsChanged:

  1913.             case NSEventTypeAppKitDefined:

  1914.             case NSEventTypeSystemDefined:

  1915.             case NSEventTypeApplicationDefined:

  1916.             case NSEventTypePeriodic:

  1917.             case NSEventTypeGesture:

  1918.             case NSEventTypeMagnify:

  1919.             case NSEventTypeSwipe:

  1920.             case NSEventTypeRotate:

  1921.             case NSEventTypeBeginGesture:

  1922.             case NSEventTypeEndGesture:

  1923.             case NSEventTypeQuickLook:

  1924.            #if JUCE_64BIT

  1925.             case NSEventTypeSmartMagnify:

  1926.             case NSEventTypePressure:

  1927.             case NSEventTypeDirectTouch:

  1928.            #endif

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

  1930.             case NSEventTypeChangeMode:

  1931.            #endif

  1932.             default:

  1933.                 return false;

  1934.         }

  1935. 

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

  1937.         {

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

  1939.             {

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

  1941.                 {

  1942.                     if (isKey)

  1943.                     {

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

  1945.                             return false;

  1946.                     }

  1947.                     else

  1948.                     {

  1949.                         if (peer->isSharedWindow

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

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

  1952.                             return false;

  1953.                     }

  1954.                 }

  1955.             }

  1956.         }

  1957. 

  1958.         if (isInputAttempt)

  1959.         {

  1960.             if (! [NSApp isActive])

  1961.                 [NSApp activateIgnoringOtherApps: YES];

  1962. 

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

  1964.                 modal->inputAttemptWhenModal();

  1965.         }

  1966. 

  1967.         return true;

  1968.     }

  1969. 

  1970.     void setFullScreenSizeConstraints (const ComponentBoundsConstrainer& c)

  1971.     {

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

  1973.         {

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

  1975.                                              0.0f);

  1976.             [window setMinFullScreenContentSize: minSize];

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

  1978.         }

  1979.     }

  1980. 

  1981.     void displayLayer ([[maybe_unused]] CALayer* layer) override

  1982.     {

  1983.        #if JUCE_COREGRAPHICS_RENDER_WITH_MULTIPLE_PAINT_CALLS

  1984.         if (metalRenderer == nullptr)

  1985.             return;

  1986. 

  1987.         const auto scale = [this]

  1988.         {

  1989.             if (auto* viewWindow = [view window])

  1990.                 return (float) viewWindow.backingScaleFactor;

  1991. 

  1992.             return 1.0f;

  1993.         }();

  1994. 

  1995.         deferredRepaints = metalRenderer->drawRectangleList (static_cast<CAMetalLayer*> (layer),

  1996.                                                              scale,

  1997.                                                              [this] (auto&&... args) { drawRectWithContext (args...); },

  1998.                                                              std::move (deferredRepaints),

  1999.                                                              [view inLiveResize]);

  2000.        #endif

  2001.     }

  2002. 

  2003.     //==============================================================================

  2004.     std::vector<ScopedNotificationCenterObserver> scopedObservers;

  2005.     std::vector<ScopedNotificationCenterObserver> windowObservers;

  2006. 

  2007.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (NSViewComponentPeer)

  2008. };

  2009. 

  2010. //==============================================================================

  2011. template <typename Base>

  2012. struct NSViewComponentPeerWrapper  : public Base

  2013. {

  2014.     explicit NSViewComponentPeerWrapper (const char* baseName)

  2015.         : Base (baseName)

  2016.     {

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

  2018.     }

  2019. 

  2020.     static NSViewComponentPeer* getOwner (id self)

  2021.     {

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

  2023.     }

  2024. 

  2025.     static id getAccessibleChild (id self)

  2026.     {

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

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

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

  2030. 

  2031.         return nil;

  2032.     }

  2033. };

  2034. 

  2035. //==============================================================================

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

  2037. {

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

  2039.     {

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

  2041.         {

  2042.             auto* owner = getOwner (self);

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

  2044.         });

  2045. 

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

  2047.         {

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

  2049. 

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

  2051.         });

  2052. 

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

  2054.         {

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

  2056.             return YES;

  2057.         });

  2058. 

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

  2060.         {

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

  2062.             return YES;

  2063.         });

  2064. 

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

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

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

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

  2069. 

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

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

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

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

  2074. 

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

  2076. 

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

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

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

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

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

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

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

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

  2085. 

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

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

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

  2089. 

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

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

  2092. 

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

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

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

  2096. 

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

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

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

  2100. 

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

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

  2103. 

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

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

  2106. 

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

  2108. 

  2109.        #if JUCE_COREGRAPHICS_RENDER_WITH_MULTIPLE_PAINT_CALLS

  2110.         addMethod (@selector (makeBackingLayer), [] (id self, SEL) -> CALayer*

  2111.         {

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

  2113.             {

  2114.                 if (owner->metalRenderer != nullptr)

  2115.                 {

  2116.                     auto* layer = [CAMetalLayer layer];

  2117. 

  2118.                     layer.device = MTLCreateSystemDefaultDevice();

  2119.                     layer.framebufferOnly = NO;

  2120.                     layer.pixelFormat = MTLPixelFormatBGRA8Unorm_sRGB;

  2121.                     layer.opaque = getOwner (self)->getComponent().isOpaque();

  2122.                     layer.needsDisplayOnBoundsChange = YES;

  2123.                     layer.drawsAsynchronously = YES;

  2124.                     layer.delegate = owner->layerDelegate.get();

  2125. 

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

  2127.                         layer.allowsNextDrawableTimeout = NO;

  2128. 

  2129.                     return layer;

  2130.                 }

  2131.             }

  2132. 

  2133.             return sendSuperclassMessage<CALayer*> (self, @selector (makeBackingLayer));

  2134.         });

  2135.        #endif

  2136. 

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

  2138.         {

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

  2140.             {

  2141.                 if (p->isAlwaysOnTop)

  2142.                 {

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

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

  2145.                     p->setAlwaysOnTop (false);

  2146.                     p->wasAlwaysOnTop = true;

  2147.                 }

  2148.             }

  2149.         });

  2150. 

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

  2152.         {

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

  2154.             {

  2155.                 if (p->wasAlwaysOnTop)

  2156.                     p->setAlwaysOnTop (true);

  2157. 

  2158.                 p->redirectMovedOrResized();

  2159.             }

  2160.         });

  2161. 

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

  2163. 

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

  2165.         {

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

  2167.                 return p->worksWhenModal();

  2168. 

  2169.             return false;

  2170.         });

  2171. 

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

  2173.         {

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

  2175.             // to be the entire frame.

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

  2177.             {

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

  2179.                 layer.contentsFormat = kCAContentsFormatRGBA8Uint;

  2180.             }

  2181. 

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

  2183.         });

  2184. 

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

  2186.         {

  2187.             const auto handled = [&]

  2188.             {

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

  2190.                     return owner->sendEventToInputContextOrComponent (ev);

  2191. 

  2192.                 return false;

  2193.             }();

  2194. 

  2195.             if (! handled)

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

  2197.         });

  2198. 

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

  2200.         {

  2201.             auto* owner = getOwner (self);

  2202. 

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

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

  2205.         });

  2206. 

  2207.         // See "The Path of Key Events" on this page:

  2208.         // https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/EventOverview/EventArchitecture/EventArchitecture.html

  2209.         // Normally, 'special' key presses (cursor keys, shortcuts, return, delete etc.) will be

  2210.         // sent down the view hierarchy to this function before any of the other keyboard handling

  2211.         // functions.

  2212.         // If any object returns YES from performKeyEquivalent, then the event is consumed.

  2213.         // If no object handles the key equivalent, then the event will be sent to the main menu.

  2214.         // If the menu is also unable to respond to the event, then the event will be sent

  2215.         // to keyDown:/keyUp: via sendEvent:, but this time the event will be sent to the first

  2216.         // responder and propagated back up the responder chain.

  2217.         // This architecture presents some issues in JUCE apps, which always expect the focused

  2218.         // Component to be sent all key presses *including* special keys.

  2219.         // There are also some slightly pathological cases that JUCE needs to support, for example

  2220.         // the situation where one of the cursor keys is bound to a main menu item. By default,

  2221.         // macOS would send the cursor event to performKeyEquivalent on each NSResponder, then send

  2222.         // the event to the main menu if no responder handled it. This would mean that the focused

  2223.         // Component would never see the event, which would break widgets like the TextEditor, which

  2224.         // expect to take precedence over menu items when they have focus.

  2225.         // Another layer of subtlety is that some IMEs require cursor key input. When long-pressing

  2226.         // the 'e' key to bring up the accent menu, the popup menu should receive cursor events

  2227.         // before the focused component.

  2228.         // To fulfil all of these requirements, we handle special keys ('key equivalents') like any

  2229.         // other key event, and send these events firstly to the NSTextInputContext (if there's an

  2230.         // active TextInputTarget), and then on to the focused Component in the case that the

  2231.         // input handler is unable to use the keypress. If the event still hasn't been used, then

  2232.         // it will be sent to the superclass's performKeyEquivalent: function, which will give the

  2233.         // OS a chance to handle events like cmd+Q, cmd+`, cmd+H etc.

  2234.         addMethod (@selector (performKeyEquivalent:), [] (id self, SEL s, NSEvent* ev) -> BOOL

  2235.         {

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

  2237.             {

  2238.                 const auto ref = owner->safeComponent;

  2239. 

  2240.                 if (owner->sendEventToInputContextOrComponent (ev))

  2241.                 {

  2242.                     if (ref == nullptr)

  2243.                         return YES;

  2244. 

  2245.                     const auto isFirstResponder = [&]

  2246.                     {

  2247.                         if (auto* v = owner->view)

  2248.                             if (auto* w = v.window)

  2249.                                 return w.firstResponder == self;

  2250. 

  2251.                         return false;

  2252.                     }();

  2253. 

  2254.                     // If the view isn't the first responder, but the view has successfully

  2255.                     // performed the key equivalent, then the key event must have been passed down

  2256.                     // the view hierarchy to this point. In that case, the view won't be sent a

  2257.                     // matching keyUp event, so we simulate it here.

  2258.                     if (! isFirstResponder)

  2259.                         owner->redirectKeyUp (ev);

  2260. 

  2261.                     return YES;

  2262.                 }

  2263.             }

  2264. 

  2265.             return sendSuperclassMessage<BOOL> (self, s, ev);

  2266.         });

  2267. 

  2268.         addMethod (@selector (insertText:replacementRange:), [] (id self, SEL, id aString, NSRange replacementRange)

  2269.         {

  2270.             // This commits multi-byte text when using an IME, or after every keypress for western keyboards

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

  2272.             {

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

  2274.                 {

  2275.                     const auto newText = nsStringToJuce ([aString isKindOfClass: [NSAttributedString class]] ? [aString string] : aString);

  2276. 

  2277.                     if (newText.isNotEmpty())

  2278.                     {

  2279.                         target->setHighlightedRegion ([&]

  2280.                         {

  2281.                             // To test this, try long-pressing 'e' to bring up the accent popup,

  2282.                             // then select one of the accented options.

  2283.                             if (replacementRange.location != NSNotFound)

  2284.                                 return nsRangeToJuce (replacementRange);

  2285. 

  2286.                             // To test this, try entering the characters 'a b <esc>' with the 2-Set

  2287.                             // Korean IME. The input client should receive three calls to setMarkedText:

  2288.                             // followed by a call to insertText:

  2289.                             // The final call to insertText should overwrite the currently-marked

  2290.                             // text, and reset the composition string.

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

  2292.                                 return Range<int>::withStartAndLength (owner->startOfMarkedTextInTextInputTarget,

  2293.                                                                        owner->stringBeingComposed.length());

  2294. 

  2295.                             return target->getHighlightedRegion();

  2296.                         }());

  2297. 

  2298.                         target->insertTextAtCaret (newText);

  2299.                         target->setTemporaryUnderlining ({});

  2300.                     }

  2301.                 }

  2302.                 else

  2303.                     jassertfalse; // The system should not attempt to insert text when there is no active TextInputTarget

  2304. 

  2305.                 owner->stringBeingComposed.clear();

  2306.             }

  2307.         });

  2308. 

  2309.         addMethod (@selector (doCommandBySelector:), [] (id self, SEL, SEL sel)

  2310.         {

  2311.             const auto handled = [&]

  2312.             {

  2313.                 // 'Special' keys, like backspace, return, tab, and escape, are converted to commands by the system.

  2314.                 // Components still expect to receive these events as key presses, so we send the currently-processed

  2315.                 // key event (if any).

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

  2317.                 {

  2318.                     owner->viewCannotHandleEvent = [&]

  2319.                     {

  2320.                         if (auto* e = owner->keyEventBeingHandled.get())

  2321.                         {

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

  2323.                                 return true;

  2324. 

  2325.                             return ! ([e type] == NSEventTypeKeyDown ? owner->redirectKeyDown (e)

  2326.                                                                      : owner->redirectKeyUp (e));

  2327.                         }

  2328. 

  2329.                         return true;

  2330.                     }();

  2331. 

  2332.                     return ! owner->viewCannotHandleEvent;

  2333.                 }

  2334. 

  2335.                 return false;

  2336.             }();

  2337. 

  2338.             if (! handled)

  2339.                 sendSuperclassMessage<void> (self, @selector (doCommandBySelector:), sel);

  2340.         });

  2341. 

  2342.         addMethod (@selector (setMarkedText:selectedRange:replacementRange:), [] (id self,

  2343.                                                                                   SEL,

  2344.                                                                                   id aString,

  2345.                                                                                   const NSRange selectedRange,

  2346.                                                                                   const NSRange replacementRange)

  2347.         {

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

  2349.             {

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

  2351.                 {

  2352.                     const auto toInsert = nsStringToJuce ([aString isKindOfClass: [NSAttributedString class]] ? [aString string] : aString);

  2353.                     const auto [initialHighlight, marked, finalHighlight] = [&]

  2354.                     {

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

  2356.                         {

  2357.                             const auto toReplace = Range<int>::withStartAndLength (owner->startOfMarkedTextInTextInputTarget,

  2358.                                                                                    owner->stringBeingComposed.length());

  2359. 

  2360.                             return replacementRange.location != NSNotFound

  2361.                                  // There's a composition underway, so replacementRange is relative to the marked text,

  2362.                                  // and selectedRange is relative to the inserted string.

  2363.                                  ? std::tuple (toReplace,

  2364.                                                owner->stringBeingComposed.replaceSection (static_cast<int> (replacementRange.location),

  2365.                                                                                           static_cast<int> (replacementRange.length),

  2366.                                                                                           toInsert),

  2367.                                                nsRangeToJuce (selectedRange) + static_cast<int> (replacementRange.location))

  2368.                                  // The replacementRange is invalid, so replace all the marked text.

  2369.                                  : std::tuple (toReplace, toInsert, nsRangeToJuce (selectedRange));

  2370.                         }

  2371. 

  2372.                         if (replacementRange.location != NSNotFound)

  2373.                             // There's no string composition in progress, so replacementRange is relative to the start

  2374.                             // of the document.

  2375.                             return std::tuple (nsRangeToJuce (replacementRange), toInsert, nsRangeToJuce (selectedRange));

  2376. 

  2377.                         return std::tuple (target->getHighlightedRegion(), toInsert, nsRangeToJuce (selectedRange));

  2378.                     }();

  2379. 

  2380.                     owner->stringBeingComposed = marked;

  2381.                     owner->startOfMarkedTextInTextInputTarget = initialHighlight.getStart();

  2382. 

  2383.                     target->setHighlightedRegion (initialHighlight);

  2384.                     target->insertTextAtCaret (marked);

  2385.                     target->setTemporaryUnderlining ({ Range<int>::withStartAndLength (initialHighlight.getStart(), marked.length()) });

  2386.                     target->setHighlightedRegion (finalHighlight + owner->startOfMarkedTextInTextInputTarget);

  2387.                 }

  2388.             }

  2389.         });

  2390. 

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

  2392.         {

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

  2394.             {

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

  2396.                 {

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

  2398.                     {

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

  2400.                         target->setTemporaryUnderlining ({});

  2401.                     }

  2402. 

  2403.                     owner->stringBeingComposed.clear();

  2404.                 }

  2405.             }

  2406.         });

  2407. 

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

  2409.         {

  2410.             auto* owner = getOwner (self);

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

  2412.         });

  2413. 

  2414.         addMethod (@selector (attributedSubstringForProposedRange:actualRange:), [] (id self, SEL, NSRange theRange, NSRangePointer actualRange) -> NSAttributedString*

  2415.         {

  2416.             jassert (theRange.location != NSNotFound);

  2417. 

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

  2419.             {

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

  2421.                 {

  2422.                     const auto clamped = Range<int> { 0, target->getTotalNumChars() }.constrainRange (nsRangeToJuce (theRange));

  2423. 

  2424.                     if (actualRange != nullptr)

  2425.                         *actualRange = juceRangeToNS (clamped);

  2426. 

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

  2428.                 }

  2429.             }

  2430. 

  2431.             return nil;

  2432.         });

  2433. 

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

  2435.         {

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

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

  2438.                     return NSMakeRange (static_cast<NSUInteger> (owner->startOfMarkedTextInTextInputTarget),

  2439.                                         static_cast<NSUInteger> (owner->stringBeingComposed.length()));

  2440. 

  2441.             return NSMakeRange (NSNotFound, 0);

  2442.         });

  2443. 

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

  2445.         {

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

  2447.             {

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

  2449.                 {

  2450.                     const auto highlight = target->getHighlightedRegion();

  2451. 

  2452.                     // The accent-selector popup does not show if the selectedRange location is NSNotFound!

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

  2454.                                         (NSUInteger) highlight.getLength());

  2455.                 }

  2456.             }

  2457. 

  2458.             return NSMakeRange (NSNotFound, 0);

  2459.         });

  2460. 

  2461.         addMethod (@selector (firstRectForCharacterRange:actualRange:), [] (id self, SEL, NSRange range, NSRangePointer actualRange)

  2462.         {

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

  2464.             {

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

  2466.                 {

  2467.                     if (auto* comp = dynamic_cast<Component*> (target))

  2468.                     {

  2469.                         const auto codePointRange = range.location == NSNotFound ? Range<int>::emptyRange (target->getCaretPosition())

  2470.                                                                                  : nsRangeToJuce (range);

  2471.                         const auto clamped = Range<int> { 0, target->getTotalNumChars() }.constrainRange (codePointRange);

  2472. 

  2473.                         if (actualRange != nullptr)

  2474.                             *actualRange = juceRangeToNS (clamped);

  2475. 

  2476.                         const auto rect = codePointRange.isEmpty() ? target->getCaretRectangleForCharIndex (codePointRange.getStart())

  2477.                                                                    : target->getTextBounds (codePointRange).getRectangle (0);

  2478.                         const auto areaOnDesktop = comp->localAreaToGlobal (rect);

  2479. 

  2480.                         return flippedScreenRect (makeNSRect (detail::ScalingHelpers::scaledScreenPosToUnscaled (areaOnDesktop)));

  2481.                     }

  2482.                 }

  2483.             }

  2484. 

  2485.             return NSZeroRect;

  2486.         });

  2487. 

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

  2489. 

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

  2491. 

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

  2493.         {

  2494.             auto* owner = getOwner (self);

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

  2496.         });

  2497. 

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

  2499. 

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

  2501.         {

  2502.             auto* owner = getOwner (self);

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

  2504.         });

  2505. 

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

  2507. 

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

  2509. 

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

  2511. 

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

  2513.         {

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

  2515.         });

  2516. 

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

  2518.         {

  2519.             return [getAccessibleChild (self) accessibilityFocusedUIElement];

  2520.         });

  2521. 

  2522.         // deprecated methods required for backwards compatibility

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

  2524. 

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

  2526.         {

  2527.             if ([attribute isEqualToString: NSAccessibilityChildrenAttribute])

  2528.                 return getAccessibilityChildren (self, {});

  2529. 

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

  2531.         });

  2532. 

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

  2534. 

  2535.         addProtocol (@protocol (NSTextInputClient));

  2536. 

  2537.         registerClass();

  2538.     }

  2539. 

  2540. private:

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

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

  2543.     {

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

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

  2546.     }

  2547. 

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

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

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

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

  2552. 

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

  2554.     {

  2555.         if (JUCEApplicationBase::isStandaloneApp())

  2556.         {

  2557.             asyncMouseDown (self, s, ev);

  2558.         }

  2559.         else

  2560.         {

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

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

  2563.             // the event asynchronously..

  2564.             [self performSelectorOnMainThread: NSViewComponentPeer::asyncMouseDownSelector

  2565.                                    withObject: ev

  2566.                                 waitUntilDone: NO];

  2567.         }

  2568.     }

  2569. 

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

  2571.     {

  2572.         if (JUCEApplicationBase::isStandaloneApp())

  2573.         {

  2574.             asyncMouseUp (self, s, ev);

  2575.         }

  2576.         else

  2577.         {

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

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

  2580.             // the event asynchronously..

  2581.             [self performSelectorOnMainThread: NSViewComponentPeer::asyncMouseUpSelector

  2582.                                    withObject: ev

  2583.                                 waitUntilDone: NO];

  2584.         }

  2585.     }

  2586. 

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

  2588.     {

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

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

  2591.                 return NSDragOperationGeneric;

  2592. 

  2593.         return NSDragOperationNone;

  2594.     }

  2595. 

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

  2597.     {

  2598.         return NSAccessibilityUnignoredChildrenForOnlyChild (getAccessibleChild (self));

  2599.     }

  2600. };

  2601. 

  2602. //==============================================================================

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

  2604. {

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

  2606.     {

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

  2608.         {

  2609.             auto* owner = getOwner (self);

  2610. 

  2611.             return owner != nullptr

  2612.                    && owner->canBecomeKeyWindow()

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

  2614.         });

  2615. 

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

  2617.         {

  2618.             auto* owner = getOwner (self);

  2619. 

  2620.             return owner != nullptr

  2621.                    && owner->canBecomeMainWindow()

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

  2623.         });

  2624. 

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

  2626.         {

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

  2628. 

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

  2630.             {

  2631.                 jassert (! owner->inBecomeKeyWindow);

  2632. 

  2633.                 const ScopedValueSetter scope { owner->inBecomeKeyWindow, true };

  2634. 

  2635.                 if (owner->canBecomeKeyWindow())

  2636.                 {

  2637.                     owner->becomeKeyWindow();

  2638.                     return;

  2639.                 }

  2640. 

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

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

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

  2644.             }

  2645.         });

  2646. 

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

  2648.         {

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

  2650. 

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

  2652.                 owner->resignKeyWindow();

  2653.         });

  2654. 

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

  2656.         {

  2657.             auto* owner = getOwner (self);

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

  2659.         });

  2660. 

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

  2662.         {

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

  2664.             {

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

  2666.                                                                               frameRect, screen);

  2667. 

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

  2669.             }

  2670. 

  2671.             return frameRect;

  2672.         });

  2673. 

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

  2675.         {

  2676.             auto* owner = getOwner (self);

  2677. 

  2678.             if (owner == nullptr)

  2679.                 return proposedFrameSize;

  2680. 

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

  2682.             frameRect.size = proposedFrameSize;

  2683. 

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

  2685. 

  2686.             owner->dismissModals();

  2687. 

  2688.             return frameRect.size;

  2689.         });

  2690. 

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

  2692.         {

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

  2694.                 owner->resetWindowPresentation();

  2695.         });

  2696. 

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

  2698.         {

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

  2700.                 return;

  2701. 

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

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

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

  2705.         });

  2706. 

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

  2708.         {

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

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

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

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

  2713.         });

  2714. 

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

  2716.         {

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

  2718.                 owner->liveResizingStart();

  2719.         });

  2720. 

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

  2722.         {

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

  2724.                 owner->liveResizingEnd();

  2725.         });

  2726. 

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

  2728.         {

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

  2730.                 return owner->windowRepresentsFile;

  2731. 

  2732.             return false;

  2733.         });

  2734. 

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

  2736. 

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

  2738.         {

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

  2740.             {

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

  2742.                 {

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

  2744.                     {

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

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

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

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

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

  2750. 

  2751.                         return flippedScreenRect (makeNSRect ([&]

  2752.                                                               {

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

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

  2755. 

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

  2757.                                                                   return constrained;

  2758.                                                               }()));

  2759.                     }

  2760.                 }

  2761.             }

  2762. 

  2763.             return r;

  2764.         });

  2765. 

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

  2767.         {

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

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

  2770.                     return NO;

  2771. 

  2772.             return YES;

  2773.         });

  2774. 

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

  2776. 

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

  2778. 

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

  2780. 

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

  2782.         {

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

  2784.                 return [getAccessibleChild (self) accessibilitySubrole];

  2785. 

  2786.             return nil;

  2787.         });

  2788. 

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

  2790.         {

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

  2792.                 return owner->windowRepresentsFile;

  2793. 

  2794.             return false;

  2795.         });

  2796. 

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

  2798.         {

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

  2800.             {

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

  2802. 

  2803.                 if (! isFullScreen)

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

  2805. 

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

  2807. 

  2808.                 if (isFullScreen)

  2809.                 {

  2810.                     [NSApp setPresentationOptions: NSApplicationPresentationDefault];

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

  2812.                 }

  2813.             }

  2814.         });

  2815. 

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

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

  2818. 

  2819.         addProtocol (@protocol (NSWindowDelegate));

  2820. 

  2821.         registerClass();

  2822.     }

  2823. 

  2824. private:

  2825.     //==============================================================================

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

  2827. };

  2828. 

  2829. NSView* NSViewComponentPeer::createViewInstance()

  2830. {

  2831.     static JuceNSViewClass cls;

  2832.     return cls.createInstance();

  2833. }

  2834. 

  2835. NSWindow* NSViewComponentPeer::createWindowInstance()

  2836. {

  2837.     static JuceNSWindowClass cls;

  2838.     return cls.createInstance();

  2839. }

  2840. 

  2841. 

  2842. //==============================================================================

  2843. bool KeyPress::isKeyCurrentlyDown (int keyCode)

  2844. {

  2845.     const auto isDown = [] (int k)

  2846.     {

  2847.         return NSViewComponentPeer::keysCurrentlyDown.find (k) != NSViewComponentPeer::keysCurrentlyDown.cend();

  2848.     };

  2849. 

  2850.     if (isDown (keyCode))

  2851.         return true;

  2852. 

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

  2854.          && isDown ((int) CharacterFunctions::toLowerCase ((juce_wchar) keyCode)))

  2855.         return true;

  2856. 

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

  2858.          && isDown ((int) CharacterFunctions::toUpperCase ((juce_wchar) keyCode)))

  2859.         return true;

  2860. 

  2861.     return false;

  2862. }

  2863. 

  2864. //==============================================================================

  2865. bool detail::MouseInputSourceList::addSource()

  2866. {

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

  2868.     {

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

  2870.         return true;

  2871.     }

  2872. 

  2873.     return false;

  2874. }

  2875. 

  2876. bool detail::MouseInputSourceList::canUseTouch() const

  2877. {

  2878.     return false;

  2879. }

  2880. 

  2881. //==============================================================================

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

  2883. {

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

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

  2886. 

  2887.     if (peer->hasNativeTitleBar())

  2888.     {

  2889.         if (shouldBeEnabled && ! allowMenusAndBars)

  2890.             [NSApp setPresentationOptions: NSApplicationPresentationHideDock | NSApplicationPresentationHideMenuBar];

  2891.         else if (! shouldBeEnabled)

  2892.             [NSApp setPresentationOptions: NSApplicationPresentationDefault];

  2893. 

  2894.         peer->setFullScreen (true);

  2895.     }

  2896.     else

  2897.     {

  2898.         if (shouldBeEnabled)

  2899.         {

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

  2901.                                                               : (NSApplicationPresentationHideDock | NSApplicationPresentationHideMenuBar))];

  2902. 

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

  2904.             peer->becomeKeyWindow();

  2905.         }

  2906.         else

  2907.         {

  2908.             peer->resetWindowPresentation();

  2909.         }

  2910.     }

  2911. }

  2912. 

  2913. void Desktop::allowedOrientationsChanged() {}

  2914. 

  2915. //==============================================================================

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

  2917. {

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

  2919. }

  2920. 

  2921. //==============================================================================

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

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

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

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

  2926. const int KeyPress::leftKey         = NSLeftArrowFunctionKey;

  2927. const int KeyPress::rightKey        = NSRightArrowFunctionKey;

  2928. const int KeyPress::upKey           = NSUpArrowFunctionKey;

  2929. const int KeyPress::downKey         = NSDownArrowFunctionKey;

  2930. const int KeyPress::pageUpKey       = NSPageUpFunctionKey;

  2931. const int KeyPress::pageDownKey     = NSPageDownFunctionKey;

  2932. const int KeyPress::endKey          = NSEndFunctionKey;

  2933. const int KeyPress::homeKey         = NSHomeFunctionKey;

  2934. const int KeyPress::deleteKey       = NSDeleteFunctionKey;

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

  2936. const int KeyPress::tabKey          = 9;

  2937. const int KeyPress::F1Key           = NSF1FunctionKey;

  2938. const int KeyPress::F2Key           = NSF2FunctionKey;

  2939. const int KeyPress::F3Key           = NSF3FunctionKey;

  2940. const int KeyPress::F4Key           = NSF4FunctionKey;

  2941. const int KeyPress::F5Key           = NSF5FunctionKey;

  2942. const int KeyPress::F6Key           = NSF6FunctionKey;

  2943. const int KeyPress::F7Key           = NSF7FunctionKey;

  2944. const int KeyPress::F8Key           = NSF8FunctionKey;

  2945. const int KeyPress::F9Key           = NSF9FunctionKey;

  2946. const int KeyPress::F10Key          = NSF10FunctionKey;

  2947. const int KeyPress::F11Key          = NSF11FunctionKey;

  2948. const int KeyPress::F12Key          = NSF12FunctionKey;

  2949. const int KeyPress::F13Key          = NSF13FunctionKey;

  2950. const int KeyPress::F14Key          = NSF14FunctionKey;

  2951. const int KeyPress::F15Key          = NSF15FunctionKey;

  2952. const int KeyPress::F16Key          = NSF16FunctionKey;

  2953. const int KeyPress::F17Key          = NSF17FunctionKey;

  2954. const int KeyPress::F18Key          = NSF18FunctionKey;

  2955. const int KeyPress::F19Key          = NSF19FunctionKey;

  2956. const int KeyPress::F20Key          = NSF20FunctionKey;

  2957. const int KeyPress::F21Key          = NSF21FunctionKey;

  2958. const int KeyPress::F22Key          = NSF22FunctionKey;

  2959. const int KeyPress::F23Key          = NSF23FunctionKey;

  2960. const int KeyPress::F24Key          = NSF24FunctionKey;

  2961. const int KeyPress::F25Key          = NSF25FunctionKey;

  2962. const int KeyPress::F26Key          = NSF26FunctionKey;

  2963. const int KeyPress::F27Key          = NSF27FunctionKey;

  2964. const int KeyPress::F28Key          = NSF28FunctionKey;

  2965. const int KeyPress::F29Key          = NSF29FunctionKey;

  2966. const int KeyPress::F30Key          = NSF30FunctionKey;

  2967. const int KeyPress::F31Key          = NSF31FunctionKey;

  2968. const int KeyPress::F32Key          = NSF32FunctionKey;

  2969. const int KeyPress::F33Key          = NSF33FunctionKey;

  2970. const int KeyPress::F34Key          = NSF34FunctionKey;

  2971. const int KeyPress::F35Key          = NSF35FunctionKey;

  2972. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  2995. 

  2996. } // namespace juce