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.
12984 Commits
9 Branches
412MB
Tree: 05a42424f9
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '05a42424f9'
${ noResults }
JUCE/modules/juce_gui_basics/native/juce_mac_NSViewComponentPee...

2850 lines
107KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE 7 technical preview.

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

  6. 

  7.    You may use this code under the terms of the GPL v3

  8.    (see www.gnu.org/licenses).

  9. 

  10.    For the technical preview this file cannot be licensed commercially.

  11. 

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

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

  14.    DISCLAIMED.

  15. 

  16.   ==============================================================================

  17. */

  18. 

  19. #include "juce_mac_CGMetalLayerRenderer.h"

  20. 

  21. @interface NSEvent (DeviceDelta)

  22. - (float)deviceDeltaX;

  23. - (float)deviceDeltaY;

  24. @end

  25. 

  26. //==============================================================================

  27. namespace juce

  28. {

  29. 

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

  31. extern AppFocusChangeCallback appFocusChangeCallback;

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

  33. extern CheckEventBlockedByModalComps isEventBlockedByModalComps;

  34. 

  35. //==============================================================================

  36. static constexpr int translateVirtualToAsciiKeyCode (int keyCode) noexcept

  37. {

  38.     switch (keyCode)

  39.     {

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

  41.         case 0x00: return 'A';

  42.         case 0x01: return 'S';

  43.         case 0x02: return 'D';

  44.         case 0x03: return 'F';

  45.         case 0x04: return 'H';

  46.         case 0x05: return 'G';

  47.         case 0x06: return 'Z';

  48.         case 0x07: return 'X';

  49.         case 0x08: return 'C';

  50.         case 0x09: return 'V';

  51.         case 0x0B: return 'B';

  52.         case 0x0C: return 'Q';

  53.         case 0x0D: return 'W';

  54.         case 0x0E: return 'E';

  55.         case 0x0F: return 'R';

  56.         case 0x10: return 'Y';

  57.         case 0x11: return 'T';

  58.         case 0x12: return '1';

  59.         case 0x13: return '2';

  60.         case 0x14: return '3';

  61.         case 0x15: return '4';

  62.         case 0x16: return '6';

  63.         case 0x17: return '5';

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

  65.         case 0x19: return '9';

  66.         case 0x1A: return '7';

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

  68.         case 0x1C: return '8';

  69.         case 0x1D: return '0';

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

  71.         case 0x1F: return 'O';

  72.         case 0x20: return 'U';

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

  74.         case 0x22: return 'I';

  75.         case 0x23: return 'P';

  76.         case 0x25: return 'L';

  77.         case 0x26: return 'J';

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

  79.         case 0x28: return 'K';

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

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

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

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

  84.         case 0x2D: return 'N';

  85.         case 0x2E: return 'M';

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

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

  88. 

  89.         default:   return keyCode;

  90.     }

  91. }

  92. 

  93. constexpr int extendedKeyModifier = 0x30000;

  94. 

  95. //==============================================================================

  96. class NSViewComponentPeer  : public ComponentPeer

  97. {

  98. public:

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

  100.         : ComponentPeer (comp, windowStyleFlags),

  101.           safeComponent (&comp),

  102.           isSharedWindow (viewToAttachTo != nil),

  103.           lastRepaintTime (Time::getMillisecondCounter())

  104.     {

  105.         appFocusChangeCallback = appFocusChanged;

  106.         isEventBlockedByModalComps = checkEventBlockedByModalComps;

  107. 

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

  109. 

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

  111.         setOwner (view, this);

  112. 

  113.         [view registerForDraggedTypes: getSupportedDragTypes()];

  114. 

  115.         const auto options = NSTrackingMouseEnteredAndExited

  116.                            | NSTrackingMouseMoved

  117.                            | NSTrackingEnabledDuringMouseDrag

  118.                            | NSTrackingActiveAlways

  119.                            | NSTrackingInVisibleRect;

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

  121.                                                                                       options: options

  122.                                                                                         owner: view

  123.                                                                                      userInfo: nil] };

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

  125. 

  126.         notificationCenter = [NSNotificationCenter defaultCenter];

  127. 

  128.         [notificationCenter  addObserver: view

  129.                                 selector: frameChangedSelector

  130.                                     name: NSViewFrameDidChangeNotification

  131.                                   object: view];

  132. 

  133.         [view setPostsFrameChangedNotifications: YES];

  134. 

  135.        #if USE_COREGRAPHICS_RENDERING

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

  137.         {

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

  139.             {

  140.                 [view setWantsLayer: YES];

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

  142.             }

  143.         }

  144.        #endif

  145. 

  146.         createCVDisplayLink();

  147. 

  148.         if (isSharedWindow)

  149.         {

  150.             window = [viewToAttachTo window];

  151.             [viewToAttachTo addSubview: view];

  152.         }

  153.         else

  154.         {

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

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

  157.             r = flippedScreenRect (r);

  158. 

  159.             window = [createWindowInstance() initWithContentRect: r

  160.                                                        styleMask: getNSWindowStyleMask (windowStyleFlags)

  161.                                                          backing: NSBackingStoreBuffered

  162.                                                            defer: YES];

  163.             setOwner (window, this);

  164. 

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

  166.                 [window setAccessibilityElement: YES];

  167. 

  168.             [window orderOut: nil];

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

  170. 

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

  172. 

  173.             if (! [window isOpaque])

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

  175. 

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

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

  178. 

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

  180. 

  181.             if (component.isAlwaysOnTop())

  182.                 setAlwaysOnTop (true);

  183. 

  184.             [window setContentView: view];

  185. 

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

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

  188.             [window setReleasedWhenClosed: YES];

  189.             [window retain];

  190. 

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

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

  193. 

  194.             setCollectionBehaviour (false);

  195. 

  196.             [window setRestorable: NO];

  197. 

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

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

  200.                 [window setTabbingMode: NSWindowTabbingModeDisallowed];

  201.            #endif

  202. 

  203.             [notificationCenter  addObserver: view

  204.                                     selector: frameChangedSelector

  205.                                         name: NSWindowDidMoveNotification

  206.                                       object: window];

  207. 

  208.             [notificationCenter  addObserver: view

  209.                                     selector: frameChangedSelector

  210.                                         name: NSWindowDidMiniaturizeNotification

  211.                                       object: window];

  212. 

  213.             [notificationCenter  addObserver: view

  214.                                     selector: @selector (windowWillMiniaturize:)

  215.                                         name: NSWindowWillMiniaturizeNotification

  216.                                       object: window];

  217. 

  218.             [notificationCenter  addObserver: view

  219.                                     selector: @selector (windowDidDeminiaturize:)

  220.                                         name: NSWindowDidDeminiaturizeNotification

  221.                                       object: window];

  222.         }

  223. 

  224.         auto alpha = component.getAlpha();

  225. 

  226.         if (alpha < 1.0f)

  227.             setAlpha (alpha);

  228. 

  229.         setTitle (component.getName());

  230. 

  231.         getNativeRealtimeModifiers = []

  232.         {

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

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

  235. 

  236.             return ModifierKeys::currentModifiers;

  237.         };

  238.     }

  239. 

  240.     ~NSViewComponentPeer() override

  241.     {

  242.         CVDisplayLinkStop (displayLink);

  243.         dispatch_source_cancel (displaySource);

  244. 

  245.         [notificationCenter removeObserver: view];

  246.         setOwner (view, nullptr);

  247. 

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

  249.         {

  250.             redirectWillMoveToWindow (nullptr);

  251.             [view removeFromSuperview];

  252.         }

  253. 

  254.         if (! isSharedWindow)

  255.         {

  256.             setOwner (window, nullptr);

  257.             [window setContentView: nil];

  258.             [window close];

  259.             [window release];

  260.         }

  261. 

  262.         [view release];

  263.     }

  264. 

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

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

  267. 

  268.     void setVisible (bool shouldBeVisible) override

  269.     {

  270.         if (isSharedWindow)

  271.         {

  272.             if (shouldBeVisible)

  273.                 [view setHidden: false];

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

  275.                 [view setHidden: true];

  276.         }

  277.         else

  278.         {

  279.             if (shouldBeVisible)

  280.             {

  281.                 ++insideToFrontCall;

  282.                 [window orderFront: nil];

  283.                 --insideToFrontCall;

  284.                 handleBroughtToFront();

  285.             }

  286.             else

  287.             {

  288.                 [window orderOut: nil];

  289.             }

  290.         }

  291.     }

  292. 

  293.     void setTitle (const String& title) override

  294.     {

  295.         JUCE_AUTORELEASEPOOL

  296.         {

  297.             if (! isSharedWindow)

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

  299.         }

  300.     }

  301. 

  302.     bool setDocumentEditedStatus (bool edited) override

  303.     {

  304.         if (! hasNativeTitleBar())

  305.             return false;

  306. 

  307.         [window setDocumentEdited: edited];

  308.         return true;

  309.     }

  310. 

  311.     void setRepresentedFile (const File& file) override

  312.     {

  313.         if (! isSharedWindow)

  314.         {

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

  316.                                                                 ? file.getFullPathName()

  317.                                                                 : String())];

  318. 

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

  320.         }

  321.     }

  322. 

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

  324.     {

  325.         auto r = makeNSRect (newBounds);

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

  327. 

  328.         if (isSharedWindow)

  329.         {

  330.             [view setFrame: r];

  331.         }

  332.         else

  333.         {

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

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

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

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

  338. 

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

  340.                      display: isPre10_11];

  341.         }

  342. 

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

  344.             [view setNeedsDisplay: true];

  345.     }

  346. 

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

  348.     {

  349.         auto r = [view frame];

  350.         NSWindow* viewWindow = [view window];

  351. 

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

  353.         {

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

  355.             r = [viewWindow convertRectToScreen: r];

  356. 

  357.             r = flippedScreenRect (r);

  358.         }

  359. 

  360.         return convertToRectInt (r);

  361.     }

  362. 

  363.     Rectangle<int> getBounds() const override

  364.     {

  365.         return getBounds (! isSharedWindow);

  366.     }

  367. 

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

  369.     {

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

  371.     }

  372. 

  373.     using ComponentPeer::localToGlobal;

  374. 

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

  376.     {

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

  378.     }

  379. 

  380.     using ComponentPeer::globalToLocal;

  381. 

  382.     void setAlpha (float newAlpha) override

  383.     {

  384.         if (isSharedWindow)

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

  386.         else

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

  388.     }

  389. 

  390.     void setMinimised (bool shouldBeMinimised) override

  391.     {

  392.         if (! isSharedWindow)

  393.         {

  394.             if (shouldBeMinimised)

  395.                 [window miniaturize: nil];

  396.             else

  397.                 [window deminiaturize: nil];

  398.         }

  399.     }

  400. 

  401.     bool isMinimised() const override

  402.     {

  403.         return [window isMiniaturized];

  404.     }

  405. 

  406.     NSWindowCollectionBehavior getCollectionBehavior (bool forceFullScreen) const

  407.     {

  408.         if (forceFullScreen)

  409.             return NSWindowCollectionBehaviorFullScreenPrimary;

  410. 

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

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

  413. 

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

  415.              ? NSWindowCollectionBehaviorFullScreenPrimary

  416.              : fullScreenNone;

  417.     }

  418. 

  419.     void setCollectionBehaviour (bool forceFullScreen) const

  420.     {

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

  422.     }

  423. 

  424.     void setFullScreen (bool shouldBeFullScreen) override

  425.     {

  426.         if (isSharedWindow)

  427.             return;

  428. 

  429.         if (shouldBeFullScreen)

  430.             setCollectionBehaviour (true);

  431. 

  432.         if (isMinimised())

  433.             setMinimised (false);

  434. 

  435.         if (shouldBeFullScreen != isFullScreen())

  436.             [window toggleFullScreen: nil];

  437.     }

  438. 

  439.     bool isFullScreen() const override

  440.     {

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

  442.     }

  443. 

  444.     bool isKioskMode() const override

  445.     {

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

  447.     }

  448. 

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

  450.     {

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

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

  453. 

  454.         return true;

  455.     }

  456. 

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

  458.     {

  459.         NSRect viewFrame = [view frame];

  460. 

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

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

  463.             return false;

  464. 

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

  466.         {

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

  468.             {

  469.                 NSRect windowFrame = [viewWindow frame];

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

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

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

  473. 

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

  475.                     return false;

  476. 

  477.             }

  478.         }

  479. 

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

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

  482. 

  483.         return trueIfInAChildWindow ? (v != nil)

  484.                                     : (v == view);

  485.     }

  486. 

  487.     OptionalBorderSize getFrameSizeIfPresent() const override

  488.     {

  489.         if (! isSharedWindow)

  490.         {

  491.             BorderSize<int> b;

  492. 

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

  494.             NSRect w = [window frame];

  495. 

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

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

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

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

  500. 

  501.             return OptionalBorderSize { b };

  502.         }

  503. 

  504.         return {};

  505.     }

  506. 

  507.     BorderSize<int> getFrameSize() const override

  508.     {

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

  510.             return *frameSize;

  511. 

  512.         return {};

  513.     }

  514. 

  515.     bool hasNativeTitleBar() const

  516.     {

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

  518.     }

  519. 

  520.     bool setAlwaysOnTop (bool alwaysOnTop) override

  521.     {

  522.         if (! isSharedWindow)

  523.         {

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

  525.                                                                                         : NSFloatingWindowLevel)

  526.                                           : NSNormalWindowLevel];

  527. 

  528.             isAlwaysOnTop = alwaysOnTop;

  529.         }

  530. 

  531.         return true;

  532.     }

  533. 

  534.     void toFront (bool makeActiveWindow) override

  535.     {

  536.         if (isSharedWindow)

  537.         {

  538.             NSView* superview = [view superview];

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

  540. 

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

  542. 

  543.             if (! isFrontmost)

  544.             {

  545.                 [view retain];

  546.                 [subviews removeObject: view];

  547.                 [subviews addObject: view];

  548. 

  549.                 [superview setSubviews: subviews];

  550.                 [view release];

  551.             }

  552.         }

  553. 

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

  555.         {

  556.             ++insideToFrontCall;

  557. 

  558.             if (makeActiveWindow)

  559.                 [window makeKeyAndOrderFront: nil];

  560.             else

  561.                 [window orderFront: nil];

  562. 

  563.             if (insideToFrontCall <= 1)

  564.             {

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

  566.                 handleBroughtToFront();

  567.             }

  568. 

  569.             --insideToFrontCall;

  570.         }

  571.     }

  572. 

  573.     void toBehind (ComponentPeer* other) override

  574.     {

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

  576.         {

  577.             if (isSharedWindow)

  578.             {

  579.                 NSView* superview = [view superview];

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

  581. 

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

  583. 

  584.                 if (otherViewIndex == NSNotFound)

  585.                     return;

  586. 

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

  588. 

  589.                 if (! isBehind)

  590.                 {

  591.                     [view retain];

  592.                     [subviews removeObject: view];

  593.                     [subviews insertObject: view

  594.                                    atIndex: otherViewIndex];

  595. 

  596.                     [superview setSubviews: subviews];

  597.                     [view release];

  598.                 }

  599.             }

  600.             else if (component.isVisible())

  601.             {

  602.                 [window orderWindow: NSWindowBelow

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

  604.             }

  605.         }

  606.         else

  607.         {

  608.             jassertfalse; // wrong type of window?

  609.         }

  610.     }

  611. 

  612.     void setIcon (const Image& newIcon) override

  613.     {

  614.         if (! isSharedWindow)

  615.         {

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

  617.             if (! windowRepresentsFile)

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

  619. 

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

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

  622.         }

  623.     }

  624. 

  625.     StringArray getAvailableRenderingEngines() override

  626.     {

  627.         StringArray s ("Software Renderer");

  628. 

  629.        #if USE_COREGRAPHICS_RENDERING

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

  631.        #endif

  632. 

  633.         return s;

  634.     }

  635. 

  636.     int getCurrentRenderingEngine() const override

  637.     {

  638.         return usingCoreGraphics ? 1 : 0;

  639.     }

  640. 

  641.     void setCurrentRenderingEngine (int index) override

  642.     {

  643.        #if USE_COREGRAPHICS_RENDERING

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

  645.         {

  646.             usingCoreGraphics = index > 0;

  647.             [view setNeedsDisplay: true];

  648.         }

  649.        #else

  650.         ignoreUnused (index);

  651.        #endif

  652.     }

  653. 

  654.     void redirectMouseDown (NSEvent* ev)

  655.     {

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

  657.             Process::makeForegroundProcess();

  658. 

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

  660.         sendMouseEvent (ev);

  661.     }

  662. 

  663.     void redirectMouseUp (NSEvent* ev)

  664.     {

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

  666.         sendMouseEvent (ev);

  667.         showArrowCursorIfNeeded();

  668.     }

  669. 

  670.     void redirectMouseDrag (NSEvent* ev)

  671.     {

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

  673.         sendMouseEvent (ev);

  674.     }

  675. 

  676.     void redirectMouseMove (NSEvent* ev)

  677.     {

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

  679. 

  680.         NSPoint windowPos = [ev locationInWindow];

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

  682. 

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

  684.             sendMouseEvent (ev);

  685.         else

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

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

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

  689. 

  690.         showArrowCursorIfNeeded();

  691.     }

  692. 

  693.     void redirectMouseEnter (NSEvent* ev)

  694.     {

  695.         sendMouseEnterExit (ev);

  696.     }

  697. 

  698.     void redirectMouseExit (NSEvent* ev)

  699.     {

  700.         sendMouseEnterExit (ev);

  701.     }

  702. 

  703.     static float checkDeviceDeltaReturnValue (float v) noexcept

  704.     {

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

  706.         v *= 0.5f / 256.0f;

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

  708.     }

  709. 

  710.     void redirectMouseWheel (NSEvent* ev)

  711.     {

  712.         updateModifiers (ev);

  713. 

  714.         MouseWheelDetails wheel;

  715.         wheel.deltaX = 0;

  716.         wheel.deltaY = 0;

  717.         wheel.isReversed = false;

  718.         wheel.isSmooth = false;

  719.         wheel.isInertial = false;

  720. 

  721.         @try

  722.         {

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

  724.                 wheel.isReversed = [ev isDirectionInvertedFromDevice];

  725. 

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

  727. 

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

  729.             {

  730.                 if ([ev hasPreciseScrollingDeltas])

  731.                 {

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

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

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

  735.                     wheel.isSmooth = true;

  736.                 }

  737.             }

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

  739.             {

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

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

  742.             }

  743.         }

  744.         @catch (...)

  745.         {}

  746. 

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

  748.         {

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

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

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

  752.         }

  753. 

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

  755.     }

  756. 

  757.     void redirectMagnify (NSEvent* ev)

  758.     {

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

  760. 

  761.         if (invScale > 0.0f)

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

  763.     }

  764. 

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

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

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

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

  769. 

  770.     void redirectWillMoveToWindow (NSWindow* newWindow)

  771.     {

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

  773.         {

  774.             [notificationCenter removeObserver: view

  775.                                           name: NSWindowDidMoveNotification

  776.                                         object: currentWindow];

  777. 

  778.             [notificationCenter removeObserver: view

  779.                                           name: NSWindowWillMiniaturizeNotification

  780.                                         object: currentWindow];

  781. 

  782.             [notificationCenter removeObserver: view

  783.                                           name: NSWindowDidBecomeKeyNotification

  784.                                         object: currentWindow];

  785. 

  786.             [notificationCenter removeObserver: view

  787.                                           name: NSWindowDidChangeScreenNotification

  788.                                         object: currentWindow];

  789.         }

  790. 

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

  792.         {

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

  794.                 comp->setVisible (false);

  795.         }

  796.     }

  797. 

  798.     void sendMouseEvent (NSEvent* ev)

  799.     {

  800.         updateModifiers (ev);

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

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

  803.     }

  804. 

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

  806.     {

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

  808.         auto keyCode = getKeyCodeFromEvent (ev);

  809. 

  810.        #if JUCE_DEBUG_KEYCODES

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

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

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

  814.        #endif

  815. 

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

  817.         {

  818.             if (isKeyDown)

  819.             {

  820.                 bool used = false;

  821. 

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

  823.                 {

  824.                     auto textCharacter = u.getAndAdvance();

  825. 

  826.                     switch (keyCode)

  827.                     {

  828.                         case NSLeftArrowFunctionKey:

  829.                         case NSRightArrowFunctionKey:

  830.                         case NSUpArrowFunctionKey:

  831.                         case NSDownArrowFunctionKey:

  832.                         case NSPageUpFunctionKey:

  833.                         case NSPageDownFunctionKey:

  834.                         case NSEndFunctionKey:

  835.                         case NSHomeFunctionKey:

  836.                         case NSDeleteFunctionKey:

  837.                             textCharacter = 0;

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

  839. 

  840.                         default:

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

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

  843.                                 textCharacter = 0;

  844.                             break;

  845.                     }

  846. 

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

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

  849.                 }

  850. 

  851.                 return used;

  852.             }

  853. 

  854.             if (handleKeyUpOrDown (false))

  855.                 return true;

  856.         }

  857. 

  858.         return false;

  859.     }

  860. 

  861.     bool redirectKeyDown (NSEvent* ev)

  862.     {

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

  864.         // our event object gets lost)

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

  866. 

  867.         updateKeysDown (ev, true);

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

  869. 

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

  871.         {

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

  873.             updateKeysDown (ev, false);

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

  875.         }

  876. 

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

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

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

  880.             used = true;

  881. 

  882.         return used;

  883.     }

  884. 

  885.     bool redirectKeyUp (NSEvent* ev)

  886.     {

  887.         updateKeysDown (ev, false);

  888.         return handleKeyEvent (ev, false)

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

  890.     }

  891. 

  892.     void redirectModKeyChange (NSEvent* ev)

  893.     {

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

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

  896. 

  897.         keysCurrentlyDown.clear();

  898.         handleKeyUpOrDown (true);

  899. 

  900.         updateModifiers (ev);

  901.         handleModifierKeysChange();

  902.     }

  903. 

  904.     //==============================================================================

  905.     void drawRect (NSRect r)

  906.     {

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

  908.             return;

  909. 

  910.         auto cg = []

  911.         {

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

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

  914. 

  915.             JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wdeprecated-declarations")

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

  917.             JUCE_END_IGNORE_WARNINGS_GCC_LIKE

  918.         }();

  919. 

  920.         drawRectWithContext (cg, r);

  921.     }

  922. 

  923.     void drawRectWithContext (CGContextRef cg, NSRect r)

  924.     {

  925.         if (! component.isOpaque())

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

  927. 

  928.         float displayScale = 1.0f;

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

  930. 

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

  932.             displayScale = (float) screen.backingScaleFactor;

  933. 

  934.         auto invalidateTransparentWindowShadow = [this]

  935.         {

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

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

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

  939.                 [window invalidateShadow];

  940.         };

  941. 

  942.        #if USE_COREGRAPHICS_RENDERING && JUCE_COREGRAPHICS_RENDER_WITH_MULTIPLE_PAINT_CALLS

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

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

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

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

  947.         // to avoid CoreGraphics consolidating disparate rects.

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

  949.         {

  950.             const NSRect* rects = nullptr;

  951.             NSInteger numRects = 0;

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

  953. 

  954.             if (numRects > 1)

  955.             {

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

  957.                 {

  958.                     NSRect rect = rects[i];

  959.                     CGContextSaveGState (cg);

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

  961.                     renderRect (cg, rect, displayScale);

  962.                     CGContextRestoreGState (cg);

  963.                 }

  964. 

  965.                 invalidateTransparentWindowShadow();

  966.                 return;

  967.             }

  968.         }

  969.        #endif

  970. 

  971.         renderRect (cg, r, displayScale);

  972.         invalidateTransparentWindowShadow();

  973.     }

  974. 

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

  976.     {

  977.        #if USE_COREGRAPHICS_RENDERING

  978.         if (usingCoreGraphics)

  979.         {

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

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

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

  983.             handlePaint (context);

  984.         }

  985.         else

  986.        #endif

  987.         {

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

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

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

  991. 

  992.             RectangleList<int> clip;

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

  994. 

  995.             if (! clip.isEmpty())

  996.             {

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

  998.                             roundToInt (clipW * displayScale),

  999.                             roundToInt (clipH * displayScale),

  1000.                             ! component.isOpaque());

  1001. 

  1002.                 {

  1003.                     auto intScale = roundToInt (displayScale);

  1004. 

  1005.                     if (intScale != 1)

  1006.                         clip.scaleAll (intScale);

  1007. 

  1008.                     auto context = component.getLookAndFeel()

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

  1010. 

  1011.                     if (intScale != 1)

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

  1013. 

  1014.                     handlePaint (*context);

  1015.                 }

  1016. 

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

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

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

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

  1021.                 CGImageRelease (image);

  1022.             }

  1023.         }

  1024.     }

  1025. 

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

  1027.     {

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

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

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

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

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

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

  1034.     }

  1035. 

  1036.     static bool shouldThrottleRepaint()

  1037.     {

  1038.         return areAnyWindowsInLiveResize();

  1039.     }

  1040. 

  1041.     void setNeedsDisplayRectangles()

  1042.     {

  1043.         if (deferredRepaints.isEmpty())

  1044.             return;

  1045. 

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

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

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

  1049. 

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

  1051. 

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

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

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

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

  1056.             return;

  1057. 

  1058.        #if USE_COREGRAPHICS_RENDERING && JUCE_COREGRAPHICS_RENDER_WITH_MULTIPLE_PAINT_CALLS

  1059.         // We require macOS 10.14 to use the Metal layer renderer

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

  1061.         {

  1062.             const auto& comp = getComponent();

  1063. 

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

  1065.             if (areAnyWindowsInLiveResize())

  1066.             {

  1067.                 if (metalRenderer != nullptr)

  1068.                 {

  1069.                     metalRenderer.reset();

  1070.                     view.wantsLayer = NO;

  1071.                     view.layer = nil;

  1072.                     deferredRepaints = comp.getLocalBounds().toFloat();

  1073.                 }

  1074.             }

  1075.             else

  1076.             {

  1077.                 if (metalRenderer == nullptr)

  1078.                 {

  1079.                     view.wantsLayer = YES;

  1080.                     view.layerContentsRedrawPolicy = NSViewLayerContentsRedrawDuringViewResize;

  1081.                     view.layerContentsPlacement = NSViewLayerContentsPlacementTopLeft;

  1082.                     view.layer = [CAMetalLayer layer];

  1083.                     metalRenderer = std::make_unique<CoreGraphicsMetalLayerRenderer> ((CAMetalLayer*) view.layer, getComponent());

  1084.                     deferredRepaints = comp.getLocalBounds().toFloat();

  1085.                 }

  1086.             }

  1087.         }

  1088.        #endif

  1089. 

  1090.         auto dispatchRectangles = [this] ()

  1091.         {

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

  1093.             {

  1094.                 if (metalRenderer != nullptr)

  1095.                 {

  1096.                     return metalRenderer->drawRectangleList ((CAMetalLayer*) view.layer,

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

  1098.                                                              view.frame,

  1099.                                                              getComponent(),

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

  1101.                                                              deferredRepaints);

  1102.                 }

  1103.             }

  1104. 

  1105.             for (auto& i : deferredRepaints)

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

  1107. 

  1108.             return true;

  1109.         };

  1110. 

  1111.         if (dispatchRectangles())

  1112.         {

  1113.             lastRepaintTime = Time::getMillisecondCounter();

  1114.             deferredRepaints.clear();

  1115.         }

  1116.     }

  1117. 

  1118.     void performAnyPendingRepaintsNow() override

  1119.     {

  1120.         [view displayIfNeeded];

  1121.     }

  1122. 

  1123.     static bool areAnyWindowsInLiveResize() noexcept

  1124.     {

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

  1126.             if ([w inLiveResize])

  1127.                 return true;

  1128. 

  1129.         return false;

  1130.     }

  1131. 

  1132.     //==============================================================================

  1133.     bool isBlockedByModalComponent()

  1134.     {

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

  1136.         {

  1137.             if (insideToFrontCall == 0

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

  1139.                  && getComponent().isCurrentlyBlockedByAnotherModalComponent())

  1140.             {

  1141.                 return true;

  1142.             }

  1143.         }

  1144. 

  1145.         return false;

  1146.     }

  1147. 

  1148.     enum class KeyWindowChanged { no, yes };

  1149. 

  1150.     void sendModalInputAttemptIfBlocked (KeyWindowChanged keyChanged)

  1151.     {

  1152.         if (! isBlockedByModalComponent())

  1153.             return;

  1154. 

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

  1156.         {

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

  1158.             {

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

  1160. 

  1161.                 if (! modalPeerIsTemporary)

  1162.                     return;

  1163. 

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

  1165.                 // component that is now key.

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

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

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

  1169. 

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

  1171.                     return;

  1172. 

  1173.                 modal->inputAttemptWhenModal();

  1174.             }

  1175.         }

  1176.     }

  1177. 

  1178.     bool canBecomeKeyWindow()

  1179.     {

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

  1181.     }

  1182. 

  1183.     bool canBecomeMainWindow()

  1184.     {

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

  1186.     }

  1187. 

  1188.     bool worksWhenModal() const

  1189.     {

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

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

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

  1193.         return ! JUCEApplication::isStandaloneApp();

  1194.     }

  1195. 

  1196.     void becomeKeyWindow()

  1197.     {

  1198.         handleBroughtToFront();

  1199.         grabFocus();

  1200.     }

  1201. 

  1202.     void resignKeyWindow()

  1203.     {

  1204.         viewFocusLoss();

  1205.     }

  1206. 

  1207.     bool windowShouldClose()

  1208.     {

  1209.         if (! isValidPeer (this))

  1210.             return YES;

  1211. 

  1212.         handleUserClosingWindow();

  1213.         return NO;

  1214.     }

  1215. 

  1216.     void redirectMovedOrResized()

  1217.     {

  1218.         handleMovedOrResized();

  1219.         setNeedsDisplayRectangles();

  1220.     }

  1221. 

  1222.     void windowDidChangeScreen()

  1223.     {

  1224.         updateCVDisplayLinkScreen();

  1225.     }

  1226. 

  1227.     void viewMovedToWindow()

  1228.     {

  1229.         if (isSharedWindow)

  1230.         {

  1231.             auto newWindow = [view window];

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

  1233. 

  1234.             window = newWindow;

  1235. 

  1236.             if (shouldSetVisible)

  1237.                 getComponent().setVisible (true);

  1238.         }

  1239. 

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

  1241.         {

  1242.             [notificationCenter addObserver: view

  1243.                                    selector: dismissModalsSelector

  1244.                                        name: NSWindowWillMoveNotification

  1245.                                      object: currentWindow];

  1246. 

  1247.             [notificationCenter addObserver: view

  1248.                                    selector: dismissModalsSelector

  1249.                                        name: NSWindowWillMiniaturizeNotification

  1250.                                      object: currentWindow];

  1251. 

  1252.             [notificationCenter addObserver: view

  1253.                                    selector: becomeKeySelector

  1254.                                        name: NSWindowDidBecomeKeyNotification

  1255.                                      object: currentWindow];

  1256. 

  1257.             [notificationCenter addObserver: view

  1258.                                    selector: resignKeySelector

  1259.                                        name: NSWindowDidResignKeyNotification

  1260.                                      object: currentWindow];

  1261. 

  1262.             [notificationCenter addObserver: view

  1263.                                    selector: @selector (windowDidChangeScreen:)

  1264.                                        name: NSWindowDidChangeScreenNotification

  1265.                                      object: currentWindow];

  1266. 

  1267.             updateCVDisplayLinkScreen();

  1268.         }

  1269.     }

  1270. 

  1271.     void dismissModals()

  1272.     {

  1273.         if (hasNativeTitleBar() || isSharedWindow)

  1274.             sendModalInputAttemptIfBlocked (KeyWindowChanged::no);

  1275.     }

  1276. 

  1277.     void becomeKey()

  1278.     {

  1279.         component.repaint();

  1280.     }

  1281. 

  1282.     void resignKey()

  1283.     {

  1284.         viewFocusLoss();

  1285.         sendModalInputAttemptIfBlocked (KeyWindowChanged::yes);

  1286.     }

  1287. 

  1288.     void liveResizingStart()

  1289.     {

  1290.         if (constrainer == nullptr)

  1291.             return;

  1292. 

  1293.         constrainer->resizeStart();

  1294.         isFirstLiveResize = true;

  1295. 

  1296.         setFullScreenSizeConstraints (*constrainer);

  1297.     }

  1298. 

  1299.     void liveResizingEnd()

  1300.     {

  1301.         if (constrainer != nullptr)

  1302.             constrainer->resizeEnd();

  1303.     }

  1304. 

  1305.     NSRect constrainRect (const NSRect r)

  1306.     {

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

  1308.             return r;

  1309. 

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

  1311. 

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

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

  1314. 

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

  1316. 

  1317.         const bool inLiveResize = [window inLiveResize];

  1318. 

  1319.         if (! inLiveResize || isFirstLiveResize)

  1320.         {

  1321.             isFirstLiveResize = false;

  1322. 

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

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

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

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

  1327.         }

  1328. 

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

  1330.                                   isStretchingTop, isStretchingLeft, isStretchingBottom, isStretchingRight);

  1331. 

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

  1333.     }

  1334. 

  1335.     static void showArrowCursorIfNeeded()

  1336.     {

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

  1338.         auto mouse = desktop.getMainMouseSource();

  1339. 

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

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

  1342.         {

  1343.             [[NSCursor arrowCursor] set];

  1344.         }

  1345.     }

  1346. 

  1347.     static void updateModifiers (NSEvent* e)

  1348.     {

  1349.         updateModifiers ([e modifierFlags]);

  1350.     }

  1351. 

  1352.     static void updateModifiers (const NSUInteger flags)

  1353.     {

  1354.         int m = 0;

  1355. 

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

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

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

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

  1360. 

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

  1362.     }

  1363. 

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

  1365.     {

  1366.         updateModifiers (ev);

  1367. 

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

  1369.         {

  1370.             if (isKeyDown)

  1371.                 keysCurrentlyDown.addIfNotAlreadyThere (keyCode);

  1372.             else

  1373.                 keysCurrentlyDown.removeFirstMatchingValue (keyCode);

  1374.         }

  1375.     }

  1376. 

  1377.     static int getKeyCodeFromEvent (NSEvent* ev)

  1378.     {

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

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

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

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

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

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

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

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

  1387.         // if the shift key was not pressed

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

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

  1390. 

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

  1392.             keyCode = '\t';

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

  1394.             keyCode = '\r';

  1395.         else

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

  1397. 

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

  1399.         // keyboard control over the application.

  1400.         //

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

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

  1403.         // non-printing ranges.

  1404.         if (keyCode > 0xff

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

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

  1407.         {

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

  1409.         }

  1410. 

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

  1412.         {

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

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

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

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

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

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

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

  1420.                                               '.', KeyPress::numberPadDecimalPoint,

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

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

  1423. 

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

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

  1426.                     keyCode = numPadConversions [i + 1];

  1427.         }

  1428. 

  1429.         return keyCode;

  1430.     }

  1431. 

  1432.     static int64 getMouseTime (NSEvent* e) noexcept

  1433.     {

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

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

  1436.     }

  1437. 

  1438.     static float getMousePressure (NSEvent* e) noexcept

  1439.     {

  1440.         @try

  1441.         {

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

  1443.                 return (float) e.pressure;

  1444.         }

  1445.         @catch (NSException* e) {}

  1446.         @finally {}

  1447. 

  1448.         return 0.0f;

  1449.     }

  1450. 

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

  1452.     {

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

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

  1455.     }

  1456. 

  1457.     static int getModifierForButtonNumber (const NSInteger num)

  1458.     {

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

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

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

  1462.     }

  1463. 

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

  1465.     {

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

  1467.                                                               : NSWindowStyleMaskBorderless;

  1468. 

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

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

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

  1472.         return style;

  1473.     }

  1474. 

  1475.     static NSArray* getSupportedDragTypes()

  1476.     {

  1477.         const auto type = []

  1478.         {

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

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

  1481.                 return NSPasteboardTypeFileURL;

  1482.            #endif

  1483. 

  1484.             JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wdeprecated-declarations")

  1485.             return (NSString*) kUTTypeFileURL;

  1486.             JUCE_END_IGNORE_WARNINGS_GCC_LIKE

  1487.         }();

  1488. 

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

  1490.     }

  1491. 

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

  1493.     {

  1494.         NSPasteboard* pasteboard = [sender draggingPasteboard];

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

  1496. 

  1497.         if (contentType == nil)

  1498.             return false;

  1499. 

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

  1501. 

  1502.         ComponentPeer::DragInfo dragInfo;

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

  1504. 

  1505.         if (contentType == NSPasteboardTypeString)

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

  1507.         else

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

  1509. 

  1510.         if (! dragInfo.isEmpty())

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

  1512. 

  1513.         return false;

  1514.     }

  1515. 

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

  1517.     {

  1518.         StringArray files;

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

  1520. 

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

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

  1523.         {

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

  1525. 

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

  1527.             {

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

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

  1530.                 NSEnumerator* enumerator = [tracks objectEnumerator];

  1531.                 NSDictionary* track;

  1532. 

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

  1534.                 {

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

  1536.                     {

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

  1538. 

  1539.                         if ([url isFileURL])

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

  1541.                     }

  1542.                 }

  1543.             }

  1544.         }

  1545.         else

  1546.         {

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

  1548. 

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

  1550.             {

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

  1552. 

  1553.                 if ([url isFileURL])

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

  1555.             }

  1556.         }

  1557. 

  1558.         return files;

  1559.     }

  1560. 

  1561.     //==============================================================================

  1562.     void viewFocusGain()

  1563.     {

  1564.         if (currentlyFocusedPeer != this)

  1565.         {

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

  1567.                 currentlyFocusedPeer->handleFocusLoss();

  1568. 

  1569.             currentlyFocusedPeer = this;

  1570.             handleFocusGain();

  1571.         }

  1572.     }

  1573. 

  1574.     void viewFocusLoss()

  1575.     {

  1576.         if (currentlyFocusedPeer == this)

  1577.         {

  1578.             currentlyFocusedPeer = nullptr;

  1579.             handleFocusLoss();

  1580.         }

  1581.     }

  1582. 

  1583.     bool isFocused() const override

  1584.     {

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

  1586.                     ? this == currentlyFocusedPeer

  1587.                     : [window isKeyWindow];

  1588.     }

  1589. 

  1590.     void grabFocus() override

  1591.     {

  1592.         if (window != nil)

  1593.         {

  1594.             [window makeKeyWindow];

  1595.             [window makeFirstResponder: view];

  1596. 

  1597.             viewFocusGain();

  1598.         }

  1599.     }

  1600. 

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

  1602. 

  1603.     void closeInputMethodContext() override

  1604.     {

  1605.         stringBeingComposed.clear();

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

  1607. 

  1608.         if (inputContext != nil)

  1609.             [inputContext discardMarkedText];

  1610.     }

  1611. 

  1612.     void resetWindowPresentation()

  1613.     {

  1614.         if (hasNativeTitleBar())

  1615.         {

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

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

  1618.         }

  1619. 

  1620.         [NSApp setPresentationOptions: NSApplicationPresentationDefault];

  1621.         setCollectionBehaviour (isFullScreen());

  1622.     }

  1623. 

  1624.     void setHasChangedSinceSaved (bool b) override

  1625.     {

  1626.         if (! isSharedWindow)

  1627.             [window setDocumentEdited: b];

  1628.     }

  1629. 

  1630.     //==============================================================================

  1631.     NSWindow* window = nil;

  1632.     NSView* view = nil;

  1633.     WeakReference<Component> safeComponent;

  1634.     bool isSharedWindow = false;

  1635.    #if USE_COREGRAPHICS_RENDERING

  1636.     bool usingCoreGraphics = true;

  1637.    #else

  1638.     bool usingCoreGraphics = false;

  1639.    #endif

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

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

  1642.     bool windowRepresentsFile = false;

  1643.     bool isAlwaysOnTop = false, wasAlwaysOnTop = false;

  1644.     String stringBeingComposed;

  1645.     NSNotificationCenter* notificationCenter = nil;

  1646. 

  1647.     Rectangle<float> lastSizeBeforeZoom;

  1648.     RectangleList<float> deferredRepaints;

  1649.     uint32 lastRepaintTime;

  1650. 

  1651.     static ComponentPeer* currentlyFocusedPeer;

  1652.     static Array<int> keysCurrentlyDown;

  1653.     static int insideToFrontCall;

  1654. 

  1655.     static const SEL dismissModalsSelector;

  1656.     static const SEL frameChangedSelector;

  1657.     static const SEL asyncMouseDownSelector;

  1658.     static const SEL asyncMouseUpSelector;

  1659.     static const SEL becomeKeySelector;

  1660.     static const SEL resignKeySelector;

  1661. 

  1662. private:

  1663.     static NSView* createViewInstance();

  1664.     static NSWindow* createWindowInstance();

  1665. 

  1666.     void sendMouseEnterExit (NSEvent* ev)

  1667.     {

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

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

  1670.                 return;

  1671. 

  1672.         sendMouseEvent (ev);

  1673.     }

  1674. 

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

  1676.     {

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

  1678.     }

  1679. 

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

  1681.     {

  1682.         const NSRect* rects = nullptr;

  1683.         NSInteger numRects = 0;

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

  1685. 

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

  1687. 

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

  1689. 

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

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

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

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

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

  1695.     }

  1696. 

  1697.     static void appFocusChanged()

  1698.     {

  1699.         keysCurrentlyDown.clear();

  1700. 

  1701.         if (isValidPeer (currentlyFocusedPeer))

  1702.         {

  1703.             if (Process::isForegroundProcess())

  1704.             {

  1705.                 currentlyFocusedPeer->handleFocusGain();

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

  1707.             }

  1708.             else

  1709.             {

  1710.                 currentlyFocusedPeer->handleFocusLoss();

  1711.             }

  1712.         }

  1713.     }

  1714. 

  1715.     static bool checkEventBlockedByModalComps (NSEvent* e)

  1716.     {

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

  1718.             return false;

  1719. 

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

  1721. 

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

  1723.             return false;

  1724. 

  1725.         bool isKey = false, isInputAttempt = false;

  1726. 

  1727.         switch ([e type])

  1728.         {

  1729.             case NSEventTypeKeyDown:

  1730.             case NSEventTypeKeyUp:

  1731.                 isKey = isInputAttempt = true;

  1732.                 break;

  1733. 

  1734.             case NSEventTypeLeftMouseDown:

  1735.             case NSEventTypeRightMouseDown:

  1736.             case NSEventTypeOtherMouseDown:

  1737.                 isInputAttempt = true;

  1738.                 break;

  1739. 

  1740.             case NSEventTypeLeftMouseDragged:

  1741.             case NSEventTypeRightMouseDragged:

  1742.             case NSEventTypeLeftMouseUp:

  1743.             case NSEventTypeRightMouseUp:

  1744.             case NSEventTypeOtherMouseUp:

  1745.             case NSEventTypeOtherMouseDragged:

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

  1747.                     return false;

  1748.                 break;

  1749. 

  1750.             case NSEventTypeMouseMoved:

  1751.             case NSEventTypeMouseEntered:

  1752.             case NSEventTypeMouseExited:

  1753.             case NSEventTypeCursorUpdate:

  1754.             case NSEventTypeScrollWheel:

  1755.             case NSEventTypeTabletPoint:

  1756.             case NSEventTypeTabletProximity:

  1757.                 break;

  1758. 

  1759.             case NSEventTypeFlagsChanged:

  1760.             case NSEventTypeAppKitDefined:

  1761.             case NSEventTypeSystemDefined:

  1762.             case NSEventTypeApplicationDefined:

  1763.             case NSEventTypePeriodic:

  1764.             case NSEventTypeGesture:

  1765.             case NSEventTypeMagnify:

  1766.             case NSEventTypeSwipe:

  1767.             case NSEventTypeRotate:

  1768.             case NSEventTypeBeginGesture:

  1769.             case NSEventTypeEndGesture:

  1770.             case NSEventTypeQuickLook:

  1771.            #if JUCE_64BIT

  1772.             case NSEventTypeSmartMagnify:

  1773.             case NSEventTypePressure:

  1774.            #endif

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

  1776.            #if JUCE_64BIT

  1777.             case NSEventTypeDirectTouch:

  1778.            #endif

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

  1780.             case NSEventTypeChangeMode:

  1781.            #endif

  1782.           #endif

  1783.             default:

  1784.                 return false;

  1785.         }

  1786. 

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

  1788.         {

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

  1790.             {

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

  1792.                 {

  1793.                     if (isKey)

  1794.                     {

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

  1796.                             return false;

  1797.                     }

  1798.                     else

  1799.                     {

  1800.                         if (peer->isSharedWindow

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

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

  1803.                             return false;

  1804.                     }

  1805.                 }

  1806.             }

  1807.         }

  1808. 

  1809.         if (isInputAttempt)

  1810.         {

  1811.             if (! [NSApp isActive])

  1812.                 [NSApp activateIgnoringOtherApps: YES];

  1813. 

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

  1815.                 modal->inputAttemptWhenModal();

  1816.         }

  1817. 

  1818.         return true;

  1819.     }

  1820. 

  1821.     void setFullScreenSizeConstraints (const ComponentBoundsConstrainer& c)

  1822.     {

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

  1824.         {

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

  1826.                                              0.0f);

  1827.             [window setMinFullScreenContentSize: minSize];

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

  1829.         }

  1830.     }

  1831. 

  1832.     //==============================================================================

  1833.     void onDisplaySourceCallback()

  1834.     {

  1835.         setNeedsDisplayRectangles();

  1836.     }

  1837. 

  1838.     void onDisplayLinkCallback()

  1839.     {

  1840.         dispatch_source_merge_data (displaySource, 1);

  1841.     }

  1842. 

  1843.     static CVReturn displayLinkCallback (CVDisplayLinkRef, const CVTimeStamp*, const CVTimeStamp*,

  1844.                                          CVOptionFlags, CVOptionFlags*, void* context)

  1845.     {

  1846.         static_cast<NSViewComponentPeer*> (context)->onDisplayLinkCallback();

  1847.         return kCVReturnSuccess;

  1848.     }

  1849. 

  1850.     void updateCVDisplayLinkScreen()

  1851.     {

  1852.         auto viewDisplayID = (CGDirectDisplayID) [[window.screen.deviceDescription objectForKey: @"NSScreenNumber"] unsignedIntegerValue];

  1853.         auto result = CVDisplayLinkSetCurrentCGDisplay (displayLink, viewDisplayID);

  1854.         jassertquiet (result == kCVReturnSuccess);

  1855.     }

  1856. 

  1857.     void createCVDisplayLink()

  1858.     {

  1859.         displaySource = dispatch_source_create (DISPATCH_SOURCE_TYPE_DATA_ADD, 0, 0, dispatch_get_main_queue());

  1860.         dispatch_source_set_event_handler (displaySource, ^(){ onDisplaySourceCallback(); });

  1861.         dispatch_resume (displaySource);

  1862. 

  1863.         auto cvReturn = CVDisplayLinkCreateWithActiveCGDisplays (&displayLink);

  1864.         jassertquiet (cvReturn == kCVReturnSuccess);

  1865. 

  1866.         cvReturn = CVDisplayLinkSetOutputCallback (displayLink, &displayLinkCallback, this);

  1867.         jassertquiet (cvReturn == kCVReturnSuccess);

  1868. 

  1869.         CVDisplayLinkStart (displayLink);

  1870.     }

  1871. 

  1872.     CVDisplayLinkRef displayLink = nullptr;

  1873.     dispatch_source_t displaySource = nullptr;

  1874. 

  1875.     std::unique_ptr<CoreGraphicsMetalLayerRenderer> metalRenderer;

  1876. 

  1877.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (NSViewComponentPeer)

  1878. };

  1879. 

  1880. int NSViewComponentPeer::insideToFrontCall = 0;

  1881. 

  1882. JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wundeclared-selector")

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

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

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

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

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

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

  1889. JUCE_END_IGNORE_WARNINGS_GCC_LIKE

  1890. 

  1891. //==============================================================================

  1892. template <typename Base>

  1893. struct NSViewComponentPeerWrapper  : public Base

  1894. {

  1895.     explicit NSViewComponentPeerWrapper (const char* baseName)

  1896.         : Base (baseName)

  1897.     {

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

  1899.     }

  1900. 

  1901.     static NSViewComponentPeer* getOwner (id self)

  1902.     {

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

  1904.     }

  1905. 

  1906.     static id getAccessibleChild (id self)

  1907.     {

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

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

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

  1911. 

  1912.         return nil;

  1913.     }

  1914. };

  1915. 

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

  1917. {

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

  1919.     {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1939.         addMethod (@selector (windowDidChangeScreen:),        windowDidChangeScreen);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1959. 

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

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

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

  1963. 

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

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

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

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

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

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

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

  1971. 

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

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

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

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

  1976. 

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

  1978. 

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

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

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

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

  1983. 

  1984.         // deprecated methods required for backwards compatibility

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

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

  1987. 

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

  1989. 

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

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

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

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

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

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

  1996. 

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

  1998. 

  1999.         addProtocol (@protocol (NSTextInput));

  2000. 

  2001.         registerClass();

  2002.     }

  2003. 

  2004. private:

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

  2006.     {

  2007.         if (JUCEApplicationBase::isStandaloneApp())

  2008.         {

  2009.             asyncMouseDown (self, s, ev);

  2010.         }

  2011.         else

  2012.         {

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

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

  2015.             // the event asynchronously..

  2016.             [self performSelectorOnMainThread: NSViewComponentPeer::asyncMouseDownSelector

  2017.                                    withObject: ev

  2018.                                 waitUntilDone: NO];

  2019.         }

  2020.     }

  2021. 

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

  2023.     {

  2024.         if (JUCEApplicationBase::isStandaloneApp())

  2025.         {

  2026.             asyncMouseUp (self, s, ev);

  2027.         }

  2028.         else

  2029.         {

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

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

  2032.             // the event asynchronously..

  2033.             [self performSelectorOnMainThread: NSViewComponentPeer::asyncMouseUpSelector

  2034.                                    withObject: ev

  2035.                                 waitUntilDone: NO];

  2036.         }

  2037.     }

  2038. 

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

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

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

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

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

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

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

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

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

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

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

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

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

  2052. 

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

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

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

  2056. 

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

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

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

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

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

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

  2063. 

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

  2065. 

  2066.     static void viewWillDraw (id self, SEL)

  2067.     {

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

  2069.         // to be the entire frame.

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

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

  2072.         {

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

  2074.             layer.contentsFormat = kCAContentsFormatRGBA8Uint;

  2075.         }

  2076.        #endif

  2077. 

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

  2079.     }

  2080. 

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

  2082.     {

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

  2084.         {

  2085.             if (p->isAlwaysOnTop)

  2086.             {

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

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

  2089.                 p->setAlwaysOnTop (false);

  2090.                 p->wasAlwaysOnTop = true;

  2091.             }

  2092.         }

  2093.     }

  2094. 

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

  2096.     {

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

  2098.         {

  2099.             if (p->wasAlwaysOnTop)

  2100.                 p->setAlwaysOnTop (true);

  2101. 

  2102.             p->redirectMovedOrResized();

  2103.         }

  2104.     }

  2105. 

  2106.     static void windowDidChangeScreen (id self, SEL, NSNotification*)

  2107.     {

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

  2109.             p->windowDidChangeScreen();

  2110.     }

  2111. 

  2112.     static BOOL isOpaque (id self, SEL)

  2113.     {

  2114.         auto* owner = getOwner (self);

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

  2116.     }

  2117. 

  2118.     //==============================================================================

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

  2120.     {

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

  2122.         {

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

  2124.             owner->textWasInserted = false;

  2125. 

  2126.             if (target != nullptr)

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

  2128.             else

  2129.                 owner->stringBeingComposed.clear();

  2130. 

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

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

  2133.         }

  2134.     }

  2135. 

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

  2137.     {

  2138.         auto* owner = getOwner (self);

  2139. 

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

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

  2142.     }

  2143. 

  2144.     //==============================================================================

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

  2146.     {

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

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

  2149.         {

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

  2151. 

  2152.             if ([newText length] > 0)

  2153.             {

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

  2155.                 {

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

  2157.                     owner->textWasInserted = true;

  2158.                 }

  2159.             }

  2160. 

  2161.             owner->stringBeingComposed.clear();

  2162.         }

  2163.     }

  2164. 

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

  2166. 

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

  2168.     {

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

  2170.         {

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

  2172.                                                            ? [aString string] : aString);

  2173. 

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

  2175.             {

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

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

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

  2179.                 owner->textWasInserted = true;

  2180.             }

  2181.         }

  2182.     }

  2183. 

  2184.     static void unmarkText (id self, SEL)

  2185.     {

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

  2187.         {

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

  2189.             {

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

  2191.                 {

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

  2193.                     owner->textWasInserted = true;

  2194.                 }

  2195. 

  2196.                 owner->stringBeingComposed.clear();

  2197.             }

  2198.         }

  2199.     }

  2200. 

  2201.     static BOOL hasMarkedText (id self, SEL)

  2202.     {

  2203.         auto* owner = getOwner (self);

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

  2205.     }

  2206. 

  2207.     static long conversationIdentifier (id self, SEL)

  2208.     {

  2209.         return (long) (pointer_sized_int) self;

  2210.     }

  2211. 

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

  2213.     {

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

  2215.         {

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

  2217.             {

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

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

  2220. 

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

  2222.             }

  2223.         }

  2224. 

  2225.         return nil;

  2226.     }

  2227. 

  2228.     static NSRange markedRange (id self, SEL)

  2229.     {

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

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

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

  2233. 

  2234.         return NSMakeRange (NSNotFound, 0);

  2235.     }

  2236. 

  2237.     static NSRange selectedRange (id self, SEL)

  2238.     {

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

  2240.         {

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

  2242.             {

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

  2244. 

  2245.                 if (! highlight.isEmpty())

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

  2247.                                         (NSUInteger) highlight.getLength());

  2248.             }

  2249.         }

  2250. 

  2251.         return NSMakeRange (NSNotFound, 0);

  2252.     }

  2253. 

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

  2255.     {

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

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

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

  2259. 

  2260.         return NSZeroRect;

  2261.     }

  2262. 

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

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

  2265. 

  2266.     //==============================================================================

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

  2268.     {

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

  2270.     }

  2271. 

  2272.     static BOOL becomeFirstResponder (id self, SEL)

  2273.     {

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

  2275.         return YES;

  2276.     }

  2277. 

  2278.     static BOOL resignFirstResponder (id self, SEL)

  2279.     {

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

  2281.         return YES;

  2282.     }

  2283. 

  2284.     static BOOL acceptsFirstResponder (id self, SEL)

  2285.     {

  2286.         auto* owner = getOwner (self);

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

  2288.     }

  2289. 

  2290.     //==============================================================================

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

  2292.     {

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

  2294.     }

  2295. 

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

  2297.     {

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

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

  2300.                 return NSDragOperationGeneric;

  2301. 

  2302.         return NSDragOperationNone;

  2303.     }

  2304. 

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

  2306.     {

  2307.         draggingExited (self, s, sender);

  2308.     }

  2309. 

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

  2311.     {

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

  2313.     }

  2314. 

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

  2316.     {

  2317.         return YES;

  2318.     }

  2319. 

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

  2321.     {

  2322.         auto* owner = getOwner (self);

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

  2324.     }

  2325. 

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

  2327. 

  2328.     //==============================================================================

  2329.     static BOOL getIsAccessibilityElement (id, SEL)

  2330.     {

  2331.         return NO;

  2332.     }

  2333. 

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

  2335.     {

  2336.         return NSAccessibilityUnignoredChildrenForOnlyChild (getAccessibleChild (self));

  2337.     }

  2338. 

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

  2340.     {

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

  2342.     }

  2343. 

  2344.     static id getAccessibilityFocusedUIElement (id self, SEL)

  2345.     {

  2346.         return [getAccessibleChild (self) accessibilityFocusedUIElement];

  2347.     }

  2348. 

  2349.     static BOOL getAccessibilityIsIgnored (id, SEL)

  2350.     {

  2351.         return YES;

  2352.     }

  2353. 

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

  2355.     {

  2356.         if ([attribute isEqualToString: NSAccessibilityChildrenAttribute])

  2357.             return getAccessibilityChildren (self, {});

  2358. 

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

  2360.     }

  2361. 

  2362.     static bool tryPassingKeyEventToPeer (NSEvent* e)

  2363.     {

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

  2365.             return false;

  2366. 

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

  2368.         {

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

  2370.             {

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

  2372.                                                       : peer->redirectKeyUp (e);

  2373.             }

  2374.         }

  2375. 

  2376.         return false;

  2377.     }

  2378. 

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

  2380.     {

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

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

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

  2384.         if (tryPassingKeyEventToPeer (event))

  2385.             return YES;

  2386. 

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

  2388.     }

  2389. 

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

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

  2392.     {

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

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

  2395.     }

  2396. };

  2397. 

  2398. //==============================================================================

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

  2400. {

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

  2402.     {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  2419. 

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

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

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

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

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

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

  2426. 

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

  2428. 

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

  2430. 

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

  2432. 

  2433.         addProtocol (@protocol (NSWindowDelegate));

  2434. 

  2435.         registerClass();

  2436.     }

  2437. 

  2438. private:

  2439.     //==============================================================================

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

  2441. 

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

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

  2444.     // to performKeyEquivalent.

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

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

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

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

  2449.     // that is on the desktop.

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

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

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

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

  2454.     // triggers an annoying NSBeep.

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

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

  2457.     {

  2458.         ignoreUnused (ev);

  2459. 

  2460.        #if JUCE_DEBUG_UNHANDLED_KEYPRESSES

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

  2462.        #endif

  2463.     }

  2464. 

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

  2466.     {

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

  2468.         {

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

  2470.             {

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

  2472.                 {

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

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

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

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

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

  2478. 

  2479.                     return flippedScreenRect (makeNSRect ([&]

  2480.                     {

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

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

  2483. 

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

  2485.                         return constrained;

  2486.                     }()));

  2487.                 }

  2488.             }

  2489.         }

  2490. 

  2491.         return r;

  2492.     }

  2493. 

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

  2495.     {

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

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

  2498.                 return NO;

  2499. 

  2500.         return YES;

  2501.     }

  2502. 

  2503.     static BOOL canBecomeKeyWindow (id self, SEL)

  2504.     {

  2505.         auto* owner = getOwner (self);

  2506. 

  2507.         return owner != nullptr

  2508.                 && owner->canBecomeKeyWindow()

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

  2510.     }

  2511. 

  2512.     static BOOL canBecomeMainWindow (id self, SEL)

  2513.     {

  2514.         auto* owner = getOwner (self);

  2515. 

  2516.         return owner != nullptr

  2517.                 && owner->canBecomeMainWindow()

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

  2519.     }

  2520. 

  2521.     static void becomeKeyWindow (id self, SEL)

  2522.     {

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

  2524. 

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

  2526.         {

  2527.             if (owner->canBecomeKeyWindow())

  2528.             {

  2529.                 owner->becomeKeyWindow();

  2530.                 return;

  2531.             }

  2532. 

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

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

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

  2536.         }

  2537.     }

  2538. 

  2539.     static void resignKeyWindow (id self, SEL)

  2540.     {

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

  2542. 

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

  2544.             owner->resignKeyWindow();

  2545.     }

  2546. 

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

  2548.     {

  2549.         auto* owner = getOwner (self);

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

  2551.     }

  2552. 

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

  2554.     {

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

  2556.         {

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

  2558.                                                                           frameRect, screen);

  2559. 

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

  2561.         }

  2562. 

  2563.         return frameRect;

  2564.     }

  2565. 

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

  2567.     {

  2568.         auto* owner = getOwner (self);

  2569. 

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

  2571.             return proposedFrameSize;

  2572. 

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

  2574.         frameRect.size = proposedFrameSize;

  2575. 

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

  2577. 

  2578.         owner->dismissModals();

  2579. 

  2580.         return frameRect.size;

  2581.     }

  2582. 

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

  2584.     {

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

  2586.         {

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

  2588. 

  2589.             if (! isFullScreen)

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

  2591. 

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

  2593. 

  2594.             if (isFullScreen)

  2595.             {

  2596.                 [NSApp setPresentationOptions: NSApplicationPresentationDefault];

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

  2598.             }

  2599.         }

  2600.     }

  2601. 

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

  2603.     {

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

  2605.             owner->resetWindowPresentation();

  2606.     }

  2607. 

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

  2609.     {

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

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

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

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

  2614.     }

  2615. 

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

  2617.     {

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

  2619.             return;

  2620. 

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

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

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

  2624.     }

  2625. 

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

  2627.     {

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

  2629.             owner->liveResizingStart();

  2630.     }

  2631. 

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

  2633.     {

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

  2635.             owner->liveResizingEnd();

  2636.     }

  2637. 

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

  2639.     {

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

  2641.             return owner->windowRepresentsFile;

  2642. 

  2643.         return false;

  2644.     }

  2645. 

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

  2647.     {

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

  2649.             return owner->windowRepresentsFile;

  2650. 

  2651.         return false;

  2652.     }

  2653. 

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

  2655.     {

  2656.         return [self title];

  2657.     }

  2658. 

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

  2660.     {

  2661.         return [getAccessibleChild (self) accessibilityLabel];

  2662.     }

  2663. 

  2664.     static id getAccessibilityWindow (id self, SEL)

  2665.     {

  2666.         return self;

  2667.     }

  2668. 

  2669.     static NSAccessibilityRole getAccessibilityRole (id, SEL)

  2670.     {

  2671.         return NSAccessibilityWindowRole;

  2672.     }

  2673. 

  2674.     static NSAccessibilityRole getAccessibilitySubrole (id self, SEL)

  2675.     {

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

  2677.             return [getAccessibleChild (self) accessibilitySubrole];

  2678. 

  2679.         return nil;

  2680.     }

  2681. };

  2682. 

  2683. NSView* NSViewComponentPeer::createViewInstance()

  2684. {

  2685.     static JuceNSViewClass cls;

  2686.     return cls.createInstance();

  2687. }

  2688. 

  2689. NSWindow* NSViewComponentPeer::createWindowInstance()

  2690. {

  2691.     static JuceNSWindowClass cls;

  2692.     return cls.createInstance();

  2693. }

  2694. 

  2695. 

  2696. //==============================================================================

  2697. ComponentPeer* NSViewComponentPeer::currentlyFocusedPeer = nullptr;

  2698. Array<int> NSViewComponentPeer::keysCurrentlyDown;

  2699. 

  2700. //==============================================================================

  2701. bool KeyPress::isKeyCurrentlyDown (int keyCode)

  2702. {

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

  2704.         return true;

  2705. 

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

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

  2708.         return true;

  2709. 

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

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

  2712.         return true;

  2713. 

  2714.     return false;

  2715. }

  2716. 

  2717. //==============================================================================

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

  2719. {

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

  2721.     {

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

  2723.         return true;

  2724.     }

  2725. 

  2726.     return false;

  2727. }

  2728. 

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

  2730. {

  2731.     return false;

  2732. }

  2733. 

  2734. //==============================================================================

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

  2736. {

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

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

  2739. 

  2740.     if (peer->hasNativeTitleBar())

  2741.     {

  2742.         if (shouldBeEnabled && ! allowMenusAndBars)

  2743.             [NSApp setPresentationOptions: NSApplicationPresentationHideDock | NSApplicationPresentationHideMenuBar];

  2744.         else if (! shouldBeEnabled)

  2745.             [NSApp setPresentationOptions: NSApplicationPresentationDefault];

  2746. 

  2747.         peer->setFullScreen (true);

  2748.     }

  2749.     else

  2750.     {

  2751.         if (shouldBeEnabled)

  2752.         {

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

  2754.                                                               : (NSApplicationPresentationHideDock | NSApplicationPresentationHideMenuBar))];

  2755. 

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

  2757.             peer->becomeKeyWindow();

  2758.         }

  2759.         else

  2760.         {

  2761.             peer->resetWindowPresentation();

  2762.         }

  2763.     }

  2764. }

  2765. 

  2766. void Desktop::allowedOrientationsChanged() {}

  2767. 

  2768. //==============================================================================

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

  2770. {

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

  2772. }

  2773. 

  2774. //==============================================================================

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

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

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

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

  2779. const int KeyPress::leftKey         = NSLeftArrowFunctionKey;

  2780. const int KeyPress::rightKey        = NSRightArrowFunctionKey;

  2781. const int KeyPress::upKey           = NSUpArrowFunctionKey;

  2782. const int KeyPress::downKey         = NSDownArrowFunctionKey;

  2783. const int KeyPress::pageUpKey       = NSPageUpFunctionKey;

  2784. const int KeyPress::pageDownKey     = NSPageDownFunctionKey;

  2785. const int KeyPress::endKey          = NSEndFunctionKey;

  2786. const int KeyPress::homeKey         = NSHomeFunctionKey;

  2787. const int KeyPress::deleteKey       = NSDeleteFunctionKey;

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

  2789. const int KeyPress::tabKey          = 9;

  2790. const int KeyPress::F1Key           = NSF1FunctionKey;

  2791. const int KeyPress::F2Key           = NSF2FunctionKey;

  2792. const int KeyPress::F3Key           = NSF3FunctionKey;

  2793. const int KeyPress::F4Key           = NSF4FunctionKey;

  2794. const int KeyPress::F5Key           = NSF5FunctionKey;

  2795. const int KeyPress::F6Key           = NSF6FunctionKey;

  2796. const int KeyPress::F7Key           = NSF7FunctionKey;

  2797. const int KeyPress::F8Key           = NSF8FunctionKey;

  2798. const int KeyPress::F9Key           = NSF9FunctionKey;

  2799. const int KeyPress::F10Key          = NSF10FunctionKey;

  2800. const int KeyPress::F11Key          = NSF11FunctionKey;

  2801. const int KeyPress::F12Key          = NSF12FunctionKey;

  2802. const int KeyPress::F13Key          = NSF13FunctionKey;

  2803. const int KeyPress::F14Key          = NSF14FunctionKey;

  2804. const int KeyPress::F15Key          = NSF15FunctionKey;

  2805. const int KeyPress::F16Key          = NSF16FunctionKey;

  2806. const int KeyPress::F17Key          = NSF17FunctionKey;

  2807. const int KeyPress::F18Key          = NSF18FunctionKey;

  2808. const int KeyPress::F19Key          = NSF19FunctionKey;

  2809. const int KeyPress::F20Key          = NSF20FunctionKey;

  2810. const int KeyPress::F21Key          = NSF21FunctionKey;

  2811. const int KeyPress::F22Key          = NSF22FunctionKey;

  2812. const int KeyPress::F23Key          = NSF23FunctionKey;

  2813. const int KeyPress::F24Key          = NSF24FunctionKey;

  2814. const int KeyPress::F25Key          = NSF25FunctionKey;

  2815. const int KeyPress::F26Key          = NSF26FunctionKey;

  2816. const int KeyPress::F27Key          = NSF27FunctionKey;

  2817. const int KeyPress::F28Key          = NSF28FunctionKey;

  2818. const int KeyPress::F29Key          = NSF29FunctionKey;

  2819. const int KeyPress::F30Key          = NSF30FunctionKey;

  2820. const int KeyPress::F31Key          = NSF31FunctionKey;

  2821. const int KeyPress::F32Key          = NSF32FunctionKey;

  2822. const int KeyPress::F33Key          = NSF33FunctionKey;

  2823. const int KeyPress::F34Key          = NSF34FunctionKey;

  2824. const int KeyPress::F35Key          = NSF35FunctionKey;

  2825. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  2848. 

  2849. } // namespace juce