falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
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.
6416 Commits
16 Branches
14GB
Tree: b8fa8f2faa
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b8fa8f2faa'
${ noResults }
Carla/source/modules/juce_gui_basics/native/juce_mac_NSViewComponentPee...

2861 lines
107KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE library.

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

  6. 

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

  8.    licensing.

  9. 

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

  11.    Agreement and JUCE Privacy Policy.

  12. 

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

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

  15. 

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

  17.    www.gnu.org/licenses).

  18. 

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

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

  21.    DISCLAIMED.

  22. 

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

  24. */

  25. 

  26. #include "juce_mac_CGMetalLayerRenderer.h"

  27. 

  28. @interface NSEvent (DeviceDelta)

  29. - (float)deviceDeltaX;

  30. - (float)deviceDeltaY;

  31. @end

  32. 

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

  34. namespace juce

  35. {

  36. 

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

  38. extern AppFocusChangeCallback appFocusChangeCallback;

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

  40. extern CheckEventBlockedByModalComps isEventBlockedByModalComps;

  41. 

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

  43. static constexpr int translateVirtualToAsciiKeyCode (int keyCode) noexcept

  44. {

  45.     switch (keyCode)

  46.     {

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

  48.         case 0x00: return 'A';

  49.         case 0x01: return 'S';

  50.         case 0x02: return 'D';

  51.         case 0x03: return 'F';

  52.         case 0x04: return 'H';

  53.         case 0x05: return 'G';

  54.         case 0x06: return 'Z';

  55.         case 0x07: return 'X';

  56.         case 0x08: return 'C';

  57.         case 0x09: return 'V';

  58.         case 0x0B: return 'B';

  59.         case 0x0C: return 'Q';

  60.         case 0x0D: return 'W';

  61.         case 0x0E: return 'E';

  62.         case 0x0F: return 'R';

  63.         case 0x10: return 'Y';

  64.         case 0x11: return 'T';

  65.         case 0x12: return '1';

  66.         case 0x13: return '2';

  67.         case 0x14: return '3';

  68.         case 0x15: return '4';

  69.         case 0x16: return '6';

  70.         case 0x17: return '5';

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

  72.         case 0x19: return '9';

  73.         case 0x1A: return '7';

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

  75.         case 0x1C: return '8';

  76.         case 0x1D: return '0';

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

  78.         case 0x1F: return 'O';

  79.         case 0x20: return 'U';

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

  81.         case 0x22: return 'I';

  82.         case 0x23: return 'P';

  83.         case 0x25: return 'L';

  84.         case 0x26: return 'J';

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

  86.         case 0x28: return 'K';

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

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

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

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

  91.         case 0x2D: return 'N';

  92.         case 0x2E: return 'M';

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

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

  95. 

  96.         default:   return keyCode;

  97.     }

  98. }

  99. 

  100. constexpr int extendedKeyModifier = 0x30000;

  101. 

  102. //==============================================================================

  103. class NSViewComponentPeer  : public ComponentPeer

  104. {

  105. public:

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

  107.         : ComponentPeer (comp, windowStyleFlags),

  108.           safeComponent (&comp),

  109.           isSharedWindow (viewToAttachTo != nil),

  110.           lastRepaintTime (Time::getMillisecondCounter())

  111.     {

  112.         appFocusChangeCallback = appFocusChanged;

  113.         isEventBlockedByModalComps = checkEventBlockedByModalComps;

  114. 

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

  116. 

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

  118.         setOwner (view, this);

  119. 

  120.         [view registerForDraggedTypes: getSupportedDragTypes()];

  121. 

  122.         const auto options = NSTrackingMouseEnteredAndExited

  123.                            | NSTrackingMouseMoved

  124.                            | NSTrackingEnabledDuringMouseDrag

  125.                            | NSTrackingActiveAlways

  126.                            | NSTrackingInVisibleRect;

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

  128.                                                                                       options: options

  129.                                                                                         owner: view

  130.                                                                                      userInfo: nil] };

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

  132. 

  133.         notificationCenter = [NSNotificationCenter defaultCenter];

  134. 

  135.         [notificationCenter  addObserver: view

  136.                                 selector: frameChangedSelector

  137.                                     name: NSViewFrameDidChangeNotification

  138.                                   object: view];

  139. 

  140.         [view setPostsFrameChangedNotifications: YES];

  141. 

  142.        #if USE_COREGRAPHICS_RENDERING

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

  144.         {

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

  146.             {

  147.                 [view setWantsLayer: YES];

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

  149.             }

  150.         }

  151.        #endif

  152. 

  153.         createCVDisplayLink();

  154. 

  155.         if (isSharedWindow)

  156.         {

  157.             window = [viewToAttachTo window];

  158.             [viewToAttachTo addSubview: view];

  159.         }

  160.         else

  161.         {

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

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

  164.             r = flippedScreenRect (r);

  165. 

  166.             window = [createWindowInstance() initWithContentRect: r

  167.                                                        styleMask: getNSWindowStyleMask (windowStyleFlags)

  168.                                                          backing: NSBackingStoreBuffered

  169.                                                            defer: YES];

  170.             setOwner (window, this);

  171. 

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

  173.                 [window setAccessibilityElement: YES];

  174. 

  175.             [window orderOut: nil];

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

  177. 

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

  179. 

  180.             if (! [window isOpaque])

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

  182. 

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

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

  185. 

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

  187. 

  188.             if (component.isAlwaysOnTop())

  189.                 setAlwaysOnTop (true);

  190. 

  191.             [window setContentView: view];

  192. 

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

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

  195.             [window setReleasedWhenClosed: YES];

  196.             [window retain];

  197. 

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

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

  200. 

  201.             setCollectionBehaviour (false);

  202. 

  203.             [window setRestorable: NO];

  204. 

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

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

  207.                 [window setTabbingMode: NSWindowTabbingModeDisallowed];

  208.            #endif

  209. 

  210.             [notificationCenter  addObserver: view

  211.                                     selector: frameChangedSelector

  212.                                         name: NSWindowDidMoveNotification

  213.                                       object: window];

  214. 

  215.             [notificationCenter  addObserver: view

  216.                                     selector: frameChangedSelector

  217.                                         name: NSWindowDidMiniaturizeNotification

  218.                                       object: window];

  219. 

  220.             [notificationCenter  addObserver: view

  221.                                     selector: @selector (windowWillMiniaturize:)

  222.                                         name: NSWindowWillMiniaturizeNotification

  223.                                       object: window];

  224. 

  225.             [notificationCenter  addObserver: view

  226.                                     selector: @selector (windowDidDeminiaturize:)

  227.                                         name: NSWindowDidDeminiaturizeNotification

  228.                                       object: window];

  229.         }

  230. 

  231.         auto alpha = component.getAlpha();

  232. 

  233.         if (alpha < 1.0f)

  234.             setAlpha (alpha);

  235. 

  236.         setTitle (component.getName());

  237. 

  238.         getNativeRealtimeModifiers = []

  239.         {

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

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

  242. 

  243.             return ModifierKeys::currentModifiers;

  244.         };

  245.     }

  246. 

  247.     ~NSViewComponentPeer() override

  248.     {

  249.         CVDisplayLinkStop (displayLink);

  250.         dispatch_source_cancel (displaySource);

  251. 

  252.         [notificationCenter removeObserver: view];

  253.         setOwner (view, nullptr);

  254. 

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

  256.         {

  257.             redirectWillMoveToWindow (nullptr);

  258.             [view removeFromSuperview];

  259.         }

  260. 

  261.         if (! isSharedWindow)

  262.         {

  263.             setOwner (window, nullptr);

  264.             [window setContentView: nil];

  265.             [window close];

  266.             [window release];

  267.         }

  268. 

  269.         [view release];

  270.     }

  271. 

  272.     //==============================================================================

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

  274. 

  275.     void setVisible (bool shouldBeVisible) override

  276.     {

  277.         if (isSharedWindow)

  278.         {

  279.             if (shouldBeVisible)

  280.                 [view setHidden: false];

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

  282.                 [view setHidden: true];

  283.         }

  284.         else

  285.         {

  286.             if (shouldBeVisible)

  287.             {

  288.                 ++insideToFrontCall;

  289.                 [window orderFront: nil];

  290.                 --insideToFrontCall;

  291.                 handleBroughtToFront();

  292.             }

  293.             else

  294.             {

  295.                 [window orderOut: nil];

  296.             }

  297.         }

  298.     }

  299. 

  300.     void setTitle (const String& title) override

  301.     {

  302.         JUCE_AUTORELEASEPOOL

  303.         {

  304.             if (! isSharedWindow)

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

  306.         }

  307.     }

  308. 

  309.     bool setDocumentEditedStatus (bool edited) override

  310.     {

  311.         if (! hasNativeTitleBar())

  312.             return false;

  313. 

  314.         [window setDocumentEdited: edited];

  315.         return true;

  316.     }

  317. 

  318.     void setRepresentedFile (const File& file) override

  319.     {

  320.         if (! isSharedWindow)

  321.         {

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

  323.                                                                 ? file.getFullPathName()

  324.                                                                 : String())];

  325. 

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

  327.         }

  328.     }

  329. 

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

  331.     {

  332.         auto r = makeNSRect (newBounds);

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

  334. 

  335.         if (isSharedWindow)

  336.         {

  337.             [view setFrame: r];

  338.         }

  339.         else

  340.         {

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

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

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

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

  345. 

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

  347.                      display: isPre10_11];

  348.         }

  349. 

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

  351.             [view setNeedsDisplay: true];

  352.     }

  353. 

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

  355.     {

  356.         auto r = [view frame];

  357.         NSWindow* viewWindow = [view window];

  358. 

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

  360.         {

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

  362.             r = [viewWindow convertRectToScreen: r];

  363. 

  364.             r = flippedScreenRect (r);

  365.         }

  366. 

  367.         return convertToRectInt (r);

  368.     }

  369. 

  370.     Rectangle<int> getBounds() const override

  371.     {

  372.         return getBounds (! isSharedWindow);

  373.     }

  374. 

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

  376.     {

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

  378.     }

  379. 

  380.     using ComponentPeer::localToGlobal;

  381. 

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

  383.     {

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

  385.     }

  386. 

  387.     using ComponentPeer::globalToLocal;

  388. 

  389.     void setAlpha (float newAlpha) override

  390.     {

  391.         if (isSharedWindow)

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

  393.         else

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

  395.     }

  396. 

  397.     void setMinimised (bool shouldBeMinimised) override

  398.     {

  399.         if (! isSharedWindow)

  400.         {

  401.             if (shouldBeMinimised)

  402.                 [window miniaturize: nil];

  403.             else

  404.                 [window deminiaturize: nil];

  405.         }

  406.     }

  407. 

  408.     bool isMinimised() const override

  409.     {

  410.         return [window isMiniaturized];

  411.     }

  412. 

  413.     NSWindowCollectionBehavior getCollectionBehavior (bool forceFullScreen) const

  414.     {

  415.         if (forceFullScreen)

  416.             return NSWindowCollectionBehaviorFullScreenPrimary;

  417. 

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

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

  420. 

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

  422.              ? NSWindowCollectionBehaviorFullScreenPrimary

  423.              : fullScreenNone;

  424.     }

  425. 

  426.     void setCollectionBehaviour (bool forceFullScreen) const

  427.     {

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

  429.     }

  430. 

  431.     void setFullScreen (bool shouldBeFullScreen) override

  432.     {

  433.         if (isSharedWindow)

  434.             return;

  435. 

  436.         if (shouldBeFullScreen)

  437.             setCollectionBehaviour (true);

  438. 

  439.         if (isMinimised())

  440.             setMinimised (false);

  441. 

  442.         if (shouldBeFullScreen != isFullScreen())

  443.             [window toggleFullScreen: nil];

  444.     }

  445. 

  446.     bool isFullScreen() const override

  447.     {

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

  449.     }

  450. 

  451.     bool isKioskMode() const override

  452.     {

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

  454.     }

  455. 

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

  457.     {

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

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

  460. 

  461.         return true;

  462.     }

  463. 

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

  465.     {

  466.         NSRect viewFrame = [view frame];

  467. 

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

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

  470.             return false;

  471. 

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

  473.         {

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

  475.             {

  476.                 NSRect windowFrame = [viewWindow frame];

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

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

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

  480. 

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

  482.                     return false;

  483. 

  484.             }

  485.         }

  486. 

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

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

  489. 

  490.         return trueIfInAChildWindow ? (v != nil)

  491.                                     : (v == view);

  492.     }

  493. 

  494.     OptionalBorderSize getFrameSizeIfPresent() const override

  495.     {

  496.         if (! isSharedWindow)

  497.         {

  498.             BorderSize<int> b;

  499. 

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

  501.             NSRect w = [window frame];

  502. 

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

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

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

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

  507. 

  508.             return OptionalBorderSize { b };

  509.         }

  510. 

  511.         return {};

  512.     }

  513. 

  514.     BorderSize<int> getFrameSize() const override

  515.     {

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

  517.             return *frameSize;

  518. 

  519.         return {};

  520.     }

  521. 

  522.     bool hasNativeTitleBar() const

  523.     {

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

  525.     }

  526. 

  527.     bool setAlwaysOnTop (bool alwaysOnTop) override

  528.     {

  529.         if (! isSharedWindow)

  530.         {

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

  532.                                                                                         : NSFloatingWindowLevel)

  533.                                           : NSNormalWindowLevel];

  534. 

  535.             isAlwaysOnTop = alwaysOnTop;

  536.         }

  537. 

  538.         return true;

  539.     }

  540. 

  541.     void toFront (bool makeActiveWindow) override

  542.     {

  543.         if (isSharedWindow)

  544.         {

  545.             NSView* superview = [view superview];

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

  547. 

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

  549. 

  550.             if (! isFrontmost)

  551.             {

  552.                 [view retain];

  553.                 [subviews removeObject: view];

  554.                 [subviews addObject: view];

  555. 

  556.                 [superview setSubviews: subviews];

  557.                 [view release];

  558.             }

  559.         }

  560. 

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

  562.         {

  563.             ++insideToFrontCall;

  564. 

  565.             if (makeActiveWindow)

  566.                 [window makeKeyAndOrderFront: nil];

  567.             else

  568.                 [window orderFront: nil];

  569. 

  570.             if (insideToFrontCall <= 1)

  571.             {

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

  573.                 handleBroughtToFront();

  574.             }

  575. 

  576.             --insideToFrontCall;

  577.         }

  578.     }

  579. 

  580.     void toBehind (ComponentPeer* other) override

  581.     {

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

  583.         {

  584.             if (isSharedWindow)

  585.             {

  586.                 NSView* superview = [view superview];

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

  588. 

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

  590. 

  591.                 if (otherViewIndex == NSNotFound)

  592.                     return;

  593. 

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

  595. 

  596.                 if (! isBehind)

  597.                 {

  598.                     [view retain];

  599.                     [subviews removeObject: view];

  600.                     [subviews insertObject: view

  601.                                    atIndex: otherViewIndex];

  602. 

  603.                     [superview setSubviews: subviews];

  604.                     [view release];

  605.                 }

  606.             }

  607.             else if (component.isVisible())

  608.             {

  609.                 [window orderWindow: NSWindowBelow

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

  611.             }

  612.         }

  613.         else

  614.         {

  615.             jassertfalse; // wrong type of window?

  616.         }

  617.     }

  618. 

  619.     void setIcon (const Image& newIcon) override

  620.     {

  621.         if (! isSharedWindow)

  622.         {

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

  624.             if (! windowRepresentsFile)

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

  626. 

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

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

  629.         }

  630.     }

  631. 

  632.     StringArray getAvailableRenderingEngines() override

  633.     {

  634.         StringArray s ("Software Renderer");

  635. 

  636.        #if USE_COREGRAPHICS_RENDERING

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

  638.        #endif

  639. 

  640.         return s;

  641.     }

  642. 

  643.     int getCurrentRenderingEngine() const override

  644.     {

  645.         return usingCoreGraphics ? 1 : 0;

  646.     }

  647. 

  648.     void setCurrentRenderingEngine (int index) override

  649.     {

  650.        #if USE_COREGRAPHICS_RENDERING

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

  652.         {

  653.             usingCoreGraphics = index > 0;

  654.             [view setNeedsDisplay: true];

  655.         }

  656.        #else

  657.         ignoreUnused (index);

  658.        #endif

  659.     }

  660. 

  661.     void redirectMouseDown (NSEvent* ev)

  662.     {

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

  664.             Process::makeForegroundProcess();

  665. 

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

  667.         sendMouseEvent (ev);

  668.     }

  669. 

  670.     void redirectMouseUp (NSEvent* ev)

  671.     {

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

  673.         sendMouseEvent (ev);

  674.         showArrowCursorIfNeeded();

  675.     }

  676. 

  677.     void redirectMouseDrag (NSEvent* ev)

  678.     {

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

  680.         sendMouseEvent (ev);

  681.     }

  682. 

  683.     void redirectMouseMove (NSEvent* ev)

  684.     {

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

  686. 

  687.         NSPoint windowPos = [ev locationInWindow];

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

  689. 

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

  691.             sendMouseEvent (ev);

  692.         else

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

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

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

  696. 

  697.         showArrowCursorIfNeeded();

  698.     }

  699. 

  700.     void redirectMouseEnter (NSEvent* ev)

  701.     {

  702.         sendMouseEnterExit (ev);

  703.     }

  704. 

  705.     void redirectMouseExit (NSEvent* ev)

  706.     {

  707.         sendMouseEnterExit (ev);

  708.     }

  709. 

  710.     static float checkDeviceDeltaReturnValue (float v) noexcept

  711.     {

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

  713.         v *= 0.5f / 256.0f;

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

  715.     }

  716. 

  717.     void redirectMouseWheel (NSEvent* ev)

  718.     {

  719.         updateModifiers (ev);

  720. 

  721.         MouseWheelDetails wheel;

  722.         wheel.deltaX = 0;

  723.         wheel.deltaY = 0;

  724.         wheel.isReversed = false;

  725.         wheel.isSmooth = false;

  726.         wheel.isInertial = false;

  727. 

  728.         @try

  729.         {

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

  731.                 wheel.isReversed = [ev isDirectionInvertedFromDevice];

  732. 

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

  734. 

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

  736.             {

  737.                 if ([ev hasPreciseScrollingDeltas])

  738.                 {

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

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

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

  742.                     wheel.isSmooth = true;

  743.                 }

  744.             }

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

  746.             {

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

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

  749.             }

  750.         }

  751.         @catch (...)

  752.         {}

  753. 

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

  755.         {

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

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

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

  759.         }

  760. 

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

  762.     }

  763. 

  764.     void redirectMagnify (NSEvent* ev)

  765.     {

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

  767. 

  768.         if (invScale > 0.0f)

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

  770.     }

  771. 

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

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

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

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

  776. 

  777.     void redirectWillMoveToWindow (NSWindow* newWindow)

  778.     {

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

  780.         {

  781.             [notificationCenter removeObserver: view

  782.                                           name: NSWindowDidMoveNotification

  783.                                         object: currentWindow];

  784. 

  785.             [notificationCenter removeObserver: view

  786.                                           name: NSWindowWillMiniaturizeNotification

  787.                                         object: currentWindow];

  788. 

  789.             [notificationCenter removeObserver: view

  790.                                           name: NSWindowDidBecomeKeyNotification

  791.                                         object: currentWindow];

  792. 

  793.             [notificationCenter removeObserver: view

  794.                                           name: NSWindowDidChangeScreenNotification

  795.                                         object: currentWindow];

  796.         }

  797. 

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

  799.         {

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

  801.                 comp->setVisible (false);

  802.         }

  803.     }

  804. 

  805.     void sendMouseEvent (NSEvent* ev)

  806.     {

  807.         updateModifiers (ev);

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

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

  810.     }

  811. 

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

  813.     {

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

  815.         auto keyCode = getKeyCodeFromEvent (ev);

  816. 

  817.        #if JUCE_DEBUG_KEYCODES

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

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

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

  821.        #endif

  822. 

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

  824.         {

  825.             if (isKeyDown)

  826.             {

  827.                 bool used = false;

  828. 

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

  830.                 {

  831.                     auto textCharacter = u.getAndAdvance();

  832. 

  833.                     switch (keyCode)

  834.                     {

  835.                         case NSLeftArrowFunctionKey:

  836.                         case NSRightArrowFunctionKey:

  837.                         case NSUpArrowFunctionKey:

  838.                         case NSDownArrowFunctionKey:

  839.                         case NSPageUpFunctionKey:

  840.                         case NSPageDownFunctionKey:

  841.                         case NSEndFunctionKey:

  842.                         case NSHomeFunctionKey:

  843.                         case NSDeleteFunctionKey:

  844.                             textCharacter = 0;

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

  846. 

  847.                         default:

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

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

  850.                                 textCharacter = 0;

  851.                             break;

  852.                     }

  853. 

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

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

  856.                 }

  857. 

  858.                 return used;

  859.             }

  860. 

  861.             if (handleKeyUpOrDown (false))

  862.                 return true;

  863.         }

  864. 

  865.         return false;

  866.     }

  867. 

  868.     bool redirectKeyDown (NSEvent* ev)

  869.     {

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

  871.         // our event object gets lost)

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

  873. 

  874.         updateKeysDown (ev, true);

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

  876. 

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

  878.         {

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

  880.             updateKeysDown (ev, false);

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

  882.         }

  883. 

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

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

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

  887.             used = true;

  888. 

  889.         return used;

  890.     }

  891. 

  892.     bool redirectKeyUp (NSEvent* ev)

  893.     {

  894.         updateKeysDown (ev, false);

  895.         return handleKeyEvent (ev, false)

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

  897.     }

  898. 

  899.     void redirectModKeyChange (NSEvent* ev)

  900.     {

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

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

  903. 

  904.         keysCurrentlyDown.clear();

  905.         handleKeyUpOrDown (true);

  906. 

  907.         updateModifiers (ev);

  908.         handleModifierKeysChange();

  909.     }

  910. 

  911.     //==============================================================================

  912.     void drawRect (NSRect r)

  913.     {

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

  915.             return;

  916. 

  917.         auto cg = []

  918.         {

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

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

  921. 

  922.             JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wdeprecated-declarations")

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

  924.             JUCE_END_IGNORE_WARNINGS_GCC_LIKE

  925.         }();

  926. 

  927.         drawRectWithContext (cg, r);

  928.     }

  929. 

  930.     void drawRectWithContext (CGContextRef cg, NSRect r)

  931.     {

  932.         if (! component.isOpaque())

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

  934. 

  935.         float displayScale = 1.0f;

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

  937. 

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

  939.             displayScale = (float) screen.backingScaleFactor;

  940. 

  941.         auto invalidateTransparentWindowShadow = [this]

  942.         {

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

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

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

  946.                 [window invalidateShadow];

  947.         };

  948. 

  949.        #if USE_COREGRAPHICS_RENDERING && JUCE_COREGRAPHICS_RENDER_WITH_MULTIPLE_PAINT_CALLS

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

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

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

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

  954.         // to avoid CoreGraphics consolidating disparate rects.

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

  956.         {

  957.             const NSRect* rects = nullptr;

  958.             NSInteger numRects = 0;

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

  960. 

  961.             if (numRects > 1)

  962.             {

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

  964.                 {

  965.                     NSRect rect = rects[i];

  966.                     CGContextSaveGState (cg);

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

  968.                     renderRect (cg, rect, displayScale);

  969.                     CGContextRestoreGState (cg);

  970.                 }

  971. 

  972.                 invalidateTransparentWindowShadow();

  973.                 return;

  974.             }

  975.         }

  976.        #endif

  977. 

  978.         renderRect (cg, r, displayScale);

  979.         invalidateTransparentWindowShadow();

  980.     }

  981. 

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

  983.     {

  984.        #if USE_COREGRAPHICS_RENDERING

  985.         if (usingCoreGraphics)

  986.         {

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

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

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

  990.             handlePaint (context);

  991.         }

  992.         else

  993.        #endif

  994.         {

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

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

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

  998. 

  999.             RectangleList<int> clip;

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

  1001. 

  1002.             if (! clip.isEmpty())

  1003.             {

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

  1005.                             roundToInt (clipW * displayScale),

  1006.                             roundToInt (clipH * displayScale),

  1007.                             ! component.isOpaque());

  1008. 

  1009.                 {

  1010.                     auto intScale = roundToInt (displayScale);

  1011. 

  1012.                     if (intScale != 1)

  1013.                         clip.scaleAll (intScale);

  1014. 

  1015.                     auto context = component.getLookAndFeel()

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

  1017. 

  1018.                     if (intScale != 1)

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

  1020. 

  1021.                     handlePaint (*context);

  1022.                 }

  1023. 

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

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

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

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

  1028.                 CGImageRelease (image);

  1029.             }

  1030.         }

  1031.     }

  1032. 

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

  1034.     {

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

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

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

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

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

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

  1041.     }

  1042. 

  1043.     static bool shouldThrottleRepaint()

  1044.     {

  1045.         return areAnyWindowsInLiveResize();

  1046.     }

  1047. 

  1048.     void setNeedsDisplayRectangles()

  1049.     {

  1050.         if (deferredRepaints.isEmpty())

  1051.             return;

  1052. 

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

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

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

  1056. 

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

  1058. 

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

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

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

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

  1063.             return;

  1064. 

  1065.        #if USE_COREGRAPHICS_RENDERING && JUCE_COREGRAPHICS_RENDER_WITH_MULTIPLE_PAINT_CALLS

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

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

  1068.         {

  1069.             const auto& comp = getComponent();

  1070. 

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

  1072.             if (areAnyWindowsInLiveResize())

  1073.             {

  1074.                 if (metalRenderer != nullptr)

  1075.                 {

  1076.                     metalRenderer.reset();

  1077.                     view.wantsLayer = NO;

  1078.                     view.layer = nil;

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

  1080.                 }

  1081.             }

  1082.             else

  1083.             {

  1084.                 if (metalRenderer == nullptr)

  1085.                 {

  1086.                     view.wantsLayer = YES;

  1087.                     view.layerContentsRedrawPolicy = NSViewLayerContentsRedrawDuringViewResize;

  1088.                     view.layerContentsPlacement = NSViewLayerContentsPlacementTopLeft;

  1089.                     view.layer = [CAMetalLayer layer];

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

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

  1092.                 }

  1093.             }

  1094.         }

  1095.        #endif

  1096. 

  1097.         auto dispatchRectangles = [this] ()

  1098.         {

  1099.            #if USE_COREGRAPHICS_RENDERING

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

  1101.             {

  1102.                 if (metalRenderer != nullptr)

  1103.                 {

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

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

  1106.                                                              view.frame,

  1107.                                                              getComponent(),

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

  1109.                                                              deferredRepaints);

  1110.                 }

  1111.             }

  1112.            #endif

  1113. 

  1114.             for (auto& i : deferredRepaints)

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

  1116. 

  1117.             return true;

  1118.         };

  1119. 

  1120.         if (dispatchRectangles())

  1121.         {

  1122.             lastRepaintTime = Time::getMillisecondCounter();

  1123.             deferredRepaints.clear();

  1124.         }

  1125.     }

  1126. 

  1127.     void performAnyPendingRepaintsNow() override

  1128.     {

  1129.         [view displayIfNeeded];

  1130.     }

  1131. 

  1132.     static bool areAnyWindowsInLiveResize() noexcept

  1133.     {

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

  1135.             if ([w inLiveResize])

  1136.                 return true;

  1137. 

  1138.         return false;

  1139.     }

  1140. 

  1141.     //==============================================================================

  1142.     bool isBlockedByModalComponent()

  1143.     {

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

  1145.         {

  1146.             if (insideToFrontCall == 0

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

  1148.                  && getComponent().isCurrentlyBlockedByAnotherModalComponent())

  1149.             {

  1150.                 return true;

  1151.             }

  1152.         }

  1153. 

  1154.         return false;

  1155.     }

  1156. 

  1157.     enum class KeyWindowChanged { no, yes };

  1158. 

  1159.     void sendModalInputAttemptIfBlocked (KeyWindowChanged keyChanged)

  1160.     {

  1161.         if (! isBlockedByModalComponent())

  1162.             return;

  1163. 

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

  1165.         {

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

  1167.             {

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

  1169. 

  1170.                 if (! modalPeerIsTemporary)

  1171.                     return;

  1172. 

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

  1174.                 // component that is now key.

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

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

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

  1178. 

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

  1180.                     return;

  1181. 

  1182.                 modal->inputAttemptWhenModal();

  1183.             }

  1184.         }

  1185.     }

  1186. 

  1187.     bool canBecomeKeyWindow()

  1188.     {

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

  1190.     }

  1191. 

  1192.     bool canBecomeMainWindow()

  1193.     {

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

  1195.     }

  1196. 

  1197.     bool worksWhenModal() const

  1198.     {

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

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

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

  1202.         return ! JUCEApplication::isStandaloneApp();

  1203.     }

  1204. 

  1205.     void becomeKeyWindow()

  1206.     {

  1207.         handleBroughtToFront();

  1208.         grabFocus();

  1209.     }

  1210. 

  1211.     void resignKeyWindow()

  1212.     {

  1213.         viewFocusLoss();

  1214.     }

  1215. 

  1216.     bool windowShouldClose()

  1217.     {

  1218.         if (! isValidPeer (this))

  1219.             return YES;

  1220. 

  1221.         handleUserClosingWindow();

  1222.         return NO;

  1223.     }

  1224. 

  1225.     void redirectMovedOrResized()

  1226.     {

  1227.         handleMovedOrResized();

  1228.         setNeedsDisplayRectangles();

  1229.     }

  1230. 

  1231.     void windowDidChangeScreen()

  1232.     {

  1233.         updateCVDisplayLinkScreen();

  1234.     }

  1235. 

  1236.     void viewMovedToWindow()

  1237.     {

  1238.         if (isSharedWindow)

  1239.         {

  1240.             auto newWindow = [view window];

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

  1242. 

  1243.             window = newWindow;

  1244. 

  1245.             if (shouldSetVisible)

  1246.                 getComponent().setVisible (true);

  1247.         }

  1248. 

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

  1250.         {

  1251.             [notificationCenter addObserver: view

  1252.                                    selector: dismissModalsSelector

  1253.                                        name: NSWindowWillMoveNotification

  1254.                                      object: currentWindow];

  1255. 

  1256.             [notificationCenter addObserver: view

  1257.                                    selector: dismissModalsSelector

  1258.                                        name: NSWindowWillMiniaturizeNotification

  1259.                                      object: currentWindow];

  1260. 

  1261.             [notificationCenter addObserver: view

  1262.                                    selector: becomeKeySelector

  1263.                                        name: NSWindowDidBecomeKeyNotification

  1264.                                      object: currentWindow];

  1265. 

  1266.             [notificationCenter addObserver: view

  1267.                                    selector: resignKeySelector

  1268.                                        name: NSWindowDidResignKeyNotification

  1269.                                      object: currentWindow];

  1270. 

  1271.             [notificationCenter addObserver: view

  1272.                                    selector: @selector (windowDidChangeScreen:)

  1273.                                        name: NSWindowDidChangeScreenNotification

  1274.                                      object: currentWindow];

  1275. 

  1276.             updateCVDisplayLinkScreen();

  1277.         }

  1278.     }

  1279. 

  1280.     void dismissModals()

  1281.     {

  1282.         if (hasNativeTitleBar() || isSharedWindow)

  1283.             sendModalInputAttemptIfBlocked (KeyWindowChanged::no);

  1284.     }

  1285. 

  1286.     void becomeKey()

  1287.     {

  1288.         component.repaint();

  1289.     }

  1290. 

  1291.     void resignKey()

  1292.     {

  1293.         viewFocusLoss();

  1294.         sendModalInputAttemptIfBlocked (KeyWindowChanged::yes);

  1295.     }

  1296. 

  1297.     void liveResizingStart()

  1298.     {

  1299.         if (constrainer == nullptr)

  1300.             return;

  1301. 

  1302.         constrainer->resizeStart();

  1303.         isFirstLiveResize = true;

  1304. 

  1305.         setFullScreenSizeConstraints (*constrainer);

  1306.     }

  1307. 

  1308.     void liveResizingEnd()

  1309.     {

  1310.         if (constrainer != nullptr)

  1311.             constrainer->resizeEnd();

  1312.     }

  1313. 

  1314.     NSRect constrainRect (const NSRect r)

  1315.     {

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

  1317.             return r;

  1318. 

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

  1320. 

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

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

  1323. 

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

  1325. 

  1326.         const bool inLiveResize = [window inLiveResize];

  1327. 

  1328.         if (! inLiveResize || isFirstLiveResize)

  1329.         {

  1330.             isFirstLiveResize = false;

  1331. 

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

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

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

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

  1336.         }

  1337. 

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

  1339.                                   isStretchingTop, isStretchingLeft, isStretchingBottom, isStretchingRight);

  1340. 

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

  1342.     }

  1343. 

  1344.     static void showArrowCursorIfNeeded()

  1345.     {

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

  1347.         auto mouse = desktop.getMainMouseSource();

  1348. 

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

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

  1351.         {

  1352.             [[NSCursor arrowCursor] set];

  1353.         }

  1354.     }

  1355. 

  1356.     static void updateModifiers (NSEvent* e)

  1357.     {

  1358.         updateModifiers ([e modifierFlags]);

  1359.     }

  1360. 

  1361.     static void updateModifiers (const NSUInteger flags)

  1362.     {

  1363.         int m = 0;

  1364. 

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

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

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

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

  1369. 

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

  1371.     }

  1372. 

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

  1374.     {

  1375.         updateModifiers (ev);

  1376. 

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

  1378.         {

  1379.             if (isKeyDown)

  1380.                 keysCurrentlyDown.addIfNotAlreadyThere (keyCode);

  1381.             else

  1382.                 keysCurrentlyDown.removeFirstMatchingValue (keyCode);

  1383.         }

  1384.     }

  1385. 

  1386.     static int getKeyCodeFromEvent (NSEvent* ev)

  1387.     {

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

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

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

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

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

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

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

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

  1396.         // if the shift key was not pressed

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

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

  1399. 

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

  1401.             keyCode = '\t';

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

  1403.             keyCode = '\r';

  1404.         else

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

  1406. 

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

  1408.         // keyboard control over the application.

  1409.         //

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

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

  1412.         // non-printing ranges.

  1413.         if (keyCode > 0xff

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

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

  1416.         {

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

  1418.         }

  1419. 

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

  1421.         {

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

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

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

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

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

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

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

  1429.                                               '.', KeyPress::numberPadDecimalPoint,

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

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

  1432. 

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

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

  1435.                     keyCode = numPadConversions [i + 1];

  1436.         }

  1437. 

  1438.         return keyCode;

  1439.     }

  1440. 

  1441.     static int64 getMouseTime (NSEvent* e) noexcept

  1442.     {

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

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

  1445.     }

  1446. 

  1447.     static float getMousePressure (NSEvent* e) noexcept

  1448.     {

  1449.         @try

  1450.         {

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

  1452.                 return (float) e.pressure;

  1453.         }

  1454.         @catch (NSException* e) {}

  1455.         @finally {}

  1456. 

  1457.         return 0.0f;

  1458.     }

  1459. 

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

  1461.     {

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

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

  1464.     }

  1465. 

  1466.     static int getModifierForButtonNumber (const NSInteger num)

  1467.     {

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

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

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

  1471.     }

  1472. 

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

  1474.     {

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

  1476.                                                               : NSWindowStyleMaskBorderless;

  1477. 

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

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

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

  1481.         return style;

  1482.     }

  1483. 

  1484.     static NSArray* getSupportedDragTypes()

  1485.     {

  1486.         const auto type = []

  1487.         {

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

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

  1490.                 return NSPasteboardTypeFileURL;

  1491.            #endif

  1492. 

  1493.             JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wdeprecated-declarations")

  1494.             return (NSString*) kUTTypeFileURL;

  1495.             JUCE_END_IGNORE_WARNINGS_GCC_LIKE

  1496.         }();

  1497. 

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

  1499.     }

  1500. 

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

  1502.     {

  1503.         NSPasteboard* pasteboard = [sender draggingPasteboard];

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

  1505. 

  1506.         if (contentType == nil)

  1507.             return false;

  1508. 

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

  1510. 

  1511.         ComponentPeer::DragInfo dragInfo;

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

  1513. 

  1514.         if (contentType == NSPasteboardTypeString)

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

  1516.         else

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

  1518. 

  1519.         if (! dragInfo.isEmpty())

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

  1521. 

  1522.         return false;

  1523.     }

  1524. 

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

  1526.     {

  1527.         StringArray files;

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

  1529. 

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

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

  1532.         {

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

  1534. 

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

  1536.             {

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

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

  1539.                 NSEnumerator* enumerator = [tracks objectEnumerator];

  1540.                 NSDictionary* track;

  1541. 

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

  1543.                 {

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

  1545.                     {

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

  1547. 

  1548.                         if ([url isFileURL])

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

  1550.                     }

  1551.                 }

  1552.             }

  1553.         }

  1554.         else

  1555.         {

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

  1557. 

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

  1559.             {

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

  1561. 

  1562.                 if ([url isFileURL])

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

  1564.             }

  1565.         }

  1566. 

  1567.         return files;

  1568.     }

  1569. 

  1570.     //==============================================================================

  1571.     void viewFocusGain()

  1572.     {

  1573.         if (currentlyFocusedPeer != this)

  1574.         {

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

  1576.                 currentlyFocusedPeer->handleFocusLoss();

  1577. 

  1578.             currentlyFocusedPeer = this;

  1579.             handleFocusGain();

  1580.         }

  1581.     }

  1582. 

  1583.     void viewFocusLoss()

  1584.     {

  1585.         if (currentlyFocusedPeer == this)

  1586.         {

  1587.             currentlyFocusedPeer = nullptr;

  1588.             handleFocusLoss();

  1589.         }

  1590.     }

  1591. 

  1592.     bool isFocused() const override

  1593.     {

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

  1595.                     ? this == currentlyFocusedPeer

  1596.                     : [window isKeyWindow];

  1597.     }

  1598. 

  1599.     void grabFocus() override

  1600.     {

  1601.         if (window != nil)

  1602.         {

  1603.             [window makeKeyWindow];

  1604.             [window makeFirstResponder: view];

  1605. 

  1606.             viewFocusGain();

  1607.         }

  1608.     }

  1609. 

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

  1611. 

  1612.     void closeInputMethodContext() override

  1613.     {

  1614.         stringBeingComposed.clear();

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

  1616. 

  1617.         if (inputContext != nil)

  1618.             [inputContext discardMarkedText];

  1619.     }

  1620. 

  1621.     void resetWindowPresentation()

  1622.     {

  1623.         if (hasNativeTitleBar())

  1624.         {

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

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

  1627.         }

  1628. 

  1629.         [NSApp setPresentationOptions: NSApplicationPresentationDefault];

  1630.         setCollectionBehaviour (isFullScreen());

  1631.     }

  1632. 

  1633.     void setHasChangedSinceSaved (bool b) override

  1634.     {

  1635.         if (! isSharedWindow)

  1636.             [window setDocumentEdited: b];

  1637.     }

  1638. 

  1639.     //==============================================================================

  1640.     NSWindow* window = nil;

  1641.     NSView* view = nil;

  1642.     WeakReference<Component> safeComponent;

  1643.     bool isSharedWindow = false;

  1644.    #if USE_COREGRAPHICS_RENDERING

  1645.     bool usingCoreGraphics = true;

  1646.    #else

  1647.     bool usingCoreGraphics = false;

  1648.    #endif

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

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

  1651.     bool windowRepresentsFile = false;

  1652.     bool isAlwaysOnTop = false, wasAlwaysOnTop = false;

  1653.     String stringBeingComposed;

  1654.     NSNotificationCenter* notificationCenter = nil;

  1655. 

  1656.     Rectangle<float> lastSizeBeforeZoom;

  1657.     RectangleList<float> deferredRepaints;

  1658.     uint32 lastRepaintTime;

  1659. 

  1660.     static ComponentPeer* currentlyFocusedPeer;

  1661.     static Array<int> keysCurrentlyDown;

  1662.     static int insideToFrontCall;

  1663. 

  1664.     static const SEL dismissModalsSelector;

  1665.     static const SEL frameChangedSelector;

  1666.     static const SEL asyncMouseDownSelector;

  1667.     static const SEL asyncMouseUpSelector;

  1668.     static const SEL becomeKeySelector;

  1669.     static const SEL resignKeySelector;

  1670. 

  1671. private:

  1672.     static NSView* createViewInstance();

  1673.     static NSWindow* createWindowInstance();

  1674. 

  1675.     void sendMouseEnterExit (NSEvent* ev)

  1676.     {

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

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

  1679.                 return;

  1680. 

  1681.         sendMouseEvent (ev);

  1682.     }

  1683. 

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

  1685.     {

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

  1687.     }

  1688. 

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

  1690.     {

  1691.         const NSRect* rects = nullptr;

  1692.         NSInteger numRects = 0;

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

  1694. 

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

  1696. 

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

  1698. 

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

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

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

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

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

  1704.     }

  1705. 

  1706.     static void appFocusChanged()

  1707.     {

  1708.         keysCurrentlyDown.clear();

  1709. 

  1710.         if (isValidPeer (currentlyFocusedPeer))

  1711.         {

  1712.             if (Process::isForegroundProcess())

  1713.             {

  1714.                 currentlyFocusedPeer->handleFocusGain();

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

  1716.             }

  1717.             else

  1718.             {

  1719.                 currentlyFocusedPeer->handleFocusLoss();

  1720.             }

  1721.         }

  1722.     }

  1723. 

  1724.     static bool checkEventBlockedByModalComps (NSEvent* e)

  1725.     {

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

  1727.             return false;

  1728. 

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

  1730. 

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

  1732.             return false;

  1733. 

  1734.         bool isKey = false, isInputAttempt = false;

  1735. 

  1736.         switch ([e type])

  1737.         {

  1738.             case NSEventTypeKeyDown:

  1739.             case NSEventTypeKeyUp:

  1740.                 isKey = isInputAttempt = true;

  1741.                 break;

  1742. 

  1743.             case NSEventTypeLeftMouseDown:

  1744.             case NSEventTypeRightMouseDown:

  1745.             case NSEventTypeOtherMouseDown:

  1746.                 isInputAttempt = true;

  1747.                 break;

  1748. 

  1749.             case NSEventTypeLeftMouseDragged:

  1750.             case NSEventTypeRightMouseDragged:

  1751.             case NSEventTypeLeftMouseUp:

  1752.             case NSEventTypeRightMouseUp:

  1753.             case NSEventTypeOtherMouseUp:

  1754.             case NSEventTypeOtherMouseDragged:

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

  1756.                     return false;

  1757.                 break;

  1758. 

  1759.             case NSEventTypeMouseMoved:

  1760.             case NSEventTypeMouseEntered:

  1761.             case NSEventTypeMouseExited:

  1762.             case NSEventTypeCursorUpdate:

  1763.             case NSEventTypeScrollWheel:

  1764.             case NSEventTypeTabletPoint:

  1765.             case NSEventTypeTabletProximity:

  1766.                 break;

  1767. 

  1768.             case NSEventTypeFlagsChanged:

  1769.             case NSEventTypeAppKitDefined:

  1770.             case NSEventTypeSystemDefined:

  1771.             case NSEventTypeApplicationDefined:

  1772.             case NSEventTypePeriodic:

  1773.             case NSEventTypeGesture:

  1774.             case NSEventTypeMagnify:

  1775.             case NSEventTypeSwipe:

  1776.             case NSEventTypeRotate:

  1777.             case NSEventTypeBeginGesture:

  1778.             case NSEventTypeEndGesture:

  1779.             case NSEventTypeQuickLook:

  1780.            #if JUCE_64BIT

  1781.             case NSEventTypeSmartMagnify:

  1782.             case NSEventTypePressure:

  1783.            #endif

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

  1785.            #if JUCE_64BIT

  1786.             case NSEventTypeDirectTouch:

  1787.            #endif

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

  1789.             case NSEventTypeChangeMode:

  1790.            #endif

  1791.           #endif

  1792.             default:

  1793.                 return false;

  1794.         }

  1795. 

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

  1797.         {

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

  1799.             {

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

  1801.                 {

  1802.                     if (isKey)

  1803.                     {

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

  1805.                             return false;

  1806.                     }

  1807.                     else

  1808.                     {

  1809.                         if (peer->isSharedWindow

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

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

  1812.                             return false;

  1813.                     }

  1814.                 }

  1815.             }

  1816.         }

  1817. 

  1818.         if (isInputAttempt)

  1819.         {

  1820.             if (! [NSApp isActive])

  1821.                 [NSApp activateIgnoringOtherApps: YES];

  1822. 

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

  1824.                 modal->inputAttemptWhenModal();

  1825.         }

  1826. 

  1827.         return true;

  1828.     }

  1829. 

  1830.     void setFullScreenSizeConstraints (const ComponentBoundsConstrainer& c)

  1831.     {

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

  1833.         {

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

  1835.                                              0.0f);

  1836.             [window setMinFullScreenContentSize: minSize];

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

  1838.         }

  1839.     }

  1840. 

  1841.     //==============================================================================

  1842.     void onDisplaySourceCallback()

  1843.     {

  1844.         setNeedsDisplayRectangles();

  1845.     }

  1846. 

  1847.     void onDisplayLinkCallback()

  1848.     {

  1849.         dispatch_source_merge_data (displaySource, 1);

  1850.     }

  1851. 

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

  1853.                                          CVOptionFlags, CVOptionFlags*, void* context)

  1854.     {

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

  1856.         return kCVReturnSuccess;

  1857.     }

  1858. 

  1859.     void updateCVDisplayLinkScreen()

  1860.     {

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

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

  1863.         jassertquiet (result == kCVReturnSuccess);

  1864.     }

  1865. 

  1866.     void createCVDisplayLink()

  1867.     {

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

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

  1870.         dispatch_resume (displaySource);

  1871. 

  1872.         auto cvReturn = CVDisplayLinkCreateWithActiveCGDisplays (&displayLink);

  1873.         jassertquiet (cvReturn == kCVReturnSuccess);

  1874. 

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

  1876.         jassertquiet (cvReturn == kCVReturnSuccess);

  1877. 

  1878.         CVDisplayLinkStart (displayLink);

  1879.     }

  1880. 

  1881.     CVDisplayLinkRef displayLink = nullptr;

  1882.     dispatch_source_t displaySource = nullptr;

  1883. 

  1884.    #if USE_COREGRAPHICS_RENDERING

  1885.     std::unique_ptr<CoreGraphicsMetalLayerRenderer> metalRenderer;

  1886.    #endif

  1887. 

  1888.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (NSViewComponentPeer)

  1889. };

  1890. 

  1891. int NSViewComponentPeer::insideToFrontCall = 0;

  1892. 

  1893. JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wundeclared-selector")

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

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

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

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

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

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

  1900. JUCE_END_IGNORE_WARNINGS_GCC_LIKE

  1901. 

  1902. //==============================================================================

  1903. template <typename Base>

  1904. struct NSViewComponentPeerWrapper  : public Base

  1905. {

  1906.     explicit NSViewComponentPeerWrapper (const char* baseName)

  1907.         : Base (baseName)

  1908.     {

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

  1910.     }

  1911. 

  1912.     static NSViewComponentPeer* getOwner (id self)

  1913.     {

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

  1915.     }

  1916. 

  1917.     static id getAccessibleChild (id self)

  1918.     {

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

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

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

  1922. 

  1923.         return nil;

  1924.     }

  1925. };

  1926. 

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

  1928. {

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

  1930.     {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1970. 

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

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

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

  1974. 

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

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

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

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

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

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

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

  1982. 

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

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

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

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

  1987. 

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

  1989. 

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

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

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

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

  1994. 

  1995.         // deprecated methods required for backwards compatibility

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

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

  1998. 

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

  2000. 

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

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

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

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

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

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

  2007. 

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

  2009. 

  2010.         addProtocol (@protocol (NSTextInput));

  2011. 

  2012.         registerClass();

  2013.     }

  2014. 

  2015. private:

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

  2017.     {

  2018.         if (JUCEApplicationBase::isStandaloneApp())

  2019.         {

  2020.             asyncMouseDown (self, s, ev);

  2021.         }

  2022.         else

  2023.         {

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

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

  2026.             // the event asynchronously..

  2027.             [self performSelectorOnMainThread: NSViewComponentPeer::asyncMouseDownSelector

  2028.                                    withObject: ev

  2029.                                 waitUntilDone: NO];

  2030.         }

  2031.     }

  2032. 

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

  2034.     {

  2035.         if (JUCEApplicationBase::isStandaloneApp())

  2036.         {

  2037.             asyncMouseUp (self, s, ev);

  2038.         }

  2039.         else

  2040.         {

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

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

  2043.             // the event asynchronously..

  2044.             [self performSelectorOnMainThread: NSViewComponentPeer::asyncMouseUpSelector

  2045.                                    withObject: ev

  2046.                                 waitUntilDone: NO];

  2047.         }

  2048.     }

  2049. 

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

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

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

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

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

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

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

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

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

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

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

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

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

  2063. 

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

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

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

  2067. 

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

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

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

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

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

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

  2074. 

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

  2076. 

  2077.     static void viewWillDraw (id self, SEL)

  2078.     {

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

  2080.         // to be the entire frame.

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

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

  2083.         {

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

  2085.             layer.contentsFormat = kCAContentsFormatRGBA8Uint;

  2086.         }

  2087.        #endif

  2088. 

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

  2090.     }

  2091. 

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

  2093.     {

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

  2095.         {

  2096.             if (p->isAlwaysOnTop)

  2097.             {

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

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

  2100.                 p->setAlwaysOnTop (false);

  2101.                 p->wasAlwaysOnTop = true;

  2102.             }

  2103.         }

  2104.     }

  2105. 

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

  2107.     {

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

  2109.         {

  2110.             if (p->wasAlwaysOnTop)

  2111.                 p->setAlwaysOnTop (true);

  2112. 

  2113.             p->redirectMovedOrResized();

  2114.         }

  2115.     }

  2116. 

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

  2118.     {

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

  2120.             p->windowDidChangeScreen();

  2121.     }

  2122. 

  2123.     static BOOL isOpaque (id self, SEL)

  2124.     {

  2125.         auto* owner = getOwner (self);

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

  2127.     }

  2128. 

  2129.     //==============================================================================

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

  2131.     {

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

  2133.         {

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

  2135.             owner->textWasInserted = false;

  2136. 

  2137.             if (target != nullptr)

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

  2139.             else

  2140.                 owner->stringBeingComposed.clear();

  2141. 

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

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

  2144.         }

  2145.     }

  2146. 

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

  2148.     {

  2149.         auto* owner = getOwner (self);

  2150. 

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

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

  2153.     }

  2154. 

  2155.     //==============================================================================

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

  2157.     {

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

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

  2160.         {

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

  2162. 

  2163.             if ([newText length] > 0)

  2164.             {

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

  2166.                 {

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

  2168.                     owner->textWasInserted = true;

  2169.                 }

  2170.             }

  2171. 

  2172.             owner->stringBeingComposed.clear();

  2173.         }

  2174.     }

  2175. 

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

  2177. 

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

  2179.     {

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

  2181.         {

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

  2183.                                                            ? [aString string] : aString);

  2184. 

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

  2186.             {

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

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

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

  2190.                 owner->textWasInserted = true;

  2191.             }

  2192.         }

  2193.     }

  2194. 

  2195.     static void unmarkText (id self, SEL)

  2196.     {

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

  2198.         {

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

  2200.             {

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

  2202.                 {

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

  2204.                     owner->textWasInserted = true;

  2205.                 }

  2206. 

  2207.                 owner->stringBeingComposed.clear();

  2208.             }

  2209.         }

  2210.     }

  2211. 

  2212.     static BOOL hasMarkedText (id self, SEL)

  2213.     {

  2214.         auto* owner = getOwner (self);

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

  2216.     }

  2217. 

  2218.     static long conversationIdentifier (id self, SEL)

  2219.     {

  2220.         return (long) (pointer_sized_int) self;

  2221.     }

  2222. 

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

  2224.     {

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

  2226.         {

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

  2228.             {

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

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

  2231. 

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

  2233.             }

  2234.         }

  2235. 

  2236.         return nil;

  2237.     }

  2238. 

  2239.     static NSRange markedRange (id self, SEL)

  2240.     {

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

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

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

  2244. 

  2245.         return NSMakeRange (NSNotFound, 0);

  2246.     }

  2247. 

  2248.     static NSRange selectedRange (id self, SEL)

  2249.     {

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

  2251.         {

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

  2253.             {

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

  2255. 

  2256.                 if (! highlight.isEmpty())

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

  2258.                                         (NSUInteger) highlight.getLength());

  2259.             }

  2260.         }

  2261. 

  2262.         return NSMakeRange (NSNotFound, 0);

  2263.     }

  2264. 

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

  2266.     {

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

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

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

  2270. 

  2271.         return NSZeroRect;

  2272.     }

  2273. 

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

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

  2276. 

  2277.     //==============================================================================

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

  2279.     {

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

  2281.     }

  2282. 

  2283.     static BOOL becomeFirstResponder (id self, SEL)

  2284.     {

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

  2286.         return YES;

  2287.     }

  2288. 

  2289.     static BOOL resignFirstResponder (id self, SEL)

  2290.     {

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

  2292.         return YES;

  2293.     }

  2294. 

  2295.     static BOOL acceptsFirstResponder (id self, SEL)

  2296.     {

  2297.         auto* owner = getOwner (self);

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

  2299.     }

  2300. 

  2301.     //==============================================================================

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

  2303.     {

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

  2305.     }

  2306. 

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

  2308.     {

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

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

  2311.                 return NSDragOperationGeneric;

  2312. 

  2313.         return NSDragOperationNone;

  2314.     }

  2315. 

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

  2317.     {

  2318.         draggingExited (self, s, sender);

  2319.     }

  2320. 

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

  2322.     {

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

  2324.     }

  2325. 

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

  2327.     {

  2328.         return YES;

  2329.     }

  2330. 

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

  2332.     {

  2333.         auto* owner = getOwner (self);

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

  2335.     }

  2336. 

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

  2338. 

  2339.     //==============================================================================

  2340.     static BOOL getIsAccessibilityElement (id, SEL)

  2341.     {

  2342.         return NO;

  2343.     }

  2344. 

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

  2346.     {

  2347.         return NSAccessibilityUnignoredChildrenForOnlyChild (getAccessibleChild (self));

  2348.     }

  2349. 

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

  2351.     {

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

  2353.     }

  2354. 

  2355.     static id getAccessibilityFocusedUIElement (id self, SEL)

  2356.     {

  2357.         return [getAccessibleChild (self) accessibilityFocusedUIElement];

  2358.     }

  2359. 

  2360.     static BOOL getAccessibilityIsIgnored (id, SEL)

  2361.     {

  2362.         return YES;

  2363.     }

  2364. 

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

  2366.     {

  2367.         if ([attribute isEqualToString: NSAccessibilityChildrenAttribute])

  2368.             return getAccessibilityChildren (self, {});

  2369. 

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

  2371.     }

  2372. 

  2373.     static bool tryPassingKeyEventToPeer (NSEvent* e)

  2374.     {

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

  2376.             return false;

  2377. 

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

  2379.         {

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

  2381.             {

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

  2383.                                                       : peer->redirectKeyUp (e);

  2384.             }

  2385.         }

  2386. 

  2387.         return false;

  2388.     }

  2389. 

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

  2391.     {

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

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

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

  2395.         if (tryPassingKeyEventToPeer (event))

  2396.             return YES;

  2397. 

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

  2399.     }

  2400. 

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

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

  2403.     {

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

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

  2406.     }

  2407. };

  2408. 

  2409. //==============================================================================

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

  2411. {

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

  2413.     {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  2430. 

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

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

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

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

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

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

  2437. 

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

  2439. 

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

  2441. 

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

  2443. 

  2444.         addProtocol (@protocol (NSWindowDelegate));

  2445. 

  2446.         registerClass();

  2447.     }

  2448. 

  2449. private:

  2450.     //==============================================================================

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

  2452. 

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

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

  2455.     // to performKeyEquivalent.

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

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

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

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

  2460.     // that is on the desktop.

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

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

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

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

  2465.     // triggers an annoying NSBeep.

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

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

  2468.     {

  2469.         ignoreUnused (ev);

  2470. 

  2471.        #if JUCE_DEBUG_UNHANDLED_KEYPRESSES

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

  2473.        #endif

  2474.     }

  2475. 

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

  2477.     {

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

  2479.         {

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

  2481.             {

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

  2483.                 {

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

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

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

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

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

  2489. 

  2490.                     return flippedScreenRect (makeNSRect ([&]

  2491.                     {

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

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

  2494. 

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

  2496.                         return constrained;

  2497.                     }()));

  2498.                 }

  2499.             }

  2500.         }

  2501. 

  2502.         return r;

  2503.     }

  2504. 

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

  2506.     {

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

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

  2509.                 return NO;

  2510. 

  2511.         return YES;

  2512.     }

  2513. 

  2514.     static BOOL canBecomeKeyWindow (id self, SEL)

  2515.     {

  2516.         auto* owner = getOwner (self);

  2517. 

  2518.         return owner != nullptr

  2519.                 && owner->canBecomeKeyWindow()

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

  2521.     }

  2522. 

  2523.     static BOOL canBecomeMainWindow (id self, SEL)

  2524.     {

  2525.         auto* owner = getOwner (self);

  2526. 

  2527.         return owner != nullptr

  2528.                 && owner->canBecomeMainWindow()

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

  2530.     }

  2531. 

  2532.     static void becomeKeyWindow (id self, SEL)

  2533.     {

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

  2535. 

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

  2537.         {

  2538.             if (owner->canBecomeKeyWindow())

  2539.             {

  2540.                 owner->becomeKeyWindow();

  2541.                 return;

  2542.             }

  2543. 

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

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

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

  2547.         }

  2548.     }

  2549. 

  2550.     static void resignKeyWindow (id self, SEL)

  2551.     {

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

  2553. 

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

  2555.             owner->resignKeyWindow();

  2556.     }

  2557. 

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

  2559.     {

  2560.         auto* owner = getOwner (self);

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

  2562.     }

  2563. 

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

  2565.     {

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

  2567.         {

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

  2569.                                                                           frameRect, screen);

  2570. 

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

  2572.         }

  2573. 

  2574.         return frameRect;

  2575.     }

  2576. 

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

  2578.     {

  2579.         auto* owner = getOwner (self);

  2580. 

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

  2582.             return proposedFrameSize;

  2583. 

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

  2585.         frameRect.size = proposedFrameSize;

  2586. 

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

  2588. 

  2589.         owner->dismissModals();

  2590. 

  2591.         return frameRect.size;

  2592.     }

  2593. 

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

  2595.     {

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

  2597.         {

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

  2599. 

  2600.             if (! isFullScreen)

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

  2602. 

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

  2604. 

  2605.             if (isFullScreen)

  2606.             {

  2607.                 [NSApp setPresentationOptions: NSApplicationPresentationDefault];

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

  2609.             }

  2610.         }

  2611.     }

  2612. 

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

  2614.     {

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

  2616.             owner->resetWindowPresentation();

  2617.     }

  2618. 

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

  2620.     {

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

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

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

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

  2625.     }

  2626. 

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

  2628.     {

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

  2630.             return;

  2631. 

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

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

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

  2635.     }

  2636. 

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

  2638.     {

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

  2640.             owner->liveResizingStart();

  2641.     }

  2642. 

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

  2644.     {

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

  2646.             owner->liveResizingEnd();

  2647.     }

  2648. 

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

  2650.     {

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

  2652.             return owner->windowRepresentsFile;

  2653. 

  2654.         return false;

  2655.     }

  2656. 

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

  2658.     {

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

  2660.             return owner->windowRepresentsFile;

  2661. 

  2662.         return false;

  2663.     }

  2664. 

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

  2666.     {

  2667.         return [self title];

  2668.     }

  2669. 

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

  2671.     {

  2672.         return [getAccessibleChild (self) accessibilityLabel];

  2673.     }

  2674. 

  2675.     static id getAccessibilityWindow (id self, SEL)

  2676.     {

  2677.         return self;

  2678.     }

  2679. 

  2680.     static NSAccessibilityRole getAccessibilityRole (id, SEL)

  2681.     {

  2682.         return NSAccessibilityWindowRole;

  2683.     }

  2684. 

  2685.     static NSAccessibilityRole getAccessibilitySubrole (id self, SEL)

  2686.     {

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

  2688.             return [getAccessibleChild (self) accessibilitySubrole];

  2689. 

  2690.         return nil;

  2691.     }

  2692. };

  2693. 

  2694. NSView* NSViewComponentPeer::createViewInstance()

  2695. {

  2696.     static JuceNSViewClass cls;

  2697.     return cls.createInstance();

  2698. }

  2699. 

  2700. NSWindow* NSViewComponentPeer::createWindowInstance()

  2701. {

  2702.     static JuceNSWindowClass cls;

  2703.     return cls.createInstance();

  2704. }

  2705. 

  2706. 

  2707. //==============================================================================

  2708. ComponentPeer* NSViewComponentPeer::currentlyFocusedPeer = nullptr;

  2709. Array<int> NSViewComponentPeer::keysCurrentlyDown;

  2710. 

  2711. //==============================================================================

  2712. bool KeyPress::isKeyCurrentlyDown (int keyCode)

  2713. {

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

  2715.         return true;

  2716. 

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

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

  2719.         return true;

  2720. 

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

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

  2723.         return true;

  2724. 

  2725.     return false;

  2726. }

  2727. 

  2728. //==============================================================================

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

  2730. {

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

  2732.     {

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

  2734.         return true;

  2735.     }

  2736. 

  2737.     return false;

  2738. }

  2739. 

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

  2741. {

  2742.     return false;

  2743. }

  2744. 

  2745. //==============================================================================

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

  2747. {

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

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

  2750. 

  2751.     if (peer->hasNativeTitleBar())

  2752.     {

  2753.         if (shouldBeEnabled && ! allowMenusAndBars)

  2754.             [NSApp setPresentationOptions: NSApplicationPresentationHideDock | NSApplicationPresentationHideMenuBar];

  2755.         else if (! shouldBeEnabled)

  2756.             [NSApp setPresentationOptions: NSApplicationPresentationDefault];

  2757. 

  2758.         peer->setFullScreen (true);

  2759.     }

  2760.     else

  2761.     {

  2762.         if (shouldBeEnabled)

  2763.         {

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

  2765.                                                               : (NSApplicationPresentationHideDock | NSApplicationPresentationHideMenuBar))];

  2766. 

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

  2768.             peer->becomeKeyWindow();

  2769.         }

  2770.         else

  2771.         {

  2772.             peer->resetWindowPresentation();

  2773.         }

  2774.     }

  2775. }

  2776. 

  2777. void Desktop::allowedOrientationsChanged() {}

  2778. 

  2779. //==============================================================================

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

  2781. {

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

  2783. }

  2784. 

  2785. //==============================================================================

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

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

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

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

  2790. const int KeyPress::leftKey         = NSLeftArrowFunctionKey;

  2791. const int KeyPress::rightKey        = NSRightArrowFunctionKey;

  2792. const int KeyPress::upKey           = NSUpArrowFunctionKey;

  2793. const int KeyPress::downKey         = NSDownArrowFunctionKey;

  2794. const int KeyPress::pageUpKey       = NSPageUpFunctionKey;

  2795. const int KeyPress::pageDownKey     = NSPageDownFunctionKey;

  2796. const int KeyPress::endKey          = NSEndFunctionKey;

  2797. const int KeyPress::homeKey         = NSHomeFunctionKey;

  2798. const int KeyPress::deleteKey       = NSDeleteFunctionKey;

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

  2800. const int KeyPress::tabKey          = 9;

  2801. const int KeyPress::F1Key           = NSF1FunctionKey;

  2802. const int KeyPress::F2Key           = NSF2FunctionKey;

  2803. const int KeyPress::F3Key           = NSF3FunctionKey;

  2804. const int KeyPress::F4Key           = NSF4FunctionKey;

  2805. const int KeyPress::F5Key           = NSF5FunctionKey;

  2806. const int KeyPress::F6Key           = NSF6FunctionKey;

  2807. const int KeyPress::F7Key           = NSF7FunctionKey;

  2808. const int KeyPress::F8Key           = NSF8FunctionKey;

  2809. const int KeyPress::F9Key           = NSF9FunctionKey;

  2810. const int KeyPress::F10Key          = NSF10FunctionKey;

  2811. const int KeyPress::F11Key          = NSF11FunctionKey;

  2812. const int KeyPress::F12Key          = NSF12FunctionKey;

  2813. const int KeyPress::F13Key          = NSF13FunctionKey;

  2814. const int KeyPress::F14Key          = NSF14FunctionKey;

  2815. const int KeyPress::F15Key          = NSF15FunctionKey;

  2816. const int KeyPress::F16Key          = NSF16FunctionKey;

  2817. const int KeyPress::F17Key          = NSF17FunctionKey;

  2818. const int KeyPress::F18Key          = NSF18FunctionKey;

  2819. const int KeyPress::F19Key          = NSF19FunctionKey;

  2820. const int KeyPress::F20Key          = NSF20FunctionKey;

  2821. const int KeyPress::F21Key          = NSF21FunctionKey;

  2822. const int KeyPress::F22Key          = NSF22FunctionKey;

  2823. const int KeyPress::F23Key          = NSF23FunctionKey;

  2824. const int KeyPress::F24Key          = NSF24FunctionKey;

  2825. const int KeyPress::F25Key          = NSF25FunctionKey;

  2826. const int KeyPress::F26Key          = NSF26FunctionKey;

  2827. const int KeyPress::F27Key          = NSF27FunctionKey;

  2828. const int KeyPress::F28Key          = NSF28FunctionKey;

  2829. const int KeyPress::F29Key          = NSF29FunctionKey;

  2830. const int KeyPress::F30Key          = NSF30FunctionKey;

  2831. const int KeyPress::F31Key          = NSF31FunctionKey;

  2832. const int KeyPress::F32Key          = NSF32FunctionKey;

  2833. const int KeyPress::F33Key          = NSF33FunctionKey;

  2834. const int KeyPress::F34Key          = NSF34FunctionKey;

  2835. const int KeyPress::F35Key          = NSF35FunctionKey;

  2836. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  2859. 

  2860. } // namespace juce