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

3605 lines
128KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE library.

  5.    Copyright (c) 2013 - Raw Material Software Ltd.

  6. 

  7.    Permission is granted to use this software under the terms of either:

  8.    a) the GPL v2 (or any later version)

  9.    b) the Affero GPL v3

  10. 

  11.    Details of these licenses can be found at: www.gnu.org/licenses

  12. 

  13.    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY

  14.    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR

  15.    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.

  16. 

  17.    ------------------------------------------------------------------------------

  18. 

  19.    To release a closed-source product which uses JUCE, commercial licenses are

  20.    available: visit www.juce.com for more information.

  21. 

  22.   ==============================================================================

  23. */

  24. 

  25. extern Display* display;

  26. extern XContext windowHandleXContext;

  27. typedef void (*WindowMessageReceiveCallback) (XEvent&);

  28. extern WindowMessageReceiveCallback dispatchWindowMessage;

  29. 

  30. 

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

  32. struct Atoms

  33. {

  34.     Atoms()

  35.     {

  36.         protocols                       = getIfExists ("WM_PROTOCOLS");

  37.         protocolList [TAKE_FOCUS]       = getIfExists ("WM_TAKE_FOCUS");

  38.         protocolList [DELETE_WINDOW]    = getIfExists ("WM_DELETE_WINDOW");

  39.         protocolList [PING]             = getIfExists ("_NET_WM_PING");

  40.         changeState                     = getIfExists ("WM_CHANGE_STATE");

  41.         state                           = getIfExists ("WM_STATE");

  42.         userTime                        = getCreating ("_NET_WM_USER_TIME");

  43.         activeWin                       = getCreating ("_NET_ACTIVE_WINDOW");

  44.         pid                             = getCreating ("_NET_WM_PID");

  45.         windowType                      = getIfExists ("_NET_WM_WINDOW_TYPE");

  46.         windowState                     = getIfExists ("_NET_WM_STATE");

  47.         compositingManager              = getCreating ("_NET_WM_CM_S0");

  48. 

  49.         XdndAware                       = getCreating ("XdndAware");

  50.         XdndEnter                       = getCreating ("XdndEnter");

  51.         XdndLeave                       = getCreating ("XdndLeave");

  52.         XdndPosition                    = getCreating ("XdndPosition");

  53.         XdndStatus                      = getCreating ("XdndStatus");

  54.         XdndDrop                        = getCreating ("XdndDrop");

  55.         XdndFinished                    = getCreating ("XdndFinished");

  56.         XdndSelection                   = getCreating ("XdndSelection");

  57. 

  58.         XdndTypeList                    = getCreating ("XdndTypeList");

  59.         XdndActionList                  = getCreating ("XdndActionList");

  60.         XdndActionCopy                  = getCreating ("XdndActionCopy");

  61.         XdndActionPrivate               = getCreating ("XdndActionPrivate");

  62.         XdndActionDescription           = getCreating ("XdndActionDescription");

  63. 

  64.         allowedMimeTypes[0]             = getCreating ("UTF8_STRING");

  65.         allowedMimeTypes[1]             = getCreating ("text/plain;charset=utf-8");

  66.         allowedMimeTypes[2]             = getCreating ("text/plain");

  67.         allowedMimeTypes[3]             = getCreating ("text/uri-list");

  68. 

  69.         externalAllowedFileMimeTypes[0] = getCreating ("text/uri-list");

  70.         externalAllowedTextMimeTypes[0] = getCreating ("text/plain");

  71. 

  72.         allowedActions[0]               = getCreating ("XdndActionMove");

  73.         allowedActions[1]               = XdndActionCopy;

  74.         allowedActions[2]               = getCreating ("XdndActionLink");

  75.         allowedActions[3]               = getCreating ("XdndActionAsk");

  76.         allowedActions[4]               = XdndActionPrivate;

  77.     }

  78. 

  79.     static const Atoms& get()

  80.     {

  81.         static Atoms atoms;

  82.         return atoms;

  83.     }

  84. 

  85.     enum ProtocolItems

  86.     {

  87.         TAKE_FOCUS = 0,

  88.         DELETE_WINDOW = 1,

  89.         PING = 2

  90.     };

  91. 

  92.     Atom protocols, protocolList[3], changeState, state, userTime,

  93.          activeWin, pid, windowType, windowState, compositingManager,

  94.          XdndAware, XdndEnter, XdndLeave, XdndPosition, XdndStatus,

  95.          XdndDrop, XdndFinished, XdndSelection, XdndTypeList, XdndActionList,

  96.          XdndActionDescription, XdndActionCopy, XdndActionPrivate,

  97.          allowedActions[5],

  98.          allowedMimeTypes[4],

  99.          externalAllowedFileMimeTypes[1],

  100.          externalAllowedTextMimeTypes[1];

  101. 

  102.     static const unsigned long DndVersion;

  103. 

  104.     static Atom getIfExists (const char* name)    { return XInternAtom (display, name, True); }

  105.     static Atom getCreating (const char* name)    { return XInternAtom (display, name, False); }

  106. 

  107.     static String getName (const Atom atom)

  108.     {

  109.         if (atom == None)

  110.             return "None";

  111. 

  112.         return String (XGetAtomName (display, atom));

  113.     }

  114. 

  115.     static bool isMimeTypeFile (const Atom atom)  { return getName (atom).equalsIgnoreCase ("text/uri-list"); }

  116. };

  117. 

  118. const unsigned long Atoms::DndVersion = 3;

  119. 

  120. //==============================================================================

  121. struct GetXProperty

  122. {

  123.     GetXProperty (Window window, Atom atom, long offset, long length, bool shouldDelete, Atom requestedType)

  124.         : data (nullptr)

  125.     {

  126.         success = (XGetWindowProperty (display, window, atom, offset, length,

  127.                                        (Bool) shouldDelete, requestedType, &actualType,

  128.                                        &actualFormat, &numItems, &bytesLeft, &data) == Success)

  129.                     && data != nullptr;

  130.     }

  131. 

  132.     ~GetXProperty()

  133.     {

  134.         if (data != nullptr)

  135.             XFree (data);

  136.     }

  137. 

  138.     bool success;

  139.     unsigned char* data;

  140.     unsigned long numItems, bytesLeft;

  141.     Atom actualType;

  142.     int actualFormat;

  143. };

  144. 

  145. //==============================================================================

  146. namespace Keys

  147. {

  148.     enum MouseButtons

  149.     {

  150.         NoButton = 0,

  151.         LeftButton = 1,

  152.         MiddleButton = 2,

  153.         RightButton = 3,

  154.         WheelUp = 4,

  155.         WheelDown = 5

  156.     };

  157. 

  158.     static int AltMask = 0;

  159.     static int NumLockMask = 0;

  160.     static bool numLock = false;

  161.     static bool capsLock = false;

  162.     static char keyStates [32];

  163.     static const int extendedKeyModifier = 0x10000000;

  164. }

  165. 

  166. bool KeyPress::isKeyCurrentlyDown (const int keyCode)

  167. {

  168.     if (display == nullptr)

  169.         return false;

  170. 

  171.     int keysym;

  172. 

  173.     if (keyCode & Keys::extendedKeyModifier)

  174.     {

  175.         keysym = 0xff00 | (keyCode & 0xff);

  176.     }

  177.     else

  178.     {

  179.         keysym = keyCode;

  180. 

  181.         if (keysym == (XK_Tab & 0xff)

  182.             || keysym == (XK_Return & 0xff)

  183.             || keysym == (XK_Escape & 0xff)

  184.             || keysym == (XK_BackSpace & 0xff))

  185.         {

  186.             keysym |= 0xff00;

  187.         }

  188.     }

  189. 

  190.     ScopedXLock xlock;

  191. 

  192.     const int keycode = XKeysymToKeycode (display, (KeySym) keysym);

  193. 

  194.     const int keybyte = keycode >> 3;

  195.     const int keybit = (1 << (keycode & 7));

  196.     return (Keys::keyStates [keybyte] & keybit) != 0;

  197. }

  198. 

  199. //==============================================================================

  200. #if JUCE_USE_XSHM

  201. namespace XSHMHelpers

  202. {

  203.     static int trappedErrorCode = 0;

  204.     extern "C" int errorTrapHandler (Display*, XErrorEvent* err)

  205.     {

  206.         trappedErrorCode = err->error_code;

  207.         return 0;

  208.     }

  209. 

  210.     static bool isShmAvailable() noexcept

  211.     {

  212.         static bool isChecked = false;

  213.         static bool isAvailable = false;

  214. 

  215.         if (! isChecked)

  216.         {

  217.             isChecked = true;

  218. 

  219.             if (display != nullptr)

  220.             {

  221.                 int major, minor;

  222.                 Bool pixmaps;

  223. 

  224.                 ScopedXLock xlock;

  225. 

  226.                 if (XShmQueryVersion (display, &major, &minor, &pixmaps))

  227.                 {

  228.                     trappedErrorCode = 0;

  229.                     XErrorHandler oldHandler = XSetErrorHandler (errorTrapHandler);

  230. 

  231.                     XShmSegmentInfo segmentInfo;

  232.                     zerostruct (segmentInfo);

  233. 

  234.                     XImage* xImage = XShmCreateImage (display, DefaultVisual (display, DefaultScreen (display)),

  235.                                                       24, ZPixmap, 0, &segmentInfo, 50, 50);

  236. 

  237.                     if ((segmentInfo.shmid = shmget (IPC_PRIVATE,

  238.                                                      (size_t) (xImage->bytes_per_line * xImage->height),

  239.                                                      IPC_CREAT | 0777)) >= 0)

  240.                     {

  241.                         segmentInfo.shmaddr = (char*) shmat (segmentInfo.shmid, 0, 0);

  242. 

  243.                         if (segmentInfo.shmaddr != (void*) -1)

  244.                         {

  245.                             segmentInfo.readOnly = False;

  246.                             xImage->data = segmentInfo.shmaddr;

  247.                             XSync (display, False);

  248. 

  249.                             if (XShmAttach (display, &segmentInfo) != 0)

  250.                             {

  251.                                 XSync (display, False);

  252.                                 XShmDetach (display, &segmentInfo);

  253. 

  254.                                 isAvailable = true;

  255.                             }

  256.                         }

  257. 

  258.                         XFlush (display);

  259.                         XDestroyImage (xImage);

  260. 

  261.                         shmdt (segmentInfo.shmaddr);

  262.                     }

  263. 

  264.                     shmctl (segmentInfo.shmid, IPC_RMID, 0);

  265. 

  266.                     XSetErrorHandler (oldHandler);

  267.                     if (trappedErrorCode != 0)

  268.                         isAvailable = false;

  269.                 }

  270.             }

  271.         }

  272. 

  273.         return isAvailable;

  274.     }

  275. }

  276. #endif

  277. 

  278. //==============================================================================

  279. #if JUCE_USE_XRENDER

  280. namespace XRender

  281. {

  282.     typedef Status (*tXRenderQueryVersion) (Display*, int*, int*);

  283.     typedef XRenderPictFormat* (*tXRenderFindStandardFormat) (Display*, int);

  284.     typedef XRenderPictFormat* (*tXRenderFindFormat) (Display*, unsigned long, XRenderPictFormat*, int);

  285.     typedef XRenderPictFormat* (*tXRenderFindVisualFormat) (Display*, Visual*);

  286. 

  287.     static tXRenderQueryVersion xRenderQueryVersion = nullptr;

  288.     static tXRenderFindStandardFormat xRenderFindStandardFormat = nullptr;

  289.     static tXRenderFindFormat xRenderFindFormat = nullptr;

  290.     static tXRenderFindVisualFormat xRenderFindVisualFormat = nullptr;

  291. 

  292.     static bool isAvailable()

  293.     {

  294.         static bool hasLoaded = false;

  295. 

  296.         if (! hasLoaded)

  297.         {

  298.             if (display != nullptr)

  299.             {

  300.                 hasLoaded = true;

  301. 

  302.                 ScopedXLock xlock;

  303. 

  304.                 if (void* h = dlopen ("libXrender.so", RTLD_GLOBAL | RTLD_NOW))

  305.                 {

  306.                     xRenderQueryVersion         = (tXRenderQueryVersion)        dlsym (h, "XRenderQueryVersion");

  307.                     xRenderFindStandardFormat   = (tXRenderFindStandardFormat)  dlsym (h, "XRenderFindStandardFormat");

  308.                     xRenderFindFormat           = (tXRenderFindFormat)          dlsym (h, "XRenderFindFormat");

  309.                     xRenderFindVisualFormat     = (tXRenderFindVisualFormat)    dlsym (h, "XRenderFindVisualFormat");

  310.                 }

  311. 

  312.                 if (xRenderQueryVersion != nullptr

  313.                      && xRenderFindStandardFormat != nullptr

  314.                      && xRenderFindFormat != nullptr

  315.                      && xRenderFindVisualFormat != nullptr)

  316.                 {

  317.                     int major, minor;

  318.                     if (xRenderQueryVersion (display, &major, &minor))

  319.                         return true;

  320.                 }

  321.             }

  322. 

  323.             xRenderQueryVersion = nullptr;

  324.         }

  325. 

  326.         return xRenderQueryVersion != nullptr;

  327.     }

  328. 

  329.     static bool hasCompositingWindowManager()

  330.     {

  331.         return display != nullptr && XGetSelectionOwner (display, Atoms::get().compositingManager) != 0;

  332.     }

  333. 

  334.     static XRenderPictFormat* findPictureFormat()

  335.     {

  336.         ScopedXLock xlock;

  337.         XRenderPictFormat* pictFormat = nullptr;

  338. 

  339.         if (isAvailable())

  340.         {

  341.             pictFormat = xRenderFindStandardFormat (display, PictStandardARGB32);

  342. 

  343.             if (pictFormat == nullptr)

  344.             {

  345.                 XRenderPictFormat desiredFormat;

  346.                 desiredFormat.type = PictTypeDirect;

  347.                 desiredFormat.depth = 32;

  348. 

  349.                 desiredFormat.direct.alphaMask = 0xff;

  350.                 desiredFormat.direct.redMask   = 0xff;

  351.                 desiredFormat.direct.greenMask = 0xff;

  352.                 desiredFormat.direct.blueMask  = 0xff;

  353. 

  354.                 desiredFormat.direct.alpha = 24;

  355.                 desiredFormat.direct.red   = 16;

  356.                 desiredFormat.direct.green = 8;

  357.                 desiredFormat.direct.blue  = 0;

  358. 

  359.                 pictFormat = xRenderFindFormat (display,

  360.                                                 PictFormatType | PictFormatDepth

  361.                                                  | PictFormatRedMask | PictFormatRed

  362.                                                  | PictFormatGreenMask | PictFormatGreen

  363.                                                  | PictFormatBlueMask | PictFormatBlue

  364.                                                  | PictFormatAlphaMask | PictFormatAlpha,

  365.                                                 &desiredFormat,

  366.                                                 0);

  367.             }

  368.         }

  369. 

  370.         return pictFormat;

  371.     }

  372. }

  373. #endif

  374. 

  375. //==============================================================================

  376. namespace Visuals

  377. {

  378.     static Visual* findVisualWithDepth (const int desiredDepth) noexcept

  379.     {

  380.         ScopedXLock xlock;

  381. 

  382.         Visual* visual = nullptr;

  383.         int numVisuals = 0;

  384.         long desiredMask = VisualNoMask;

  385.         XVisualInfo desiredVisual;

  386. 

  387.         desiredVisual.screen = DefaultScreen (display);

  388.         desiredVisual.depth = desiredDepth;

  389. 

  390.         desiredMask = VisualScreenMask | VisualDepthMask;

  391. 

  392.         if (desiredDepth == 32)

  393.         {

  394.             desiredVisual.c_class    = TrueColor;

  395.             desiredVisual.red_mask   = 0x00FF0000;

  396.             desiredVisual.green_mask = 0x0000FF00;

  397.             desiredVisual.blue_mask  = 0x000000FF;

  398.             desiredVisual.bits_per_rgb = 8;

  399. 

  400.             desiredMask |= VisualClassMask;

  401.             desiredMask |= VisualRedMaskMask;

  402.             desiredMask |= VisualGreenMaskMask;

  403.             desiredMask |= VisualBlueMaskMask;

  404.             desiredMask |= VisualBitsPerRGBMask;

  405.         }

  406. 

  407.         XVisualInfo* xvinfos = XGetVisualInfo (display,

  408.                                                desiredMask,

  409.                                                &desiredVisual,

  410.                                                &numVisuals);

  411. 

  412.         if (xvinfos != nullptr)

  413.         {

  414.             for (int i = 0; i < numVisuals; i++)

  415.             {

  416.                 if (xvinfos[i].depth == desiredDepth)

  417.                 {

  418.                     visual = xvinfos[i].visual;

  419.                     break;

  420.                 }

  421.             }

  422. 

  423.             XFree (xvinfos);

  424.         }

  425. 

  426.         return visual;

  427.     }

  428. 

  429.     static Visual* findVisualFormat (const int desiredDepth, int& matchedDepth) noexcept

  430.     {

  431.         Visual* visual = nullptr;

  432. 

  433.         if (desiredDepth == 32)

  434.         {

  435.            #if JUCE_USE_XSHM

  436.             if (XSHMHelpers::isShmAvailable())

  437.             {

  438.                #if JUCE_USE_XRENDER

  439.                 if (XRender::isAvailable())

  440.                 {

  441.                     XRenderPictFormat* pictFormat = XRender::findPictureFormat();

  442. 

  443.                     if (pictFormat != 0)

  444.                     {

  445.                         int numVisuals = 0;

  446.                         XVisualInfo desiredVisual;

  447.                         desiredVisual.screen = DefaultScreen (display);

  448.                         desiredVisual.depth = 32;

  449.                         desiredVisual.bits_per_rgb = 8;

  450. 

  451.                         XVisualInfo* xvinfos = XGetVisualInfo (display,

  452.                                                                VisualScreenMask | VisualDepthMask | VisualBitsPerRGBMask,

  453.                                                                &desiredVisual, &numVisuals);

  454.                         if (xvinfos != nullptr)

  455.                         {

  456.                             for (int i = 0; i < numVisuals; ++i)

  457.                             {

  458.                                 XRenderPictFormat* pictVisualFormat = XRender::xRenderFindVisualFormat (display, xvinfos[i].visual);

  459. 

  460.                                 if (pictVisualFormat != nullptr

  461.                                      && pictVisualFormat->type == PictTypeDirect

  462.                                      && pictVisualFormat->direct.alphaMask)

  463.                                 {

  464.                                     visual = xvinfos[i].visual;

  465.                                     matchedDepth = 32;

  466.                                     break;

  467.                                 }

  468.                             }

  469. 

  470.                             XFree (xvinfos);

  471.                         }

  472.                     }

  473.                 }

  474.                #endif

  475.                 if (visual == nullptr)

  476.                 {

  477.                     visual = findVisualWithDepth (32);

  478.                     if (visual != nullptr)

  479.                         matchedDepth = 32;

  480.                 }

  481.             }

  482.            #endif

  483.         }

  484. 

  485.         if (visual == nullptr && desiredDepth >= 24)

  486.         {

  487.             visual = findVisualWithDepth (24);

  488.             if (visual != nullptr)

  489.                 matchedDepth = 24;

  490.         }

  491. 

  492.         if (visual == nullptr && desiredDepth >= 16)

  493.         {

  494.             visual = findVisualWithDepth (16);

  495.             if (visual != nullptr)

  496.                 matchedDepth = 16;

  497.         }

  498. 

  499.         return visual;

  500.     }

  501. }

  502. 

  503. //==============================================================================

  504. class XBitmapImage  : public ImagePixelData

  505. {

  506. public:

  507.     XBitmapImage (const Image::PixelFormat format, const int w, const int h,

  508.                   const bool clearImage, const unsigned int imageDepth_, Visual* visual)

  509.         : ImagePixelData (format, w, h),

  510.           imageDepth (imageDepth_),

  511.           gc (None)

  512.     {

  513.         jassert (format == Image::RGB || format == Image::ARGB);

  514. 

  515.         pixelStride = (format == Image::RGB) ? 3 : 4;

  516.         lineStride = ((w * pixelStride + 3) & ~3);

  517. 

  518.         ScopedXLock xlock;

  519. 

  520.        #if JUCE_USE_XSHM

  521.         usingXShm = false;

  522. 

  523.         if ((imageDepth > 16) && XSHMHelpers::isShmAvailable())

  524.         {

  525.             zerostruct (segmentInfo);

  526. 

  527.             segmentInfo.shmid = -1;

  528.             segmentInfo.shmaddr = (char *) -1;

  529.             segmentInfo.readOnly = False;

  530. 

  531.             xImage = XShmCreateImage (display, visual, imageDepth, ZPixmap, 0,

  532.                                       &segmentInfo, (unsigned int) w, (unsigned int) h);

  533. 

  534.             if (xImage != nullptr)

  535.             {

  536.                 if ((segmentInfo.shmid = shmget (IPC_PRIVATE,

  537.                                                  (size_t) (xImage->bytes_per_line * xImage->height),

  538.                                                  IPC_CREAT | 0777)) >= 0)

  539.                 {

  540.                     if (segmentInfo.shmid != -1)

  541.                     {

  542.                         segmentInfo.shmaddr = (char*) shmat (segmentInfo.shmid, 0, 0);

  543. 

  544.                         if (segmentInfo.shmaddr != (void*) -1)

  545.                         {

  546.                             segmentInfo.readOnly = False;

  547. 

  548.                             xImage->data = segmentInfo.shmaddr;

  549.                             imageData = (uint8*) segmentInfo.shmaddr;

  550. 

  551.                             if (XShmAttach (display, &segmentInfo) != 0)

  552.                                 usingXShm = true;

  553.                             else

  554.                                 jassertfalse;

  555.                         }

  556.                         else

  557.                         {

  558.                             shmctl (segmentInfo.shmid, IPC_RMID, 0);

  559.                         }

  560.                     }

  561.                 }

  562.             }

  563.         }

  564. 

  565.         if (! isUsingXShm())

  566.        #endif

  567.         {

  568.             imageDataAllocated.allocate ((size_t) (lineStride * h), format == Image::ARGB && clearImage);

  569.             imageData = imageDataAllocated;

  570. 

  571.             xImage = (XImage*) ::calloc (1, sizeof (XImage));

  572. 

  573.             xImage->width = w;

  574.             xImage->height = h;

  575.             xImage->xoffset = 0;

  576.             xImage->format = ZPixmap;

  577.             xImage->data = (char*) imageData;

  578.             xImage->byte_order = ImageByteOrder (display);

  579.             xImage->bitmap_unit = BitmapUnit (display);

  580.             xImage->bitmap_bit_order = BitmapBitOrder (display);

  581.             xImage->bitmap_pad = 32;

  582.             xImage->depth = pixelStride * 8;

  583.             xImage->bytes_per_line = lineStride;

  584.             xImage->bits_per_pixel = pixelStride * 8;

  585.             xImage->red_mask   = 0x00FF0000;

  586.             xImage->green_mask = 0x0000FF00;

  587.             xImage->blue_mask  = 0x000000FF;

  588. 

  589.             if (imageDepth == 16)

  590.             {

  591.                 const int pixStride = 2;

  592.                 const int stride = ((w * pixStride + 3) & ~3);

  593. 

  594.                 imageData16Bit.malloc ((size_t) (stride * h));

  595.                 xImage->data = imageData16Bit;

  596.                 xImage->bitmap_pad = 16;

  597.                 xImage->depth = pixStride * 8;

  598.                 xImage->bytes_per_line = stride;

  599.                 xImage->bits_per_pixel = pixStride * 8;

  600.                 xImage->red_mask   = visual->red_mask;

  601.                 xImage->green_mask = visual->green_mask;

  602.                 xImage->blue_mask  = visual->blue_mask;

  603.             }

  604. 

  605.             if (! XInitImage (xImage))

  606.                 jassertfalse;

  607.         }

  608.     }

  609. 

  610.     ~XBitmapImage()

  611.     {

  612.         ScopedXLock xlock;

  613. 

  614.         if (gc != None)

  615.             XFreeGC (display, gc);

  616. 

  617.        #if JUCE_USE_XSHM

  618.         if (isUsingXShm())

  619.         {

  620.             XShmDetach (display, &segmentInfo);

  621. 

  622.             XFlush (display);

  623.             XDestroyImage (xImage);

  624. 

  625.             shmdt (segmentInfo.shmaddr);

  626.             shmctl (segmentInfo.shmid, IPC_RMID, 0);

  627.         }

  628.         else

  629.        #endif

  630.         {

  631.             xImage->data = nullptr;

  632.             XDestroyImage (xImage);

  633.         }

  634.     }

  635. 

  636.     LowLevelGraphicsContext* createLowLevelContext() override

  637.     {

  638.         sendDataChangeMessage();

  639.         return new LowLevelGraphicsSoftwareRenderer (Image (this));

  640.     }

  641. 

  642.     void initialiseBitmapData (Image::BitmapData& bitmap, int x, int y, Image::BitmapData::ReadWriteMode mode) override

  643.     {

  644.         bitmap.data = imageData + x * pixelStride + y * lineStride;

  645.         bitmap.pixelFormat = pixelFormat;

  646.         bitmap.lineStride = lineStride;

  647.         bitmap.pixelStride = pixelStride;

  648. 

  649.         if (mode != Image::BitmapData::readOnly)

  650.             sendDataChangeMessage();

  651.     }

  652. 

  653.     ImagePixelData* clone() override

  654.     {

  655.         jassertfalse;

  656.         return nullptr;

  657.     }

  658. 

  659.     ImageType* createType() const override     { return new NativeImageType(); }

  660. 

  661.     void blitToWindow (Window window, int dx, int dy, unsigned int dw, unsigned int dh, int sx, int sy)

  662.     {

  663.         ScopedXLock xlock;

  664. 

  665.         if (gc == None)

  666.         {

  667.             XGCValues gcvalues;

  668.             gcvalues.foreground = None;

  669.             gcvalues.background = None;

  670.             gcvalues.function = GXcopy;

  671.             gcvalues.plane_mask = AllPlanes;

  672.             gcvalues.clip_mask = None;

  673.             gcvalues.graphics_exposures = False;

  674. 

  675.             gc = XCreateGC (display, window,

  676.                             GCBackground | GCForeground | GCFunction | GCPlaneMask | GCClipMask | GCGraphicsExposures,

  677.                             &gcvalues);

  678.         }

  679. 

  680.         if (imageDepth == 16)

  681.         {

  682.             const uint32 rMask   = (uint32) xImage->red_mask;

  683.             const uint32 gMask   = (uint32) xImage->green_mask;

  684.             const uint32 bMask   = (uint32) xImage->blue_mask;

  685.             const uint32 rShiftL = (uint32) jmax (0,  getShiftNeeded (rMask));

  686.             const uint32 rShiftR = (uint32) jmax (0, -getShiftNeeded (rMask));

  687.             const uint32 gShiftL = (uint32) jmax (0,  getShiftNeeded (gMask));

  688.             const uint32 gShiftR = (uint32) jmax (0, -getShiftNeeded (gMask));

  689.             const uint32 bShiftL = (uint32) jmax (0,  getShiftNeeded (bMask));

  690.             const uint32 bShiftR = (uint32) jmax (0, -getShiftNeeded (bMask));

  691. 

  692.             const Image::BitmapData srcData (Image (this), Image::BitmapData::readOnly);

  693. 

  694.             for (int y = sy; y < sy + (int)dh; ++y)

  695.             {

  696.                 const uint8* p = srcData.getPixelPointer (sx, y);

  697. 

  698.                 for (int x = sx; x < sx + (int)dw; ++x)

  699.                 {

  700.                     const PixelRGB* const pixel = (const PixelRGB*) p;

  701.                     p += srcData.pixelStride;

  702. 

  703.                     XPutPixel (xImage, x, y,

  704.                                    (((((uint32) pixel->getRed())   << rShiftL) >> rShiftR) & rMask)

  705.                                  | (((((uint32) pixel->getGreen()) << gShiftL) >> gShiftR) & gMask)

  706.                                  | (((((uint32) pixel->getBlue())  << bShiftL) >> bShiftR) & bMask));

  707.                 }

  708.             }

  709.         }

  710. 

  711.         // blit results to screen.

  712.        #if JUCE_USE_XSHM

  713.         if (isUsingXShm())

  714.             XShmPutImage (display, (::Drawable) window, gc, xImage, sx, sy, dx, dy, dw, dh, True);

  715.         else

  716.        #endif

  717.             XPutImage (display, (::Drawable) window, gc, xImage, sx, sy, dx, dy, dw, dh);

  718.     }

  719. 

  720.     #if JUCE_USE_XSHM

  721.     bool isUsingXShm() const noexcept       { return usingXShm; }

  722.     #endif

  723. 

  724. private:

  725.     //==============================================================================

  726.     XImage* xImage;

  727.     const unsigned int imageDepth;

  728.     HeapBlock<uint8> imageDataAllocated;

  729.     HeapBlock<char> imageData16Bit;

  730.     int pixelStride, lineStride;

  731.     uint8* imageData;

  732.     GC gc;

  733. 

  734.    #if JUCE_USE_XSHM

  735.     XShmSegmentInfo segmentInfo;

  736.     bool usingXShm;

  737.    #endif

  738. 

  739.     static int getShiftNeeded (const uint32 mask) noexcept

  740.     {

  741.         for (int i = 32; --i >= 0;)

  742.             if (((mask >> i) & 1) != 0)

  743.                 return i - 7;

  744. 

  745.         jassertfalse;

  746.         return 0;

  747.     }

  748. 

  749.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (XBitmapImage)

  750. };

  751. 

  752. //==============================================================================

  753. namespace PixmapHelpers

  754. {

  755.     Pixmap createColourPixmapFromImage (Display* display, const Image& image)

  756.     {

  757.         ScopedXLock xlock;

  758. 

  759.         const unsigned int width = (unsigned int) image.getWidth();

  760.         const unsigned int height = (unsigned int) image.getHeight();

  761.         HeapBlock<uint32> colour (width * height);

  762.         int index = 0;

  763. 

  764.         for (int y = 0; y < (int)  height; ++y)

  765.             for (int x = 0; x < (int) width; ++x)

  766.                 colour[index++] = image.getPixelAt (x, y).getARGB();

  767. 

  768.         XImage* ximage = XCreateImage (display, CopyFromParent, 24, ZPixmap,

  769.                                        0, reinterpret_cast<char*> (colour.getData()),

  770.                                        width, height, 32, 0);

  771. 

  772.         Pixmap pixmap = XCreatePixmap (display, DefaultRootWindow (display),

  773.                                        width, height, 24);

  774. 

  775.         GC gc = XCreateGC (display, pixmap, 0, 0);

  776.         XPutImage (display, pixmap, gc, ximage, 0, 0, 0, 0, width, height);

  777.         XFreeGC (display, gc);

  778. 

  779.         return pixmap;

  780.     }

  781. 

  782.     Pixmap createMaskPixmapFromImage (Display* display, const Image& image)

  783.     {

  784.         ScopedXLock xlock;

  785. 

  786.         const unsigned int width = (unsigned int) image.getWidth();

  787.         const unsigned int height = (unsigned int) image.getHeight();

  788.         const unsigned int stride = (width + 7) >> 3;

  789.         HeapBlock<char> mask;

  790.         mask.calloc (stride * height);

  791.         const bool msbfirst = (BitmapBitOrder (display) == MSBFirst);

  792. 

  793.         for (unsigned int y = 0; y < height; ++y)

  794.         {

  795.             for (unsigned int x = 0; x < width; ++x)

  796.             {

  797.                 const char bit = (char) (1 << (msbfirst ? (7 - (x & 7)) : (x & 7)));

  798.                 const unsigned int offset = y * stride + (x >> 3);

  799. 

  800.                 if (image.getPixelAt ((int) x, (int) y).getAlpha() >= 128)

  801.                     mask[offset] |= bit;

  802.             }

  803.         }

  804. 

  805.         return XCreatePixmapFromBitmapData (display, DefaultRootWindow (display),

  806.                                             mask.getData(), width, height, 1, 0, 1);

  807.     }

  808. }

  809. 

  810. static void* createDraggingHandCursor()

  811. {

  812.     static unsigned char dragHandData[] = { 71,73,70,56,57,97,16,0,16,0,145,2,0,0,0,0,255,255,255,0,

  813.       0,0,0,0,0,33,249,4,1,0,0,2,0,44,0,0,0,0,16,0, 16,0,0,2,52,148,47,0,200,185,16,130,90,12,74,139,107,84,123,39,

  814.       132,117,151,116,132,146,248,60,209,138,98,22,203,114,34,236,37,52,77,217, 247,154,191,119,110,240,193,128,193,95,163,56,60,234,98,135,2,0,59 };

  815.     const int dragHandDataSize = 99;

  816. 

  817.     return CustomMouseCursorInfo (ImageFileFormat::loadFrom (dragHandData, dragHandDataSize), 8, 7).create();

  818. }

  819. 

  820. //==============================================================================

  821. static int numAlwaysOnTopPeers = 0;

  822. 

  823. bool juce_areThereAnyAlwaysOnTopWindows()

  824. {

  825.     return numAlwaysOnTopPeers > 0;

  826. }

  827. 

  828. //==============================================================================

  829. class LinuxComponentPeer  : public ComponentPeer

  830. {

  831. public:

  832.     LinuxComponentPeer (Component& comp, const int windowStyleFlags, Window parentToAddTo)

  833.         : ComponentPeer (comp, windowStyleFlags),

  834.           windowH (0), parentWindow (0),

  835.           fullScreen (false), mapped (false),

  836.           visual (nullptr), depth (0),

  837.           isAlwaysOnTop (comp.isAlwaysOnTop())

  838.     {

  839.         // it's dangerous to create a window on a thread other than the message thread..

  840.         jassert (MessageManager::getInstance()->currentThreadHasLockedMessageManager());

  841. 

  842.         dispatchWindowMessage = windowMessageReceive;

  843.         repainter = new LinuxRepaintManager (*this);

  844. 

  845.         if (isAlwaysOnTop)

  846.             ++numAlwaysOnTopPeers;

  847. 

  848.         createWindow (parentToAddTo);

  849. 

  850.         setTitle (component.getName());

  851.     }

  852. 

  853.     ~LinuxComponentPeer()

  854.     {

  855.         // it's dangerous to delete a window on a thread other than the message thread..

  856.         jassert (MessageManager::getInstance()->currentThreadHasLockedMessageManager());

  857. 

  858.         deleteIconPixmaps();

  859.         destroyWindow();

  860.         windowH = 0;

  861. 

  862.         if (isAlwaysOnTop)

  863.             --numAlwaysOnTopPeers;

  864.     }

  865. 

  866.     // (this callback is hooked up in the messaging code)

  867.     static void windowMessageReceive (XEvent& event)

  868.     {

  869.         if (event.xany.window != None)

  870.         {

  871.             if (LinuxComponentPeer* const peer = getPeerFor (event.xany.window))

  872.                 peer->handleWindowMessage (event);

  873.         }

  874.         else if (event.xany.type == KeymapNotify)

  875.         {

  876.             const XKeymapEvent& keymapEvent = (const XKeymapEvent&) event.xkeymap;

  877.             memcpy (Keys::keyStates, keymapEvent.key_vector, 32);

  878.         }

  879.     }

  880. 

  881.     //==============================================================================

  882.     void* getNativeHandle() const override

  883.     {

  884.         return (void*) windowH;

  885.     }

  886. 

  887.     static LinuxComponentPeer* getPeerFor (Window windowHandle) noexcept

  888.     {

  889.         XPointer peer = nullptr;

  890. 

  891.         if (display != nullptr)

  892.         {

  893.             ScopedXLock xlock;

  894. 

  895.             if (! XFindContext (display, (XID) windowHandle, windowHandleXContext, &peer))

  896.                 if (peer != nullptr && ! ComponentPeer::isValidPeer (reinterpret_cast<LinuxComponentPeer*> (peer)))

  897.                     peer = nullptr;

  898.         }

  899. 

  900.         return reinterpret_cast<LinuxComponentPeer*> (peer);

  901.     }

  902. 

  903.     void setVisible (bool shouldBeVisible) override

  904.     {

  905.         ScopedXLock xlock;

  906. 

  907.         if (shouldBeVisible)

  908.             XMapWindow (display, windowH);

  909.         else

  910.             XUnmapWindow (display, windowH);

  911.     }

  912. 

  913.     void setTitle (const String& title) override

  914.     {

  915.         XTextProperty nameProperty;

  916.         char* strings[] = { const_cast<char*> (title.toRawUTF8()) };

  917.         ScopedXLock xlock;

  918. 

  919.         if (XStringListToTextProperty (strings, 1, &nameProperty))

  920.         {

  921.             XSetWMName (display, windowH, &nameProperty);

  922.             XSetWMIconName (display, windowH, &nameProperty);

  923. 

  924.             XFree (nameProperty.value);

  925.         }

  926.     }

  927. 

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

  929.     {

  930.         if (fullScreen && ! isNowFullScreen)

  931.         {

  932.             // When transitioning back from fullscreen, we might need to remove

  933.             // the FULLSCREEN window property

  934.             Atom fs = Atoms::getIfExists ("_NET_WM_STATE_FULLSCREEN");

  935. 

  936.             if (fs != None)

  937.             {

  938.                 Window root = RootWindow (display, DefaultScreen (display));

  939. 

  940.                 XClientMessageEvent clientMsg;

  941.                 clientMsg.display = display;

  942.                 clientMsg.window = windowH;

  943.                 clientMsg.type = ClientMessage;

  944.                 clientMsg.format = 32;

  945.                 clientMsg.message_type = Atoms::get().windowState;

  946.                 clientMsg.data.l[0] = 0;  // Remove

  947.                 clientMsg.data.l[1] = (long) fs;

  948.                 clientMsg.data.l[2] = 0;

  949.                 clientMsg.data.l[3] = 1;  // Normal Source

  950. 

  951.                 ScopedXLock xlock;

  952.                 XSendEvent (display, root, false,

  953.                             SubstructureRedirectMask | SubstructureNotifyMask,

  954.                             (XEvent*) &clientMsg);

  955.             }

  956.         }

  957. 

  958.         fullScreen = isNowFullScreen;

  959. 

  960.         if (windowH != 0)

  961.         {

  962.             bounds = newBounds.withSize (jmax (1, newBounds.getWidth()),

  963.                                          jmax (1, newBounds.getHeight()));

  964. 

  965.             WeakReference<Component> deletionChecker (&component);

  966.             ScopedXLock xlock;

  967. 

  968.             XSizeHints* const hints = XAllocSizeHints();

  969.             hints->flags  = USSize | USPosition;

  970.             hints->x      = bounds.getX();

  971.             hints->y      = bounds.getY();

  972.             hints->width  = bounds.getWidth();

  973.             hints->height = bounds.getHeight();

  974. 

  975.             if ((getStyleFlags() & (windowHasTitleBar | windowIsResizable)) == windowHasTitleBar)

  976.             {

  977.                 hints->min_width  = hints->max_width  = hints->width;

  978.                 hints->min_height = hints->max_height = hints->height;

  979.                 hints->flags |= PMinSize | PMaxSize;

  980.             }

  981. 

  982.             XSetWMNormalHints (display, windowH, hints);

  983.             XFree (hints);

  984. 

  985.             XMoveResizeWindow (display, windowH,

  986.                                bounds.getX() - windowBorder.getLeft(),

  987.                                bounds.getY() - windowBorder.getTop(),

  988.                                (unsigned int) bounds.getWidth(),

  989.                                (unsigned int) bounds.getHeight());

  990. 

  991.             if (deletionChecker != nullptr)

  992.             {

  993.                 updateBorderSize();

  994.                 handleMovedOrResized();

  995.             }

  996.         }

  997.     }

  998. 

  999.     Rectangle<int> getBounds() const override          { return bounds; }

  1000. 

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

  1002.     {

  1003.         return relativePosition + bounds.getPosition().toFloat();

  1004.     }

  1005. 

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

  1007.     {

  1008.         return screenPosition - bounds.getPosition().toFloat();

  1009.     }

  1010. 

  1011.     void setAlpha (float /* newAlpha */) override

  1012.     {

  1013.         //xxx todo!

  1014.     }

  1015. 

  1016.     StringArray getAvailableRenderingEngines() override

  1017.     {

  1018.         return StringArray ("Software Renderer");

  1019.     }

  1020. 

  1021.     void setMinimised (bool shouldBeMinimised) override

  1022.     {

  1023.         if (shouldBeMinimised)

  1024.         {

  1025.             Window root = RootWindow (display, DefaultScreen (display));

  1026. 

  1027.             XClientMessageEvent clientMsg;

  1028.             clientMsg.display = display;

  1029.             clientMsg.window = windowH;

  1030.             clientMsg.type = ClientMessage;

  1031.             clientMsg.format = 32;

  1032.             clientMsg.message_type = Atoms::get().changeState;

  1033.             clientMsg.data.l[0] = IconicState;

  1034. 

  1035.             ScopedXLock xlock;

  1036.             XSendEvent (display, root, false, SubstructureRedirectMask | SubstructureNotifyMask, (XEvent*) &clientMsg);

  1037.         }

  1038.         else

  1039.         {

  1040.             setVisible (true);

  1041.         }

  1042.     }

  1043. 

  1044.     bool isMinimised() const override

  1045.     {

  1046.         ScopedXLock xlock;

  1047.         const Atoms& atoms = Atoms::get();

  1048.         GetXProperty prop (windowH, atoms.state, 0, 64, false, atoms.state);

  1049. 

  1050.         return prop.success

  1051.                 && prop.actualType == atoms.state

  1052.                 && prop.actualFormat == 32

  1053.                 && prop.numItems > 0

  1054.                 && ((unsigned long*) prop.data)[0] == IconicState;

  1055.     }

  1056. 

  1057.     void setFullScreen (const bool shouldBeFullScreen) override

  1058.     {

  1059.         Rectangle<int> r (lastNonFullscreenBounds); // (get a copy of this before de-minimising)

  1060. 

  1061.         setMinimised (false);

  1062. 

  1063.         if (fullScreen != shouldBeFullScreen)

  1064.         {

  1065.             if (shouldBeFullScreen)

  1066.                 r = Desktop::getInstance().getDisplays().getMainDisplay().userArea;

  1067. 

  1068.             if (! r.isEmpty())

  1069.                 setBounds (ScalingHelpers::scaledScreenPosToUnscaled (component, r), shouldBeFullScreen);

  1070. 

  1071.             component.repaint();

  1072.         }

  1073.     }

  1074. 

  1075.     bool isFullScreen() const override

  1076.     {

  1077.         return fullScreen;

  1078.     }

  1079. 

  1080.     bool isChildWindowOf (Window possibleParent) const

  1081.     {

  1082.         Window* windowList = nullptr;

  1083.         uint32 windowListSize = 0;

  1084.         Window parent, root;

  1085. 

  1086.         ScopedXLock xlock;

  1087.         if (XQueryTree (display, windowH, &root, &parent, &windowList, &windowListSize) != 0)

  1088.         {

  1089.             if (windowList != nullptr)

  1090.                 XFree (windowList);

  1091. 

  1092.             return parent == possibleParent;

  1093.         }

  1094. 

  1095.         return false;

  1096.     }

  1097. 

  1098.     bool isFrontWindow() const

  1099.     {

  1100.         Window* windowList = nullptr;

  1101.         uint32 windowListSize = 0;

  1102.         bool result = false;

  1103. 

  1104.         ScopedXLock xlock;

  1105.         Window parent, root = RootWindow (display, DefaultScreen (display));

  1106. 

  1107.         if (XQueryTree (display, root, &root, &parent, &windowList, &windowListSize) != 0)

  1108.         {

  1109.             for (int i = (int) windowListSize; --i >= 0;)

  1110.             {

  1111.                 if (LinuxComponentPeer* const peer = LinuxComponentPeer::getPeerFor (windowList[i]))

  1112.                 {

  1113.                     result = (peer == this);

  1114.                     break;

  1115.                 }

  1116.             }

  1117.         }

  1118. 

  1119.         if (windowList != nullptr)

  1120.             XFree (windowList);

  1121. 

  1122.         return result;

  1123.     }

  1124. 

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

  1126.     {

  1127.         if (! bounds.withZeroOrigin().contains (localPos))

  1128.             return false;

  1129. 

  1130.         for (int i = Desktop::getInstance().getNumComponents(); --i >= 0;)

  1131.         {

  1132.             Component* const c = Desktop::getInstance().getComponent (i);

  1133. 

  1134.             if (c == &component)

  1135.                 break;

  1136. 

  1137.             if (ComponentPeer* peer = c->getPeer())

  1138.                 if (peer->contains (localPos + bounds.getPosition() - peer->getBounds().getPosition(), true))

  1139.                     return false;

  1140.         }

  1141. 

  1142.         if (trueIfInAChildWindow)

  1143.             return true;

  1144. 

  1145.         ::Window root, child;

  1146.         int wx, wy;

  1147.         unsigned int ww, wh, bw, bitDepth;

  1148. 

  1149.         ScopedXLock xlock;

  1150. 

  1151.         return XGetGeometry (display, (::Drawable) windowH, &root, &wx, &wy, &ww, &wh, &bw, &bitDepth)

  1152.                 && XTranslateCoordinates (display, windowH, windowH, localPos.getX(), localPos.getY(), &wx, &wy, &child)

  1153.                 && child == None;

  1154.     }

  1155. 

  1156.     BorderSize<int> getFrameSize() const override

  1157.     {

  1158.         return BorderSize<int>();

  1159.     }

  1160. 

  1161.     bool setAlwaysOnTop (bool /* alwaysOnTop */) override

  1162.     {

  1163.         return false;

  1164.     }

  1165. 

  1166.     void toFront (bool makeActive) override

  1167.     {

  1168.         if (makeActive)

  1169.         {

  1170.             setVisible (true);

  1171.             grabFocus();

  1172.         }

  1173. 

  1174.         {

  1175.             ScopedXLock xlock;

  1176.             XEvent ev;

  1177.             ev.xclient.type = ClientMessage;

  1178.             ev.xclient.serial = 0;

  1179.             ev.xclient.send_event = True;

  1180.             ev.xclient.message_type = Atoms::get().activeWin;

  1181.             ev.xclient.window = windowH;

  1182.             ev.xclient.format = 32;

  1183.             ev.xclient.data.l[0] = 2;

  1184.             ev.xclient.data.l[1] = getUserTime();

  1185.             ev.xclient.data.l[2] = 0;

  1186.             ev.xclient.data.l[3] = 0;

  1187.             ev.xclient.data.l[4] = 0;

  1188. 

  1189.             XSendEvent (display, RootWindow (display, DefaultScreen (display)),

  1190.                         False, SubstructureRedirectMask | SubstructureNotifyMask, &ev);

  1191. 

  1192.             XWindowAttributes attr;

  1193.             XGetWindowAttributes (display, windowH, &attr);

  1194. 

  1195.             if (component.isAlwaysOnTop())

  1196.                 XRaiseWindow (display, windowH);

  1197. 

  1198.             XSync (display, False);

  1199.         }

  1200. 

  1201.         handleBroughtToFront();

  1202.     }

  1203. 

  1204.     void toBehind (ComponentPeer* other) override

  1205.     {

  1206.         if (LinuxComponentPeer* const otherPeer = dynamic_cast<LinuxComponentPeer*> (other))

  1207.         {

  1208.             setMinimised (false);

  1209. 

  1210.             Window newStack[] = { otherPeer->windowH, windowH };

  1211. 

  1212.             ScopedXLock xlock;

  1213.             XRestackWindows (display, newStack, 2);

  1214.         }

  1215.         else

  1216.             jassertfalse; // wrong type of window?

  1217.     }

  1218. 

  1219.     bool isFocused() const override

  1220.     {

  1221.         int revert = 0;

  1222.         Window focusedWindow = 0;

  1223.         ScopedXLock xlock;

  1224.         XGetInputFocus (display, &focusedWindow, &revert);

  1225. 

  1226.         return focusedWindow == windowH;

  1227.     }

  1228. 

  1229.     void grabFocus() override

  1230.     {

  1231.         XWindowAttributes atts;

  1232.         ScopedXLock xlock;

  1233. 

  1234.         if (windowH != 0

  1235.             && XGetWindowAttributes (display, windowH, &atts)

  1236.             && atts.map_state == IsViewable

  1237.             && ! isFocused())

  1238.         {

  1239.             XSetInputFocus (display, windowH, RevertToParent, (::Time) getUserTime());

  1240.             isActiveApplication = true;

  1241.         }

  1242.     }

  1243. 

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

  1245. 

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

  1247.     {

  1248.         repainter->repaint (area.getIntersection (bounds.withZeroOrigin()));

  1249.     }

  1250. 

  1251.     void performAnyPendingRepaintsNow() override

  1252.     {

  1253.         repainter->performAnyPendingRepaintsNow();

  1254.     }

  1255. 

  1256.     void setIcon (const Image& newIcon) override

  1257.     {

  1258.         const int dataSize = newIcon.getWidth() * newIcon.getHeight() + 2;

  1259.         HeapBlock<unsigned long> data ((size_t) dataSize);

  1260. 

  1261.         int index = 0;

  1262.         data[index++] = (unsigned long) newIcon.getWidth();

  1263.         data[index++] = (unsigned long) newIcon.getHeight();

  1264. 

  1265.         for (int y = 0; y < newIcon.getHeight(); ++y)

  1266.             for (int x = 0; x < newIcon.getWidth(); ++x)

  1267.                 data[index++] = (unsigned long) newIcon.getPixelAt (x, y).getARGB();

  1268. 

  1269.         ScopedXLock xlock;

  1270.         xchangeProperty (windowH, Atoms::getCreating ("_NET_WM_ICON"), XA_CARDINAL, 32, data.getData(), dataSize);

  1271. 

  1272.         deleteIconPixmaps();

  1273. 

  1274.         XWMHints* wmHints = XGetWMHints (display, windowH);

  1275. 

  1276.         if (wmHints == nullptr)

  1277.             wmHints = XAllocWMHints();

  1278. 

  1279.         wmHints->flags |= IconPixmapHint | IconMaskHint;

  1280.         wmHints->icon_pixmap = PixmapHelpers::createColourPixmapFromImage (display, newIcon);

  1281.         wmHints->icon_mask = PixmapHelpers::createMaskPixmapFromImage (display, newIcon);

  1282. 

  1283.         XSetWMHints (display, windowH, wmHints);

  1284.         XFree (wmHints);

  1285. 

  1286.         XSync (display, False);

  1287.     }

  1288. 

  1289.     void deleteIconPixmaps()

  1290.     {

  1291.         ScopedXLock xlock;

  1292.         XWMHints* wmHints = XGetWMHints (display, windowH);

  1293. 

  1294.         if (wmHints != nullptr)

  1295.         {

  1296.             if ((wmHints->flags & IconPixmapHint) != 0)

  1297.             {

  1298.                 wmHints->flags &= ~IconPixmapHint;

  1299.                 XFreePixmap (display, wmHints->icon_pixmap);

  1300.             }

  1301. 

  1302.             if ((wmHints->flags & IconMaskHint) != 0)

  1303.             {

  1304.                 wmHints->flags &= ~IconMaskHint;

  1305.                 XFreePixmap (display, wmHints->icon_mask);

  1306.             }

  1307. 

  1308.             XSetWMHints (display, windowH, wmHints);

  1309.             XFree (wmHints);

  1310.         }

  1311.     }

  1312. 

  1313.     //==============================================================================

  1314.     void handleWindowMessage (XEvent& event)

  1315.     {

  1316.         switch (event.xany.type)

  1317.         {

  1318.             case KeyPressEventType:     handleKeyPressEvent (event.xkey); break;

  1319.             case KeyRelease:            handleKeyReleaseEvent (event.xkey); break;

  1320.             case ButtonPress:           handleButtonPressEvent (event.xbutton); break;

  1321.             case ButtonRelease:         handleButtonReleaseEvent (event.xbutton); break;

  1322.             case MotionNotify:          handleMotionNotifyEvent (event.xmotion); break;

  1323.             case EnterNotify:           handleEnterNotifyEvent (event.xcrossing); break;

  1324.             case LeaveNotify:           handleLeaveNotifyEvent (event.xcrossing); break;

  1325.             case FocusIn:               handleFocusInEvent(); break;

  1326.             case FocusOut:              handleFocusOutEvent(); break;

  1327.             case Expose:                handleExposeEvent (event.xexpose); break;

  1328.             case MappingNotify:         handleMappingNotify (event.xmapping); break;

  1329.             case ClientMessage:         handleClientMessageEvent (event.xclient, event); break;

  1330.             case SelectionNotify:       handleDragAndDropSelection (event); break;

  1331.             case ConfigureNotify:       handleConfigureNotifyEvent (event.xconfigure); break;

  1332.             case ReparentNotify:        handleReparentNotifyEvent(); break;

  1333.             case GravityNotify:         handleGravityNotify(); break;

  1334.             case SelectionClear:        handleExternalSelectionClear(); break;

  1335.             case SelectionRequest:      handleExternalSelectionRequest (event); break;

  1336. 

  1337.             case CirculateNotify:

  1338.             case CreateNotify:

  1339.             case DestroyNotify:

  1340.                 // Think we can ignore these

  1341.                 break;

  1342. 

  1343.             case MapNotify:

  1344.                 mapped = true;

  1345.                 handleBroughtToFront();

  1346.                 break;

  1347. 

  1348.             case UnmapNotify:

  1349.                 mapped = false;

  1350.                 break;

  1351. 

  1352.             default:

  1353.                #if JUCE_USE_XSHM

  1354.                 if (XSHMHelpers::isShmAvailable())

  1355.                 {

  1356.                     ScopedXLock xlock;

  1357.                     if (event.xany.type == XShmGetEventBase (display))

  1358.                         repainter->notifyPaintCompleted();

  1359.                 }

  1360.                #endif

  1361.                 break;

  1362.         }

  1363.     }

  1364. 

  1365.     void handleKeyPressEvent (XKeyEvent& keyEvent)

  1366.     {

  1367.         char utf8 [64] = { 0 };

  1368.         juce_wchar unicodeChar = 0;

  1369.         int keyCode = 0;

  1370.         bool keyDownChange = false;

  1371.         KeySym sym;

  1372. 

  1373.         {

  1374.             ScopedXLock xlock;

  1375.             updateKeyStates ((int) keyEvent.keycode, true);

  1376. 

  1377.             String oldLocale (::setlocale (LC_ALL, 0));

  1378.             ::setlocale (LC_ALL, "");

  1379.             XLookupString (&keyEvent, utf8, sizeof (utf8), &sym, 0);

  1380. 

  1381.             if (oldLocale.isNotEmpty())

  1382.                 ::setlocale (LC_ALL, oldLocale.toRawUTF8());

  1383. 

  1384.             unicodeChar = *CharPointer_UTF8 (utf8);

  1385.             keyCode = (int) unicodeChar;

  1386. 

  1387.             if (keyCode < 0x20)

  1388.                 keyCode = (int) XkbKeycodeToKeysym (display, (::KeyCode) keyEvent.keycode, 0, currentModifiers.isShiftDown() ? 1 : 0);

  1389. 

  1390.             keyDownChange = (sym != NoSymbol) && ! updateKeyModifiersFromSym (sym, true);

  1391.         }

  1392. 

  1393.         const ModifierKeys oldMods (currentModifiers);

  1394.         bool keyPressed = false;

  1395. 

  1396.         if ((sym & 0xff00) == 0xff00 || keyCode == XK_ISO_Left_Tab)

  1397.         {

  1398.             switch (sym)  // Translate keypad

  1399.             {

  1400.                 case XK_KP_Add:         keyCode = XK_plus; break;

  1401.                 case XK_KP_Subtract:    keyCode = XK_hyphen; break;

  1402.                 case XK_KP_Divide:      keyCode = XK_slash; break;

  1403.                 case XK_KP_Multiply:    keyCode = XK_asterisk; break;

  1404.                 case XK_KP_Enter:       keyCode = XK_Return; break;

  1405.                 case XK_KP_Insert:      keyCode = XK_Insert; break;

  1406.                 case XK_Delete:

  1407.                 case XK_KP_Delete:      keyCode = XK_Delete; break;

  1408.                 case XK_KP_Left:        keyCode = XK_Left; break;

  1409.                 case XK_KP_Right:       keyCode = XK_Right; break;

  1410.                 case XK_KP_Up:          keyCode = XK_Up; break;

  1411.                 case XK_KP_Down:        keyCode = XK_Down; break;

  1412.                 case XK_KP_Home:        keyCode = XK_Home; break;

  1413.                 case XK_KP_End:         keyCode = XK_End; break;

  1414.                 case XK_KP_Page_Down:   keyCode = XK_Page_Down; break;

  1415.                 case XK_KP_Page_Up:     keyCode = XK_Page_Up; break;

  1416. 

  1417.                 case XK_KP_0:           keyCode = XK_0; break;

  1418.                 case XK_KP_1:           keyCode = XK_1; break;

  1419.                 case XK_KP_2:           keyCode = XK_2; break;

  1420.                 case XK_KP_3:           keyCode = XK_3; break;

  1421.                 case XK_KP_4:           keyCode = XK_4; break;

  1422.                 case XK_KP_5:           keyCode = XK_5; break;

  1423.                 case XK_KP_6:           keyCode = XK_6; break;

  1424.                 case XK_KP_7:           keyCode = XK_7; break;

  1425.                 case XK_KP_8:           keyCode = XK_8; break;

  1426.                 case XK_KP_9:           keyCode = XK_9; break;

  1427. 

  1428.                 default:                break;

  1429.             }

  1430. 

  1431.             switch (keyCode)

  1432.             {

  1433.                 case XK_Left:

  1434.                 case XK_Right:

  1435.                 case XK_Up:

  1436.                 case XK_Down:

  1437.                 case XK_Page_Up:

  1438.                 case XK_Page_Down:

  1439.                 case XK_End:

  1440.                 case XK_Home:

  1441.                 case XK_Delete:

  1442.                 case XK_Insert:

  1443.                     keyPressed = true;

  1444.                     keyCode = (keyCode & 0xff) | Keys::extendedKeyModifier;

  1445.                     break;

  1446. 

  1447.                 case XK_Tab:

  1448.                 case XK_Return:

  1449.                 case XK_Escape:

  1450.                 case XK_BackSpace:

  1451.                     keyPressed = true;

  1452.                     keyCode &= 0xff;

  1453.                     break;

  1454. 

  1455.                 case XK_ISO_Left_Tab:

  1456.                     keyPressed = true;

  1457.                     keyCode = XK_Tab & 0xff;

  1458.                     break;

  1459. 

  1460.                 default:

  1461.                     if (sym >= XK_F1 && sym <= XK_F16)

  1462.                     {

  1463.                         keyPressed = true;

  1464.                         keyCode = (sym & 0xff) | Keys::extendedKeyModifier;

  1465.                     }

  1466.                     break;

  1467.             }

  1468.         }

  1469. 

  1470.         if (utf8[0] != 0 || ((sym & 0xff00) == 0 && sym >= 8))

  1471.             keyPressed = true;

  1472. 

  1473.         if (oldMods != currentModifiers)

  1474.             handleModifierKeysChange();

  1475. 

  1476.         if (keyDownChange)

  1477.             handleKeyUpOrDown (true);

  1478. 

  1479.         if (keyPressed)

  1480.             handleKeyPress (keyCode, unicodeChar);

  1481.     }

  1482. 

  1483.     static bool isKeyReleasePartOfAutoRepeat (const XKeyEvent& keyReleaseEvent)

  1484.     {

  1485.         if (XPending (display))

  1486.         {

  1487.             XEvent e;

  1488.             XPeekEvent (display, &e);

  1489. 

  1490.             // Look for a subsequent key-down event with the same timestamp and keycode

  1491.             return e.type == KeyPressEventType

  1492.                     && e.xkey.keycode == keyReleaseEvent.keycode

  1493.                     && e.xkey.time == keyReleaseEvent.time;

  1494.         }

  1495. 

  1496.         return false;

  1497.     }

  1498. 

  1499.     void handleKeyReleaseEvent (const XKeyEvent& keyEvent)

  1500.     {

  1501.         if (! isKeyReleasePartOfAutoRepeat (keyEvent))

  1502.         {

  1503.             updateKeyStates ((int) keyEvent.keycode, false);

  1504.             KeySym sym;

  1505. 

  1506.             {

  1507.                 ScopedXLock xlock;

  1508.                 sym = XkbKeycodeToKeysym (display, (::KeyCode) keyEvent.keycode, 0, 0);

  1509.             }

  1510. 

  1511.             const ModifierKeys oldMods (currentModifiers);

  1512.             const bool keyDownChange = (sym != NoSymbol) && ! updateKeyModifiersFromSym (sym, false);

  1513. 

  1514.             if (oldMods != currentModifiers)

  1515.                 handleModifierKeysChange();

  1516. 

  1517.             if (keyDownChange)

  1518.                 handleKeyUpOrDown (false);

  1519.         }

  1520.     }

  1521. 

  1522.     template <typename EventType>

  1523.     static Point<float> getMousePos (const EventType& e) noexcept

  1524.     {

  1525.         return Point<float> ((float) e.x, (float) e.y);

  1526.     }

  1527. 

  1528.     void handleWheelEvent (const XButtonPressedEvent& buttonPressEvent, const float amount)

  1529.     {

  1530.         MouseWheelDetails wheel;

  1531.         wheel.deltaX = 0.0f;

  1532.         wheel.deltaY = amount;

  1533.         wheel.isReversed = false;

  1534.         wheel.isSmooth = false;

  1535. 

  1536.         handleMouseWheel (0, getMousePos (buttonPressEvent), getEventTime (buttonPressEvent), wheel);

  1537.     }

  1538. 

  1539.     void handleButtonPressEvent (const XButtonPressedEvent& buttonPressEvent, int buttonModifierFlag)

  1540.     {

  1541.         currentModifiers = currentModifiers.withFlags (buttonModifierFlag);

  1542.         toFront (true);

  1543.         handleMouseEvent (0, getMousePos (buttonPressEvent), currentModifiers, getEventTime (buttonPressEvent));

  1544.     }

  1545. 

  1546.     void handleButtonPressEvent (const XButtonPressedEvent& buttonPressEvent)

  1547.     {

  1548.         updateKeyModifiers ((int) buttonPressEvent.state);

  1549. 

  1550.         switch (pointerMap [buttonPressEvent.button - Button1])

  1551.         {

  1552.             case Keys::WheelUp:         handleWheelEvent (buttonPressEvent,  50.0f / 256.0f); break;

  1553.             case Keys::WheelDown:       handleWheelEvent (buttonPressEvent, -50.0f / 256.0f); break;

  1554.             case Keys::LeftButton:      handleButtonPressEvent (buttonPressEvent, ModifierKeys::leftButtonModifier); break;

  1555.             case Keys::RightButton:     handleButtonPressEvent (buttonPressEvent, ModifierKeys::rightButtonModifier); break;

  1556.             case Keys::MiddleButton:    handleButtonPressEvent (buttonPressEvent, ModifierKeys::middleButtonModifier); break;

  1557.             default: break;

  1558.         }

  1559. 

  1560.         clearLastMousePos();

  1561.     }

  1562. 

  1563.     void handleButtonReleaseEvent (const XButtonReleasedEvent& buttonRelEvent)

  1564.     {

  1565.         updateKeyModifiers ((int) buttonRelEvent.state);

  1566. 

  1567.         if (parentWindow != 0)

  1568.             updateWindowBounds();

  1569. 

  1570.         switch (pointerMap [buttonRelEvent.button - Button1])

  1571.         {

  1572.             case Keys::LeftButton:      currentModifiers = currentModifiers.withoutFlags (ModifierKeys::leftButtonModifier); break;

  1573.             case Keys::RightButton:     currentModifiers = currentModifiers.withoutFlags (ModifierKeys::rightButtonModifier); break;

  1574.             case Keys::MiddleButton:    currentModifiers = currentModifiers.withoutFlags (ModifierKeys::middleButtonModifier); break;

  1575.             default: break;

  1576.         }

  1577. 

  1578.         if (dragState.dragging)

  1579.             handleExternalDragButtonReleaseEvent();

  1580. 

  1581.         handleMouseEvent (0, getMousePos (buttonRelEvent), currentModifiers, getEventTime (buttonRelEvent));

  1582. 

  1583.         clearLastMousePos();

  1584.     }

  1585. 

  1586.     void handleMotionNotifyEvent (const XPointerMovedEvent& movedEvent)

  1587.     {

  1588.         updateKeyModifiers ((int) movedEvent.state);

  1589. 

  1590.         lastMousePos = Point<int> (movedEvent.x_root, movedEvent.y_root);

  1591. 

  1592.         if (dragState.dragging)

  1593.             handleExternalDragMotionNotify();

  1594. 

  1595.         handleMouseEvent (0, getMousePos (movedEvent), currentModifiers, getEventTime (movedEvent));

  1596.     }

  1597. 

  1598.     void handleEnterNotifyEvent (const XEnterWindowEvent& enterEvent)

  1599.     {

  1600.         if (parentWindow != 0)

  1601.             updateWindowBounds();

  1602. 

  1603.         clearLastMousePos();

  1604. 

  1605.         if (! currentModifiers.isAnyMouseButtonDown())

  1606.         {

  1607.             updateKeyModifiers ((int) enterEvent.state);

  1608.             handleMouseEvent (0, getMousePos (enterEvent), currentModifiers, getEventTime (enterEvent));

  1609.         }

  1610.     }

  1611. 

  1612.     void handleLeaveNotifyEvent (const XLeaveWindowEvent& leaveEvent)

  1613.     {

  1614.         // Suppress the normal leave if we've got a pointer grab, or if

  1615.         // it's a bogus one caused by clicking a mouse button when running

  1616.         // in a Window manager

  1617.         if (((! currentModifiers.isAnyMouseButtonDown()) && leaveEvent.mode == NotifyNormal)

  1618.              || leaveEvent.mode == NotifyUngrab)

  1619.         {

  1620.             updateKeyModifiers ((int) leaveEvent.state);

  1621.             handleMouseEvent (0, getMousePos (leaveEvent), currentModifiers, getEventTime (leaveEvent));

  1622.         }

  1623.     }

  1624. 

  1625.     void handleFocusInEvent()

  1626.     {

  1627.         isActiveApplication = true;

  1628.         if (isFocused())

  1629.             handleFocusGain();

  1630.     }

  1631. 

  1632.     void handleFocusOutEvent()

  1633.     {

  1634.         isActiveApplication = false;

  1635.         if (! isFocused())

  1636.             handleFocusLoss();

  1637.     }

  1638. 

  1639.     void handleExposeEvent (XExposeEvent& exposeEvent)

  1640.     {

  1641.         // Batch together all pending expose events

  1642.         XEvent nextEvent;

  1643.         ScopedXLock xlock;

  1644. 

  1645.         if (exposeEvent.window != windowH)

  1646.         {

  1647.             Window child;

  1648.             XTranslateCoordinates (display, exposeEvent.window, windowH,

  1649.                                    exposeEvent.x, exposeEvent.y, &exposeEvent.x, &exposeEvent.y,

  1650.                                    &child);

  1651.         }

  1652. 

  1653.         repaint (Rectangle<int> (exposeEvent.x, exposeEvent.y,

  1654.                                  exposeEvent.width, exposeEvent.height));

  1655. 

  1656.         while (XEventsQueued (display, QueuedAfterFlush) > 0)

  1657.         {

  1658.             XPeekEvent (display, &nextEvent);

  1659.             if (nextEvent.type != Expose || nextEvent.xany.window != exposeEvent.window)

  1660.                 break;

  1661. 

  1662.             XNextEvent (display, &nextEvent);

  1663.             const XExposeEvent& nextExposeEvent = (const XExposeEvent&) nextEvent.xexpose;

  1664.             repaint (Rectangle<int> (nextExposeEvent.x, nextExposeEvent.y,

  1665.                                      nextExposeEvent.width, nextExposeEvent.height));

  1666.         }

  1667.     }

  1668. 

  1669.     void handleConfigureNotifyEvent (XConfigureEvent& confEvent)

  1670.     {

  1671.         updateWindowBounds();

  1672.         updateBorderSize();

  1673.         handleMovedOrResized();

  1674. 

  1675.         // if the native title bar is dragged, need to tell any active menus, etc.

  1676.         if ((styleFlags & windowHasTitleBar) != 0

  1677.               && component.isCurrentlyBlockedByAnotherModalComponent())

  1678.         {

  1679.             if (Component* const currentModalComp = Component::getCurrentlyModalComponent())

  1680.                 currentModalComp->inputAttemptWhenModal();

  1681.         }

  1682. 

  1683.         if (confEvent.window == windowH

  1684.              && confEvent.above != 0

  1685.              && isFrontWindow())

  1686.         {

  1687.             handleBroughtToFront();

  1688.         }

  1689.     }

  1690. 

  1691.     void handleReparentNotifyEvent()

  1692.     {

  1693.         parentWindow = 0;

  1694.         Window wRoot = 0;

  1695.         Window* wChild = nullptr;

  1696.         unsigned int numChildren;

  1697. 

  1698.         {

  1699.             ScopedXLock xlock;

  1700.             XQueryTree (display, windowH, &wRoot, &parentWindow, &wChild, &numChildren);

  1701.         }

  1702. 

  1703.         if (parentWindow == windowH || parentWindow == wRoot)

  1704.             parentWindow = 0;

  1705. 

  1706.         handleGravityNotify();

  1707.     }

  1708. 

  1709.     void handleGravityNotify()

  1710.     {

  1711.         updateWindowBounds();

  1712.         updateBorderSize();

  1713.         handleMovedOrResized();

  1714.     }

  1715. 

  1716.     void handleMappingNotify (XMappingEvent& mappingEvent)

  1717.     {

  1718.         if (mappingEvent.request != MappingPointer)

  1719.         {

  1720.             // Deal with modifier/keyboard mapping

  1721.             ScopedXLock xlock;

  1722.             XRefreshKeyboardMapping (&mappingEvent);

  1723.             updateModifierMappings();

  1724.         }

  1725.     }

  1726. 

  1727.     void handleClientMessageEvent (XClientMessageEvent& clientMsg, XEvent& event)

  1728.     {

  1729.         const Atoms& atoms = Atoms::get();

  1730. 

  1731.         if (clientMsg.message_type == atoms.protocols && clientMsg.format == 32)

  1732.         {

  1733.             const Atom atom = (Atom) clientMsg.data.l[0];

  1734. 

  1735.             if (atom == atoms.protocolList [Atoms::PING])

  1736.             {

  1737.                 Window root = RootWindow (display, DefaultScreen (display));

  1738. 

  1739.                 clientMsg.window = root;

  1740. 

  1741.                 XSendEvent (display, root, False, NoEventMask, &event);

  1742.                 XFlush (display);

  1743.             }

  1744.             else if (atom == atoms.protocolList [Atoms::TAKE_FOCUS])

  1745.             {

  1746.                 if ((getStyleFlags() & juce::ComponentPeer::windowIgnoresKeyPresses) == 0)

  1747.                 {

  1748.                     XWindowAttributes atts;

  1749. 

  1750.                     ScopedXLock xlock;

  1751.                     if (clientMsg.window != 0

  1752.                          && XGetWindowAttributes (display, clientMsg.window, &atts))

  1753.                     {

  1754.                         if (atts.map_state == IsViewable)

  1755.                             XSetInputFocus (display, clientMsg.window, RevertToParent, (::Time) clientMsg.data.l[1]);

  1756.                     }

  1757.                 }

  1758.             }

  1759.             else if (atom == atoms.protocolList [Atoms::DELETE_WINDOW])

  1760.             {

  1761.                 handleUserClosingWindow();

  1762.             }

  1763.         }

  1764.         else if (clientMsg.message_type == atoms.XdndEnter)

  1765.         {

  1766.             handleDragAndDropEnter (clientMsg);

  1767.         }

  1768.         else if (clientMsg.message_type == atoms.XdndLeave)

  1769.         {

  1770.             handleDragExit (dragInfo);

  1771.             resetDragAndDrop();

  1772.         }

  1773.         else if (clientMsg.message_type == atoms.XdndPosition)

  1774.         {

  1775.             handleDragAndDropPosition (clientMsg);

  1776.         }

  1777.         else if (clientMsg.message_type == atoms.XdndDrop)

  1778.         {

  1779.             handleDragAndDropDrop (clientMsg);

  1780.         }

  1781.         else if (clientMsg.message_type == atoms.XdndStatus)

  1782.         {

  1783.             handleExternalDragAndDropStatus (clientMsg);

  1784.         }

  1785.         else if (clientMsg.message_type == atoms.XdndFinished)

  1786.         {

  1787.             externalResetDragAndDrop();

  1788.         }

  1789.     }

  1790. 

  1791.     bool externalDragTextInit (const String& text)

  1792.     {

  1793.         if (dragState.dragging)

  1794.             return false;

  1795. 

  1796.         return externalDragInit (true, text);

  1797.     }

  1798. 

  1799.     bool externalDragFileInit (const StringArray& files, bool /*canMoveFiles*/)

  1800.     {

  1801.         if (dragState.dragging)

  1802.             return false;

  1803. 

  1804.         StringArray uriList;

  1805. 

  1806.         for (int i = 0; i < files.size(); ++i)

  1807.         {

  1808.             const String& f = files[i];

  1809. 

  1810.             if (f.matchesWildcard ("?*://*", false))

  1811.                 uriList.add (f);

  1812.             else

  1813.                 uriList.add ("file://" + f);

  1814.         }

  1815. 

  1816.         return externalDragInit (false, uriList.joinIntoString ("\r\n"));

  1817.     }

  1818. 

  1819.     //==============================================================================

  1820.     void showMouseCursor (Cursor cursor) noexcept

  1821.     {

  1822.         ScopedXLock xlock;

  1823.         XDefineCursor (display, windowH, cursor);

  1824.     }

  1825. 

  1826.     //==============================================================================

  1827.     bool dontRepaint;

  1828. 

  1829.     static ModifierKeys currentModifiers;

  1830.     static bool isActiveApplication;

  1831. 

  1832. private:

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

  1834.     class LinuxRepaintManager   : public Timer

  1835.     {

  1836.     public:

  1837.         LinuxRepaintManager (LinuxComponentPeer& p)

  1838.             : peer (p), lastTimeImageUsed (0)

  1839.         {

  1840.            #if JUCE_USE_XSHM

  1841.             shmPaintsPending = 0;

  1842. 

  1843.             useARGBImagesForRendering = XSHMHelpers::isShmAvailable();

  1844. 

  1845.             if (useARGBImagesForRendering)

  1846.             {

  1847.                 ScopedXLock xlock;

  1848.                 XShmSegmentInfo segmentinfo;

  1849. 

  1850.                 XImage* const testImage

  1851.                     = XShmCreateImage (display, DefaultVisual (display, DefaultScreen (display)),

  1852.                                        24, ZPixmap, 0, &segmentinfo, 64, 64);

  1853. 

  1854.                 useARGBImagesForRendering = (testImage->bits_per_pixel == 32);

  1855.                 XDestroyImage (testImage);

  1856.             }

  1857.            #endif

  1858.         }

  1859. 

  1860.         void timerCallback() override

  1861.         {

  1862.            #if JUCE_USE_XSHM

  1863.             if (shmPaintsPending != 0)

  1864.                 return;

  1865.            #endif

  1866. 

  1867.             if (! regionsNeedingRepaint.isEmpty())

  1868.             {

  1869.                 stopTimer();

  1870.                 performAnyPendingRepaintsNow();

  1871.             }

  1872.             else if (Time::getApproximateMillisecondCounter() > lastTimeImageUsed + 3000)

  1873.             {

  1874.                 stopTimer();

  1875.                 image = Image::null;

  1876.             }

  1877.         }

  1878. 

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

  1880.         {

  1881.             if (! isTimerRunning())

  1882.                 startTimer (repaintTimerPeriod);

  1883. 

  1884.             regionsNeedingRepaint.add (area);

  1885.         }

  1886. 

  1887.         void performAnyPendingRepaintsNow()

  1888.         {

  1889.            #if JUCE_USE_XSHM

  1890.             if (shmPaintsPending != 0)

  1891.             {

  1892.                 startTimer (repaintTimerPeriod);

  1893.                 return;

  1894.             }

  1895.            #endif

  1896. 

  1897.             RectangleList<int>  originalRepaintRegion (regionsNeedingRepaint);

  1898.             regionsNeedingRepaint.clear();

  1899.             const Rectangle<int> totalArea (originalRepaintRegion.getBounds());

  1900. 

  1901.             if (! totalArea.isEmpty())

  1902.             {

  1903.                 if (image.isNull() || image.getWidth() < totalArea.getWidth()

  1904.                      || image.getHeight() < totalArea.getHeight())

  1905.                 {

  1906.                    #if JUCE_USE_XSHM

  1907.                     image = Image (new XBitmapImage (useARGBImagesForRendering ? Image::ARGB

  1908.                                                                                : Image::RGB,

  1909.                    #else

  1910.                     image = Image (new XBitmapImage (Image::RGB,

  1911.                    #endif

  1912.                                                      (totalArea.getWidth()  + 31) & ~31,

  1913.                                                      (totalArea.getHeight() + 31) & ~31,

  1914.                                                      false, (unsigned int) peer.depth, peer.visual));

  1915.                 }

  1916. 

  1917.                 startTimer (repaintTimerPeriod);

  1918. 

  1919.                 RectangleList<int> adjustedList (originalRepaintRegion);

  1920.                 adjustedList.offsetAll (-totalArea.getX(), -totalArea.getY());

  1921. 

  1922.                 if (peer.depth == 32)

  1923.                     for (const Rectangle<int>* i = originalRepaintRegion.begin(), * const e = originalRepaintRegion.end(); i != e; ++i)

  1924.                         image.clear (*i - totalArea.getPosition());

  1925. 

  1926.                 {

  1927.                     ScopedPointer<LowLevelGraphicsContext> context (peer.getComponent().getLookAndFeel()

  1928.                                                                       .createGraphicsContext (image, -totalArea.getPosition(), adjustedList));

  1929.                     peer.handlePaint (*context);

  1930.                 }

  1931. 

  1932.                 for (const Rectangle<int>* i = originalRepaintRegion.begin(), * const e = originalRepaintRegion.end(); i != e; ++i)

  1933.                 {

  1934.                     XBitmapImage* xbitmap = static_cast<XBitmapImage*> (image.getPixelData());

  1935.                    #if JUCE_USE_XSHM

  1936.                     if (xbitmap->isUsingXShm())

  1937.                         ++shmPaintsPending;

  1938.                    #endif

  1939. 

  1940. 

  1941.                    xbitmap->blitToWindow (peer.windowH,

  1942.                                           i->getX(), i->getY(),

  1943.                                           (unsigned int) i->getWidth(),

  1944.                                           (unsigned int) i->getHeight(),

  1945.                                           i->getX() - totalArea.getX(), i->getY() - totalArea.getY());

  1946.                 }

  1947.             }

  1948. 

  1949.             lastTimeImageUsed = Time::getApproximateMillisecondCounter();

  1950.             startTimer (repaintTimerPeriod);

  1951.         }

  1952. 

  1953.        #if JUCE_USE_XSHM

  1954.         void notifyPaintCompleted() noexcept        { --shmPaintsPending; }

  1955.        #endif

  1956. 

  1957.     private:

  1958.         enum { repaintTimerPeriod = 1000 / 100 };

  1959. 

  1960.         LinuxComponentPeer& peer;

  1961.         Image image;

  1962.         uint32 lastTimeImageUsed;

  1963.         RectangleList<int> regionsNeedingRepaint;

  1964. 

  1965.        #if JUCE_USE_XSHM

  1966.         bool useARGBImagesForRendering;

  1967.         int shmPaintsPending;

  1968.        #endif

  1969.         JUCE_DECLARE_NON_COPYABLE (LinuxRepaintManager)

  1970.     };

  1971. 

  1972.     ScopedPointer<LinuxRepaintManager> repainter;

  1973. 

  1974.     friend class LinuxRepaintManager;

  1975.     Window windowH, parentWindow;

  1976.     Rectangle<int> bounds;

  1977.     Image taskbarImage;

  1978.     bool fullScreen, mapped;

  1979.     Visual* visual;

  1980.     int depth;

  1981.     BorderSize<int> windowBorder;

  1982.     bool isAlwaysOnTop;

  1983.     enum { KeyPressEventType = 2 };

  1984. 

  1985.     struct MotifWmHints

  1986.     {

  1987.         unsigned long flags;

  1988.         unsigned long functions;

  1989.         unsigned long decorations;

  1990.         long input_mode;

  1991.         unsigned long status;

  1992.     };

  1993. 

  1994.     static void updateKeyStates (const int keycode, const bool press) noexcept

  1995.     {

  1996.         const int keybyte = keycode >> 3;

  1997.         const int keybit = (1 << (keycode & 7));

  1998. 

  1999.         if (press)

  2000.             Keys::keyStates [keybyte] |= keybit;

  2001.         else

  2002.             Keys::keyStates [keybyte] &= ~keybit;

  2003.     }

  2004. 

  2005.     static void updateKeyModifiers (const int status) noexcept

  2006.     {

  2007.         int keyMods = 0;

  2008. 

  2009.         if ((status & ShiftMask) != 0)     keyMods |= ModifierKeys::shiftModifier;

  2010.         if ((status & ControlMask) != 0)   keyMods |= ModifierKeys::ctrlModifier;

  2011.         if ((status & Keys::AltMask) != 0) keyMods |= ModifierKeys::altModifier;

  2012. 

  2013.         currentModifiers = currentModifiers.withOnlyMouseButtons().withFlags (keyMods);

  2014. 

  2015.         Keys::numLock  = ((status & Keys::NumLockMask) != 0);

  2016.         Keys::capsLock = ((status & LockMask) != 0);

  2017.     }

  2018. 

  2019.     static bool updateKeyModifiersFromSym (KeySym sym, const bool press) noexcept

  2020.     {

  2021.         int modifier = 0;

  2022.         bool isModifier = true;

  2023. 

  2024.         switch (sym)

  2025.         {

  2026.             case XK_Shift_L:

  2027.             case XK_Shift_R:        modifier = ModifierKeys::shiftModifier; break;

  2028. 

  2029.             case XK_Control_L:

  2030.             case XK_Control_R:      modifier = ModifierKeys::ctrlModifier; break;

  2031. 

  2032.             case XK_Alt_L:

  2033.             case XK_Alt_R:          modifier = ModifierKeys::altModifier; break;

  2034. 

  2035.             case XK_Num_Lock:

  2036.                 if (press)

  2037.                     Keys::numLock = ! Keys::numLock;

  2038. 

  2039.                 break;

  2040. 

  2041.             case XK_Caps_Lock:

  2042.                 if (press)

  2043.                     Keys::capsLock = ! Keys::capsLock;

  2044. 

  2045.                 break;

  2046. 

  2047.             case XK_Scroll_Lock:

  2048.                 break;

  2049. 

  2050.             default:

  2051.                 isModifier = false;

  2052.                 break;

  2053.         }

  2054. 

  2055.         currentModifiers = press ? currentModifiers.withFlags (modifier)

  2056.                                  : currentModifiers.withoutFlags (modifier);

  2057. 

  2058.         return isModifier;

  2059.     }

  2060. 

  2061.     // Alt and Num lock are not defined by standard X

  2062.     // modifier constants: check what they're mapped to

  2063.     static void updateModifierMappings() noexcept

  2064.     {

  2065.         ScopedXLock xlock;

  2066.         const int altLeftCode = XKeysymToKeycode (display, XK_Alt_L);

  2067.         const int numLockCode = XKeysymToKeycode (display, XK_Num_Lock);

  2068. 

  2069.         Keys::AltMask = 0;

  2070.         Keys::NumLockMask = 0;

  2071. 

  2072.         if (XModifierKeymap* const mapping = XGetModifierMapping (display))

  2073.         {

  2074.             for (int i = 0; i < 8; i++)

  2075.             {

  2076.                 if (mapping->modifiermap [i << 1] == altLeftCode)

  2077.                     Keys::AltMask = 1 << i;

  2078.                 else if (mapping->modifiermap [i << 1] == numLockCode)

  2079.                     Keys::NumLockMask = 1 << i;

  2080.             }

  2081. 

  2082.             XFreeModifiermap (mapping);

  2083.         }

  2084.     }

  2085. 

  2086.     //==============================================================================

  2087.     static void xchangeProperty (Window wndH, Atom property, Atom type, int format, const void* data, int numElements)

  2088.     {

  2089.         XChangeProperty (display, wndH, property, type, format, PropModeReplace, (const unsigned char*) data, numElements);

  2090.     }

  2091. 

  2092.     void removeWindowDecorations (Window wndH)

  2093.     {

  2094.         Atom hints = Atoms::getIfExists ("_MOTIF_WM_HINTS");

  2095. 

  2096.         if (hints != None)

  2097.         {

  2098.             MotifWmHints motifHints;

  2099.             zerostruct (motifHints);

  2100. 

  2101.             motifHints.flags = 2; /* MWM_HINTS_DECORATIONS */

  2102.             motifHints.decorations = 0;

  2103. 

  2104.             ScopedXLock xlock;

  2105.             xchangeProperty (wndH, hints, hints, 32, &motifHints, 4);

  2106.         }

  2107. 

  2108.         hints = Atoms::getIfExists ("_WIN_HINTS");

  2109. 

  2110.         if (hints != None)

  2111.         {

  2112.             long gnomeHints = 0;

  2113. 

  2114.             ScopedXLock xlock;

  2115.             xchangeProperty (wndH, hints, hints, 32, &gnomeHints, 1);

  2116.         }

  2117. 

  2118.         hints = Atoms::getIfExists ("KWM_WIN_DECORATION");

  2119. 

  2120.         if (hints != None)

  2121.         {

  2122.             long kwmHints = 2; /*KDE_tinyDecoration*/

  2123. 

  2124.             ScopedXLock xlock;

  2125.             xchangeProperty (wndH, hints, hints, 32, &kwmHints, 1);

  2126.         }

  2127.     }

  2128. 

  2129.     void addWindowButtons (Window wndH)

  2130.     {

  2131.         ScopedXLock xlock;

  2132.         Atom hints = Atoms::getIfExists ("_MOTIF_WM_HINTS");

  2133. 

  2134.         if (hints != None)

  2135.         {

  2136.             MotifWmHints motifHints;

  2137.             zerostruct (motifHints);

  2138. 

  2139.             motifHints.flags = 1 | 2; /* MWM_HINTS_FUNCTIONS | MWM_HINTS_DECORATIONS */

  2140.             motifHints.decorations = 2 /* MWM_DECOR_BORDER */ | 8 /* MWM_DECOR_TITLE */ | 16; /* MWM_DECOR_MENU */

  2141. 

  2142.             motifHints.functions = 4 /* MWM_FUNC_MOVE */;

  2143. 

  2144.             if ((styleFlags & windowHasCloseButton) != 0)

  2145.                 motifHints.functions |= 32; /* MWM_FUNC_CLOSE */

  2146. 

  2147.             if ((styleFlags & windowHasMinimiseButton) != 0)

  2148.             {

  2149.                 motifHints.functions |= 8; /* MWM_FUNC_MINIMIZE */

  2150.                 motifHints.decorations |= 0x20; /* MWM_DECOR_MINIMIZE */

  2151.             }

  2152. 

  2153.             if ((styleFlags & windowHasMaximiseButton) != 0)

  2154.             {

  2155.                 motifHints.functions |= 0x10; /* MWM_FUNC_MAXIMIZE */

  2156.                 motifHints.decorations |= 0x40; /* MWM_DECOR_MAXIMIZE */

  2157.             }

  2158. 

  2159.             if ((styleFlags & windowIsResizable) != 0)

  2160.             {

  2161.                 motifHints.functions |= 2; /* MWM_FUNC_RESIZE */

  2162.                 motifHints.decorations |= 0x4; /* MWM_DECOR_RESIZEH */

  2163.             }

  2164. 

  2165.             xchangeProperty (wndH, hints, hints, 32, &motifHints, 5);

  2166.         }

  2167. 

  2168.         hints = Atoms::getIfExists ("_NET_WM_ALLOWED_ACTIONS");

  2169. 

  2170.         if (hints != None)

  2171.         {

  2172.             Atom netHints [6];

  2173.             int num = 0;

  2174. 

  2175.             if ((styleFlags & windowIsResizable) != 0)

  2176.                 netHints [num++] = Atoms::getIfExists ("_NET_WM_ACTION_RESIZE");

  2177. 

  2178.             if ((styleFlags & windowHasMaximiseButton) != 0)

  2179.                 netHints [num++] = Atoms::getIfExists ("_NET_WM_ACTION_FULLSCREEN");

  2180. 

  2181.             if ((styleFlags & windowHasMinimiseButton) != 0)

  2182.                 netHints [num++] = Atoms::getIfExists ("_NET_WM_ACTION_MINIMIZE");

  2183. 

  2184.             if ((styleFlags & windowHasCloseButton) != 0)

  2185.                 netHints [num++] = Atoms::getIfExists ("_NET_WM_ACTION_CLOSE");

  2186. 

  2187.             xchangeProperty (wndH, hints, XA_ATOM, 32, &netHints, num);

  2188.         }

  2189.     }

  2190. 

  2191.     void setWindowType()

  2192.     {

  2193.         Atom netHints [2];

  2194. 

  2195.         if ((styleFlags & windowIsTemporary) != 0

  2196.              || ((styleFlags & windowHasDropShadow) == 0 && Desktop::canUseSemiTransparentWindows()))

  2197.             netHints [0] = Atoms::getIfExists ("_NET_WM_WINDOW_TYPE_COMBO");

  2198.         else

  2199.             netHints [0] = Atoms::getIfExists ("_NET_WM_WINDOW_TYPE_NORMAL");

  2200. 

  2201.         netHints[1] = Atoms::getIfExists ("_KDE_NET_WM_WINDOW_TYPE_OVERRIDE");

  2202. 

  2203.         xchangeProperty (windowH, Atoms::get().windowType, XA_ATOM, 32, &netHints, 2);

  2204. 

  2205.         int numHints = 0;

  2206. 

  2207.         if ((styleFlags & windowAppearsOnTaskbar) == 0)

  2208.             netHints [numHints++] = Atoms::getIfExists ("_NET_WM_STATE_SKIP_TASKBAR");

  2209. 

  2210.         if (component.isAlwaysOnTop())

  2211.             netHints [numHints++] = Atoms::getIfExists ("_NET_WM_STATE_ABOVE");

  2212. 

  2213.         if (numHints > 0)

  2214.             xchangeProperty (windowH, Atoms::get().windowState, XA_ATOM, 32, &netHints, numHints);

  2215.     }

  2216. 

  2217.     void createWindow (Window parentToAddTo)

  2218.     {

  2219.         ScopedXLock xlock;

  2220.         resetDragAndDrop();

  2221. 

  2222.         // Get defaults for various properties

  2223.         const int screen = DefaultScreen (display);

  2224.         Window root = RootWindow (display, screen);

  2225. 

  2226.         parentWindow = parentToAddTo;

  2227. 

  2228.         // Try to obtain a 32-bit visual or fallback to 24 or 16

  2229.         visual = Visuals::findVisualFormat ((styleFlags & windowIsSemiTransparent) ? 32 : 24, depth);

  2230. 

  2231.         if (visual == nullptr)

  2232.         {

  2233.             Logger::outputDebugString ("ERROR: System doesn't support 32, 24 or 16 bit RGB display.\n");

  2234.             Process::terminate();

  2235.         }

  2236. 

  2237.         // Create and install a colormap suitable fr our visual

  2238.         Colormap colormap = XCreateColormap (display, root, visual, AllocNone);

  2239.         XInstallColormap (display, colormap);

  2240. 

  2241.         // Set up the window attributes

  2242.         XSetWindowAttributes swa;

  2243.         swa.border_pixel = 0;

  2244.         swa.background_pixmap = None;

  2245.         swa.colormap = colormap;

  2246.         swa.override_redirect = (component.isAlwaysOnTop() && (styleFlags & windowIsTemporary) != 0) ? True : False;

  2247.         swa.event_mask = getAllEventsMask();

  2248. 

  2249.         windowH = XCreateWindow (display, parentToAddTo != 0 ? parentToAddTo : root,

  2250.                                  0, 0, 1, 1,

  2251.                                  0, depth, InputOutput, visual,

  2252.                                  CWBorderPixel | CWColormap | CWBackPixmap | CWEventMask | CWOverrideRedirect,

  2253.                                  &swa);

  2254. 

  2255.         XGrabButton (display, AnyButton, AnyModifier, windowH, False,

  2256.                      ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask,

  2257.                      GrabModeAsync, GrabModeAsync, None, None);

  2258. 

  2259.         // Set the window context to identify the window handle object

  2260.         if (XSaveContext (display, (XID) windowH, windowHandleXContext, (XPointer) this))

  2261.         {

  2262.             // Failed

  2263.             jassertfalse;

  2264.             Logger::outputDebugString ("Failed to create context information for window.\n");

  2265.             XDestroyWindow (display, windowH);

  2266.             windowH = 0;

  2267.             return;

  2268.         }

  2269. 

  2270.         // Set window manager hints

  2271.         XWMHints* wmHints = XAllocWMHints();

  2272.         wmHints->flags = InputHint | StateHint;

  2273.         wmHints->input = True;      // Locally active input model

  2274.         wmHints->initial_state = NormalState;

  2275.         XSetWMHints (display, windowH, wmHints);

  2276.         XFree (wmHints);

  2277. 

  2278.         // Set the window type

  2279.         setWindowType();

  2280. 

  2281.         // Define decoration

  2282.         if ((styleFlags & windowHasTitleBar) == 0)

  2283.             removeWindowDecorations (windowH);

  2284.         else

  2285.             addWindowButtons (windowH);

  2286. 

  2287.         setTitle (component.getName());

  2288. 

  2289.         const Atoms& atoms = Atoms::get();

  2290. 

  2291.         // Associate the PID, allowing to be shut down when something goes wrong

  2292.         unsigned long pid = (unsigned long) getpid();

  2293.         xchangeProperty (windowH, atoms.pid, XA_CARDINAL, 32, &pid, 1);

  2294. 

  2295.         // Set window manager protocols

  2296.         xchangeProperty (windowH, atoms.protocols, XA_ATOM, 32, atoms.protocolList, 2);

  2297. 

  2298.         // Set drag and drop flags

  2299.         xchangeProperty (windowH, atoms.XdndTypeList, XA_ATOM, 32, atoms.allowedMimeTypes, numElementsInArray (atoms.allowedMimeTypes));

  2300.         xchangeProperty (windowH, atoms.XdndActionList, XA_ATOM, 32, atoms.allowedActions, numElementsInArray (atoms.allowedActions));

  2301.         xchangeProperty (windowH, atoms.XdndActionDescription, XA_STRING, 8, "", 0);

  2302.         xchangeProperty (windowH, atoms.XdndAware, XA_ATOM, 32, &Atoms::DndVersion, 1);

  2303. 

  2304.         initialisePointerMap();

  2305.         updateModifierMappings();

  2306.     }

  2307. 

  2308.     void destroyWindow()

  2309.     {

  2310.         ScopedXLock xlock;

  2311. 

  2312.         XPointer handlePointer;

  2313.         if (! XFindContext (display, (XID) windowH, windowHandleXContext, &handlePointer))

  2314.             XDeleteContext (display, (XID) windowH, windowHandleXContext);

  2315. 

  2316.         XDestroyWindow (display, windowH);

  2317. 

  2318.         // Wait for it to complete and then remove any events for this

  2319.         // window from the event queue.

  2320.         XSync (display, false);

  2321. 

  2322.         XEvent event;

  2323.         while (XCheckWindowEvent (display, windowH, getAllEventsMask(), &event) == True)

  2324.         {}

  2325.     }

  2326. 

  2327.     static int getAllEventsMask() noexcept

  2328.     {

  2329.         return NoEventMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask

  2330.                  | EnterWindowMask | LeaveWindowMask | PointerMotionMask | KeymapStateMask

  2331.                  | ExposureMask | StructureNotifyMask | FocusChangeMask;

  2332.     }

  2333. 

  2334.     template <typename EventType>

  2335.     static int64 getEventTime (const EventType& t)

  2336.     {

  2337.         return getEventTime (t.time);

  2338.     }

  2339. 

  2340.     static int64 getEventTime (::Time t)

  2341.     {

  2342.         static int64 eventTimeOffset = 0x12345678;

  2343.         const int64 thisMessageTime = (int64) t;

  2344. 

  2345.         if (eventTimeOffset == 0x12345678)

  2346.             eventTimeOffset = Time::currentTimeMillis() - thisMessageTime;

  2347. 

  2348.         return eventTimeOffset + thisMessageTime;

  2349.     }

  2350. 

  2351.     long getUserTime() const

  2352.     {

  2353.         GetXProperty prop (windowH, Atoms::get().userTime, 0, 65536, false, XA_CARDINAL);

  2354.         return prop.success ? *(long*) prop.data : 0;

  2355.     }

  2356. 

  2357.     void updateBorderSize()

  2358.     {

  2359.         if ((styleFlags & windowHasTitleBar) == 0)

  2360.         {

  2361.             windowBorder = BorderSize<int> (0);

  2362.         }

  2363.         else if (windowBorder.getTopAndBottom() == 0 && windowBorder.getLeftAndRight() == 0)

  2364.         {

  2365.             ScopedXLock xlock;

  2366.             Atom hints = Atoms::getIfExists ("_NET_FRAME_EXTENTS");

  2367. 

  2368.             if (hints != None)

  2369.             {

  2370.                 GetXProperty prop (windowH, hints, 0, 4, false, XA_CARDINAL);

  2371. 

  2372.                 if (prop.success && prop.actualFormat == 32)

  2373.                 {

  2374.                     const unsigned long* const sizes = (const unsigned long*) prop.data;

  2375. 

  2376.                     windowBorder = BorderSize<int> ((int) sizes[2], (int) sizes[0],

  2377.                                                     (int) sizes[3], (int) sizes[1]);

  2378.                 }

  2379.             }

  2380.         }

  2381.     }

  2382. 

  2383.     void updateWindowBounds()

  2384.     {

  2385.         jassert (windowH != 0);

  2386.         if (windowH != 0)

  2387.         {

  2388.             Window root, child;

  2389.             int wx = 0, wy = 0;

  2390.             unsigned int ww = 0, wh = 0, bw, bitDepth;

  2391. 

  2392.             ScopedXLock xlock;

  2393. 

  2394.             if (XGetGeometry (display, (::Drawable) windowH, &root, &wx, &wy, &ww, &wh, &bw, &bitDepth))

  2395.                 if (! XTranslateCoordinates (display, windowH, root, 0, 0, &wx, &wy, &child))

  2396.                     wx = wy = 0;

  2397. 

  2398.             bounds.setBounds (wx, wy, (int) ww, (int) wh);

  2399.         }

  2400.     }

  2401. 

  2402.     //==============================================================================

  2403.     struct DragState

  2404.     {

  2405.         DragState() noexcept

  2406.            : isText (false), dragging (false), expectingStatus (false),

  2407.              canDrop (false), targetWindow (None), xdndVersion (-1)

  2408.         {

  2409.         }

  2410. 

  2411.         bool isText;

  2412.         bool dragging;         // currently performing outgoing external dnd as Xdnd source, have grabbed mouse

  2413.         bool expectingStatus;  // XdndPosition sent, waiting for XdndStatus

  2414.         bool canDrop;          // target window signals it will accept the drop

  2415.         Window targetWindow;   // potential drop target

  2416.         int xdndVersion;       // negotiated version with target

  2417.         Rectangle<int> silentRect;

  2418.         String textOrFiles;

  2419. 

  2420.         const Atom* getMimeTypes() const noexcept   { return isText ? Atoms::get().externalAllowedTextMimeTypes

  2421.                                                                     : Atoms::get().externalAllowedFileMimeTypes; }

  2422. 

  2423.         int getNumMimeTypes() const noexcept { return isText ? numElementsInArray (Atoms::get().externalAllowedTextMimeTypes)

  2424.                                                              : numElementsInArray (Atoms::get().externalAllowedFileMimeTypes); }

  2425. 

  2426.         bool matchesTarget (Atom targetType) const

  2427.         {

  2428.             for (int i = getNumMimeTypes(); --i >= 0;)

  2429.                 if (getMimeTypes()[i] == targetType)

  2430.                     return true;

  2431. 

  2432.             return false;

  2433.         }

  2434.     };

  2435. 

  2436.     //==============================================================================

  2437.     void resetDragAndDrop()

  2438.     {

  2439.         dragInfo.clear();

  2440.         dragInfo.position = Point<int> (-1, -1);

  2441.         dragAndDropCurrentMimeType = 0;

  2442.         dragAndDropSourceWindow = 0;

  2443.         srcMimeTypeAtomList.clear();

  2444.         finishAfterDropDataReceived = false;

  2445.     }

  2446. 

  2447.     void resetExternalDragState()

  2448.     {

  2449.         dragState = DragState();

  2450.     }

  2451. 

  2452.     void sendDragAndDropMessage (XClientMessageEvent& msg)

  2453.     {

  2454.         msg.type = ClientMessage;

  2455.         msg.display = display;

  2456.         msg.window = dragAndDropSourceWindow;

  2457.         msg.format = 32;

  2458.         msg.data.l[0] = (long) windowH;

  2459. 

  2460.         ScopedXLock xlock;

  2461.         XSendEvent (display, dragAndDropSourceWindow, False, 0, (XEvent*) &msg);

  2462.     }

  2463. 

  2464.     bool sendExternalDragAndDropMessage (XClientMessageEvent& msg, const Window targetWindow)

  2465.     {

  2466.         msg.type      = ClientMessage;

  2467.         msg.display   = display;

  2468.         msg.window    = targetWindow;

  2469.         msg.format    = 32;

  2470.         msg.data.l[0] = (long) windowH;

  2471. 

  2472.         ScopedXLock xlock;

  2473.         return XSendEvent (display, targetWindow, False, 0, (XEvent*) &msg) != 0;

  2474.     }

  2475. 

  2476.     void sendExternalDragAndDropDrop (const Window targetWindow)

  2477.     {

  2478.         XClientMessageEvent msg;

  2479.         zerostruct (msg);

  2480. 

  2481.         msg.message_type = Atoms::get().XdndDrop;

  2482.         msg.data.l[2] = CurrentTime;

  2483. 

  2484.         sendExternalDragAndDropMessage (msg, targetWindow);

  2485.     }

  2486. 

  2487.     void sendExternalDragAndDropEnter (const Window targetWindow)

  2488.     {

  2489.         XClientMessageEvent msg;

  2490.         zerostruct (msg);

  2491. 

  2492.         msg.message_type = Atoms::get().XdndEnter;

  2493. 

  2494.         const Atom* mimeTypes  = dragState.getMimeTypes();

  2495.         const int numMimeTypes = dragState.getNumMimeTypes();

  2496. 

  2497.         msg.data.l[1] = (dragState.xdndVersion << 24) | (numMimeTypes > 3);

  2498.         msg.data.l[2] = numMimeTypes > 0 ? (long) mimeTypes[0] : 0;

  2499.         msg.data.l[3] = numMimeTypes > 1 ? (long) mimeTypes[1] : 0;

  2500.         msg.data.l[4] = numMimeTypes > 2 ? (long) mimeTypes[2] : 0;

  2501. 

  2502.         sendExternalDragAndDropMessage (msg, targetWindow);

  2503.     }

  2504. 

  2505.     void sendExternalDragAndDropPosition (const Window targetWindow)

  2506.     {

  2507.         XClientMessageEvent msg;

  2508.         zerostruct (msg);

  2509. 

  2510.         msg.message_type = Atoms::get().XdndPosition;

  2511. 

  2512.         const Point<int> mousePos (Desktop::getInstance().getMousePosition());

  2513. 

  2514.         if (dragState.silentRect.contains (mousePos)) // we've been asked to keep silent

  2515.             return;

  2516. 

  2517.         msg.data.l[1] = 0;

  2518.         msg.data.l[2] = (mousePos.x << 16) | mousePos.y;

  2519.         msg.data.l[3] = CurrentTime;

  2520.         msg.data.l[4] = (long) Atoms::get().XdndActionCopy; // this is all JUCE currently supports

  2521. 

  2522.         dragState.expectingStatus = sendExternalDragAndDropMessage (msg, targetWindow);

  2523.     }

  2524. 

  2525.     void sendDragAndDropStatus (const bool acceptDrop, Atom dropAction)

  2526.     {

  2527.         XClientMessageEvent msg;

  2528.         zerostruct (msg);

  2529. 

  2530.         msg.message_type = Atoms::get().XdndStatus;

  2531.         msg.data.l[1] = (acceptDrop ? 1 : 0) | 2; // 2 indicates that we want to receive position messages

  2532.         msg.data.l[4] = (long) dropAction;

  2533. 

  2534.         sendDragAndDropMessage (msg);

  2535.     }

  2536. 

  2537.     void sendExternalDragAndDropLeave (const Window targetWindow)

  2538.     {

  2539.         XClientMessageEvent msg;

  2540.         zerostruct (msg);

  2541. 

  2542.         msg.message_type = Atoms::get().XdndLeave;

  2543.         sendExternalDragAndDropMessage (msg, targetWindow);

  2544.     }

  2545. 

  2546.     void sendDragAndDropFinish()

  2547.     {

  2548.         XClientMessageEvent msg;

  2549.         zerostruct (msg);

  2550. 

  2551.         msg.message_type = Atoms::get().XdndFinished;

  2552.         sendDragAndDropMessage (msg);

  2553.     }

  2554. 

  2555.     void handleExternalSelectionClear()

  2556.     {

  2557.         if (dragState.dragging)

  2558.             externalResetDragAndDrop();

  2559.     }

  2560. 

  2561.     void handleExternalSelectionRequest (const XEvent& evt)

  2562.     {

  2563.         Atom targetType = evt.xselectionrequest.target;

  2564. 

  2565.         XEvent s;

  2566.         s.xselection.type = SelectionNotify;

  2567.         s.xselection.requestor = evt.xselectionrequest.requestor;

  2568.         s.xselection.selection = evt.xselectionrequest.selection;

  2569.         s.xselection.target = targetType;

  2570.         s.xselection.property = None;

  2571.         s.xselection.time = evt.xselectionrequest.time;

  2572. 

  2573.         if (dragState.matchesTarget (targetType))

  2574.         {

  2575.             s.xselection.property = evt.xselectionrequest.property;

  2576. 

  2577.             xchangeProperty (evt.xselectionrequest.requestor,

  2578.                              evt.xselectionrequest.property,

  2579.                              targetType, 8,

  2580.                              dragState.textOrFiles.toRawUTF8(),

  2581.                              (int) dragState.textOrFiles.getNumBytesAsUTF8());

  2582.         }

  2583. 

  2584.         XSendEvent (display, evt.xselectionrequest.requestor, True, 0, &s);

  2585.     }

  2586. 

  2587.     void handleExternalDragAndDropStatus (const XClientMessageEvent& clientMsg)

  2588.     {

  2589.         if (dragState.expectingStatus)

  2590.         {

  2591.             dragState.expectingStatus = false;

  2592.             dragState.canDrop = false;

  2593.             dragState.silentRect = Rectangle<int>();

  2594. 

  2595.             if ((clientMsg.data.l[1] & 1) != 0

  2596.                  && ((Atom) clientMsg.data.l[4] == Atoms::get().XdndActionCopy

  2597.                       || (Atom) clientMsg.data.l[4] == Atoms::get().XdndActionPrivate))

  2598.             {

  2599.                 if ((clientMsg.data.l[1] & 2) == 0) // target requests silent rectangle

  2600.                     dragState.silentRect.setBounds ((int) clientMsg.data.l[2] >> 16,

  2601.                                                     (int) clientMsg.data.l[2] & 0xffff,

  2602.                                                     (int) clientMsg.data.l[3] >> 16,

  2603.                                                     (int) clientMsg.data.l[3] & 0xffff);

  2604. 

  2605.                 dragState.canDrop = true;

  2606.             }

  2607.         }

  2608.     }

  2609. 

  2610.     void handleExternalDragButtonReleaseEvent()

  2611.     {

  2612.         if (dragState.dragging)

  2613.             XUngrabPointer (display, CurrentTime);

  2614. 

  2615.         if (dragState.canDrop)

  2616.         {

  2617.             sendExternalDragAndDropDrop (dragState.targetWindow);

  2618.         }

  2619.         else

  2620.         {

  2621.             sendExternalDragAndDropLeave (dragState.targetWindow);

  2622.             externalResetDragAndDrop();

  2623.         }

  2624.     }

  2625. 

  2626.     void handleExternalDragMotionNotify()

  2627.     {

  2628.         Window targetWindow = externalFindDragTargetWindow (RootWindow (display, DefaultScreen (display)));

  2629. 

  2630.         if (dragState.targetWindow != targetWindow)

  2631.         {

  2632.             if (dragState.targetWindow != None)

  2633.                 sendExternalDragAndDropLeave (dragState.targetWindow);

  2634. 

  2635.             dragState.canDrop = false;

  2636.             dragState.silentRect = Rectangle<int>();

  2637. 

  2638.             if (targetWindow == None)

  2639.                 return;

  2640. 

  2641.             GetXProperty prop (targetWindow, Atoms::get().XdndAware,

  2642.                                0, 2, false, AnyPropertyType);

  2643. 

  2644.             if (prop.success

  2645.                  && prop.data != None

  2646.                  && prop.actualFormat == 32

  2647.                  && prop.numItems == 1)

  2648.             {

  2649.                 dragState.xdndVersion = jmin ((int) prop.data[0], (int) Atoms::DndVersion);

  2650.             }

  2651.             else

  2652.             {

  2653.                 dragState.xdndVersion = -1;

  2654.                 return;

  2655.             }

  2656. 

  2657.             sendExternalDragAndDropEnter (targetWindow);

  2658.             dragState.targetWindow = targetWindow;

  2659.         }

  2660. 

  2661.         if (! dragState.expectingStatus)

  2662.             sendExternalDragAndDropPosition (targetWindow);

  2663.     }

  2664. 

  2665.     void handleDragAndDropPosition (const XClientMessageEvent& clientMsg)

  2666.     {

  2667.         if (dragAndDropSourceWindow == 0)

  2668.             return;

  2669. 

  2670.         dragAndDropSourceWindow = (::Window) clientMsg.data.l[0];

  2671. 

  2672.         Point<int> dropPos ((int) clientMsg.data.l[2] >> 16,

  2673.                             (int) clientMsg.data.l[2] & 0xffff);

  2674.         dropPos -= bounds.getPosition();

  2675. 

  2676.         const Atoms& atoms = Atoms::get();

  2677.         Atom targetAction = atoms.XdndActionCopy;

  2678. 

  2679.         for (int i = numElementsInArray (atoms.allowedActions); --i >= 0;)

  2680.         {

  2681.             if ((Atom) clientMsg.data.l[4] == atoms.allowedActions[i])

  2682.             {

  2683.                 targetAction = atoms.allowedActions[i];

  2684.                 break;

  2685.             }

  2686.         }

  2687. 

  2688.         sendDragAndDropStatus (true, targetAction);

  2689. 

  2690.         if (dragInfo.position != dropPos)

  2691.         {

  2692.             dragInfo.position = dropPos;

  2693. 

  2694.             if (dragInfo.isEmpty())

  2695.                 updateDraggedFileList (clientMsg);

  2696. 

  2697.             if (! dragInfo.isEmpty())

  2698.                 handleDragMove (dragInfo);

  2699.         }

  2700.     }

  2701. 

  2702.     void handleDragAndDropDrop (const XClientMessageEvent& clientMsg)

  2703.     {

  2704.         if (dragInfo.isEmpty())

  2705.         {

  2706.             // no data, transaction finished in handleDragAndDropSelection()

  2707.             finishAfterDropDataReceived = true;

  2708.             updateDraggedFileList (clientMsg);

  2709.         }

  2710.         else

  2711.         {

  2712.             handleDragAndDropDataReceived();  // data was already received

  2713.         }

  2714.     }

  2715. 

  2716.     void handleDragAndDropDataReceived()

  2717.     {

  2718.         DragInfo dragInfoCopy (dragInfo);

  2719. 

  2720.         sendDragAndDropFinish();

  2721.         resetDragAndDrop();

  2722. 

  2723.         if (! dragInfoCopy.isEmpty())

  2724.             handleDragDrop (dragInfoCopy);

  2725.     }

  2726. 

  2727.     void handleDragAndDropEnter (const XClientMessageEvent& clientMsg)

  2728.     {

  2729.         dragInfo.clear();

  2730.         srcMimeTypeAtomList.clear();

  2731. 

  2732.         dragAndDropCurrentMimeType = 0;

  2733.         const unsigned long dndCurrentVersion = static_cast<unsigned long> (clientMsg.data.l[1] & 0xff000000) >> 24;

  2734. 

  2735.         if (dndCurrentVersion < 3 || dndCurrentVersion > Atoms::DndVersion)

  2736.         {

  2737.             dragAndDropSourceWindow = 0;

  2738.             return;

  2739.         }

  2740. 

  2741.         dragAndDropSourceWindow = (::Window) clientMsg.data.l[0];

  2742. 

  2743.         if ((clientMsg.data.l[1] & 1) != 0)

  2744.         {

  2745.             ScopedXLock xlock;

  2746.             GetXProperty prop (dragAndDropSourceWindow, Atoms::get().XdndTypeList, 0, 0x8000000L, false, XA_ATOM);

  2747. 

  2748.             if (prop.success

  2749.                  && prop.actualType == XA_ATOM

  2750.                  && prop.actualFormat == 32

  2751.                  && prop.numItems != 0)

  2752.             {

  2753.                 const unsigned long* const types = (const unsigned long*) prop.data;

  2754. 

  2755.                 for (unsigned long i = 0; i < prop.numItems; ++i)

  2756.                     if (types[i] != None)

  2757.                         srcMimeTypeAtomList.add (types[i]);

  2758.             }

  2759.         }

  2760. 

  2761.         if (srcMimeTypeAtomList.size() == 0)

  2762.         {

  2763.             for (int i = 2; i < 5; ++i)

  2764.                 if (clientMsg.data.l[i] != None)

  2765.                     srcMimeTypeAtomList.add ((unsigned long) clientMsg.data.l[i]);

  2766. 

  2767.             if (srcMimeTypeAtomList.size() == 0)

  2768.             {

  2769.                 dragAndDropSourceWindow = 0;

  2770.                 return;

  2771.             }

  2772.         }

  2773. 

  2774.         const Atoms& atoms = Atoms::get();

  2775.         for (int i = 0; i < srcMimeTypeAtomList.size() && dragAndDropCurrentMimeType == 0; ++i)

  2776.             for (int j = 0; j < numElementsInArray (atoms.allowedMimeTypes); ++j)

  2777.                 if (srcMimeTypeAtomList[i] == atoms.allowedMimeTypes[j])

  2778.                     dragAndDropCurrentMimeType = atoms.allowedMimeTypes[j];

  2779. 

  2780.         handleDragAndDropPosition (clientMsg);

  2781.     }

  2782. 

  2783.     void handleDragAndDropSelection (const XEvent& evt)

  2784.     {

  2785.         dragInfo.clear();

  2786. 

  2787.         if (evt.xselection.property != None)

  2788.         {

  2789.             StringArray lines;

  2790. 

  2791.             {

  2792.                 MemoryBlock dropData;

  2793. 

  2794.                 for (;;)

  2795.                 {

  2796.                     GetXProperty prop (evt.xany.window, evt.xselection.property,

  2797.                                        dropData.getSize() / 4, 65536, false, AnyPropertyType);

  2798. 

  2799.                     if (! prop.success)

  2800.                         break;

  2801. 

  2802.                     dropData.append (prop.data, prop.numItems * (size_t) prop.actualFormat / 8);

  2803. 

  2804.                     if (prop.bytesLeft <= 0)

  2805.                         break;

  2806.                 }

  2807. 

  2808.                 lines.addLines (dropData.toString());

  2809.             }

  2810. 

  2811.             if (Atoms::isMimeTypeFile (dragAndDropCurrentMimeType))

  2812.             {

  2813.                 for (int i = 0; i < lines.size(); ++i)

  2814.                     dragInfo.files.add (URL::removeEscapeChars (lines[i].replace ("file://", String::empty, true)));

  2815. 

  2816.                 dragInfo.files.trim();

  2817.                 dragInfo.files.removeEmptyStrings();

  2818.             }

  2819.             else

  2820.             {

  2821.                 dragInfo.text = lines.joinIntoString ("\n");

  2822.             }

  2823. 

  2824.             if (finishAfterDropDataReceived)

  2825.                 handleDragAndDropDataReceived();

  2826.         }

  2827.     }

  2828. 

  2829.     void updateDraggedFileList (const XClientMessageEvent& clientMsg)

  2830.     {

  2831.         jassert (dragInfo.isEmpty());

  2832. 

  2833.         if (dragAndDropSourceWindow != None

  2834.              && dragAndDropCurrentMimeType != None)

  2835.         {

  2836.             ScopedXLock xlock;

  2837.             XConvertSelection (display,

  2838.                                Atoms::get().XdndSelection,

  2839.                                dragAndDropCurrentMimeType,

  2840.                                Atoms::getCreating ("JXSelectionWindowProperty"),

  2841.                                windowH,

  2842.                                (::Time) clientMsg.data.l[2]);

  2843.         }

  2844.     }

  2845. 

  2846.     static bool isWindowDnDAware (Window w)

  2847.     {

  2848.         int numProperties = 0;

  2849.         Atom* const atoms = XListProperties (display, w, &numProperties);

  2850. 

  2851.         bool dndAwarePropFound = false;

  2852.         for (int i = 0; i < numProperties; ++i)

  2853.             if (atoms[i] == Atoms::get().XdndAware)

  2854.                 dndAwarePropFound = true;

  2855. 

  2856.         if (atoms != nullptr)

  2857.             XFree (atoms);

  2858. 

  2859.         return dndAwarePropFound;

  2860.     }

  2861. 

  2862.     Window externalFindDragTargetWindow (Window targetWindow)

  2863.     {

  2864.         if (targetWindow == None)

  2865.             return None;

  2866. 

  2867.         if (isWindowDnDAware (targetWindow))

  2868.             return targetWindow;

  2869. 

  2870.         Window child, phonyWin;

  2871.         int phony;

  2872.         unsigned int uphony;

  2873. 

  2874.         XQueryPointer (display, targetWindow, &phonyWin, &child,

  2875.                        &phony, &phony, &phony, &phony, &uphony);

  2876. 

  2877.         return externalFindDragTargetWindow (child);

  2878.     }

  2879. 

  2880.     bool externalDragInit (bool isText, const String& textOrFiles)

  2881.     {

  2882.         ScopedXLock xlock;

  2883. 

  2884.         resetExternalDragState();

  2885.         dragState.isText = isText;

  2886.         dragState.textOrFiles = textOrFiles;

  2887.         dragState.targetWindow = windowH;

  2888. 

  2889.         const int pointerGrabMask = Button1MotionMask | ButtonReleaseMask;

  2890. 

  2891.         if (XGrabPointer (display, windowH, True, pointerGrabMask,

  2892.                           GrabModeAsync, GrabModeAsync, None, None, CurrentTime) == GrabSuccess)

  2893.         {

  2894.             // No other method of changing the pointer seems to work, this call is needed from this very context

  2895.             XChangeActivePointerGrab (display, pointerGrabMask, (Cursor) createDraggingHandCursor(), CurrentTime);

  2896. 

  2897.             const Atoms& atoms = Atoms::get();

  2898.             XSetSelectionOwner (display, atoms.XdndSelection, windowH, CurrentTime);

  2899. 

  2900.             // save the available types to XdndTypeList

  2901.             xchangeProperty (windowH, atoms.XdndTypeList, XA_ATOM, 32,

  2902.                              dragState.getMimeTypes(),

  2903.                              dragState.getNumMimeTypes());

  2904. 

  2905.             dragState.dragging = true;

  2906.             handleExternalDragMotionNotify();

  2907.             return true;

  2908.         }

  2909. 

  2910.         return false;

  2911.     }

  2912. 

  2913.     void externalResetDragAndDrop()

  2914.     {

  2915.         if (dragState.dragging)

  2916.         {

  2917.             ScopedXLock xlock;

  2918.             XUngrabPointer (display, CurrentTime);

  2919.         }

  2920. 

  2921.         resetExternalDragState();

  2922.     }

  2923. 

  2924.     DragState dragState;

  2925.     DragInfo dragInfo;

  2926.     Atom dragAndDropCurrentMimeType;

  2927.     Window dragAndDropSourceWindow;

  2928.     bool finishAfterDropDataReceived;

  2929. 

  2930.     Array<Atom> srcMimeTypeAtomList;

  2931. 

  2932.     int pointerMap[5];

  2933. 

  2934.     void initialisePointerMap()

  2935.     {

  2936.         const int numButtons = XGetPointerMapping (display, 0, 0);

  2937.         pointerMap[2] = pointerMap[3] = pointerMap[4] = Keys::NoButton;

  2938. 

  2939.         if (numButtons == 2)

  2940.         {

  2941.             pointerMap[0] = Keys::LeftButton;

  2942.             pointerMap[1] = Keys::RightButton;

  2943.         }

  2944.         else if (numButtons >= 3)

  2945.         {

  2946.             pointerMap[0] = Keys::LeftButton;

  2947.             pointerMap[1] = Keys::MiddleButton;

  2948.             pointerMap[2] = Keys::RightButton;

  2949. 

  2950.             if (numButtons >= 5)

  2951.             {

  2952.                 pointerMap[3] = Keys::WheelUp;

  2953.                 pointerMap[4] = Keys::WheelDown;

  2954.             }

  2955.         }

  2956.     }

  2957. 

  2958.     static Point<int> lastMousePos;

  2959. 

  2960.     static void clearLastMousePos() noexcept

  2961.     {

  2962.         lastMousePos = Point<int> (0x100000, 0x100000);

  2963.     }

  2964. 

  2965.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (LinuxComponentPeer)

  2966. };

  2967. 

  2968. ModifierKeys LinuxComponentPeer::currentModifiers;

  2969. bool LinuxComponentPeer::isActiveApplication = false;

  2970. Point<int> LinuxComponentPeer::lastMousePos;

  2971. 

  2972. //==============================================================================

  2973. JUCE_API bool JUCE_CALLTYPE Process::isForegroundProcess()

  2974. {

  2975.     return LinuxComponentPeer::isActiveApplication;

  2976. }

  2977. 

  2978. // N/A on Linux as far as I know.

  2979. JUCE_API void JUCE_CALLTYPE Process::makeForegroundProcess() {}

  2980. JUCE_API void JUCE_CALLTYPE Process::hide() {}

  2981. 

  2982. //==============================================================================

  2983. void ModifierKeys::updateCurrentModifiers() noexcept

  2984. {

  2985.     currentModifiers = LinuxComponentPeer::currentModifiers;

  2986. }

  2987. 

  2988. ModifierKeys ModifierKeys::getCurrentModifiersRealtime() noexcept

  2989. {

  2990.     if (display != nullptr)

  2991.     {

  2992.         Window root, child;

  2993.         int x, y, winx, winy;

  2994.         unsigned int mask;

  2995.         int mouseMods = 0;

  2996. 

  2997.         ScopedXLock xlock;

  2998. 

  2999.         if (XQueryPointer (display, RootWindow (display, DefaultScreen (display)),

  3000.                            &root, &child, &x, &y, &winx, &winy, &mask) != False)

  3001.         {

  3002.             if ((mask & Button1Mask) != 0)  mouseMods |= ModifierKeys::leftButtonModifier;

  3003.             if ((mask & Button2Mask) != 0)  mouseMods |= ModifierKeys::middleButtonModifier;

  3004.             if ((mask & Button3Mask) != 0)  mouseMods |= ModifierKeys::rightButtonModifier;

  3005.         }

  3006. 

  3007.         LinuxComponentPeer::currentModifiers = LinuxComponentPeer::currentModifiers.withoutMouseButtons().withFlags (mouseMods);

  3008.     }

  3009. 

  3010.     return LinuxComponentPeer::currentModifiers;

  3011. }

  3012. 

  3013. 

  3014. //==============================================================================

  3015. void Desktop::setKioskComponent (Component* comp, bool enableOrDisable, bool /* allowMenusAndBars */)

  3016. {

  3017.     if (enableOrDisable)

  3018.         comp->setBounds (getDisplays().getMainDisplay().totalArea);

  3019. }

  3020. 

  3021. //==============================================================================

  3022. ComponentPeer* Component::createNewPeer (int styleFlags, void* nativeWindowToAttachTo)

  3023. {

  3024.     return new LinuxComponentPeer (*this, styleFlags, (Window) nativeWindowToAttachTo);

  3025. }

  3026. 

  3027. //==============================================================================

  3028. static double getDisplayDPI (int index)

  3029. {

  3030.     double dpiX = (DisplayWidth  (display, index) * 25.4) / DisplayWidthMM  (display, index);

  3031.     double dpiY = (DisplayHeight (display, index) * 25.4) / DisplayHeightMM (display, index);

  3032.     return (dpiX + dpiY) / 2.0;

  3033. }

  3034. 

  3035. void Desktop::Displays::findDisplays (float masterScale)

  3036. {

  3037.     if (display == 0)

  3038.         return;

  3039. 

  3040.     ScopedXLock xlock;

  3041. 

  3042.   #if JUCE_USE_XINERAMA

  3043.     int major_opcode, first_event, first_error;

  3044. 

  3045.     if (XQueryExtension (display, "XINERAMA", &major_opcode, &first_event, &first_error))

  3046.     {

  3047.         typedef Bool (*tXineramaIsActive) (::Display*);

  3048.         typedef XineramaScreenInfo* (*tXineramaQueryScreens) (::Display*, int*);

  3049. 

  3050.         static tXineramaIsActive xineramaIsActive = nullptr;

  3051.         static tXineramaQueryScreens xineramaQueryScreens = nullptr;

  3052. 

  3053.         if (xineramaIsActive == nullptr || xineramaQueryScreens == nullptr)

  3054.         {

  3055.             void* h = dlopen ("libXinerama.so", RTLD_GLOBAL | RTLD_NOW);

  3056. 

  3057.             if (h == nullptr)

  3058.                 h = dlopen ("libXinerama.so.1", RTLD_GLOBAL | RTLD_NOW);

  3059. 

  3060.             if (h != nullptr)

  3061.             {

  3062.                 xineramaIsActive = (tXineramaIsActive) dlsym (h, "XineramaIsActive");

  3063.                 xineramaQueryScreens = (tXineramaQueryScreens) dlsym (h, "XineramaQueryScreens");

  3064.             }

  3065.         }

  3066. 

  3067.         if (xineramaIsActive != nullptr

  3068.             && xineramaQueryScreens != nullptr

  3069.             && xineramaIsActive (display))

  3070.         {

  3071.             int numMonitors = 0;

  3072. 

  3073.             if (XineramaScreenInfo* const screens = xineramaQueryScreens (display, &numMonitors))

  3074.             {

  3075.                 for (int index = 0; index < numMonitors; ++index)

  3076.                 {

  3077.                     for (int j = numMonitors; --j >= 0;)

  3078.                     {

  3079.                         if (screens[j].screen_number == index)

  3080.                         {

  3081.                             Display d;

  3082.                             d.userArea = d.totalArea = Rectangle<int> (screens[j].x_org,

  3083.                                                                        screens[j].y_org,

  3084.                                                                        screens[j].width,

  3085.                                                                        screens[j].height) / masterScale;

  3086.                             d.isMain = (index == 0);

  3087.                             d.scale = masterScale;

  3088.                             d.dpi = getDisplayDPI (0); // (all screens share the same DPI)

  3089. 

  3090.                             displays.add (d);

  3091.                         }

  3092.                     }

  3093.                 }

  3094. 

  3095.                 XFree (screens);

  3096.             }

  3097.         }

  3098.     }

  3099. 

  3100.     if (displays.size() == 0)

  3101.   #endif

  3102.     {

  3103.         Atom hints = Atoms::getIfExists ("_NET_WORKAREA");

  3104. 

  3105.         if (hints != None)

  3106.         {

  3107.             const int numMonitors = ScreenCount (display);

  3108. 

  3109.             for (int i = 0; i < numMonitors; ++i)

  3110.             {

  3111.                 GetXProperty prop (RootWindow (display, i), hints, 0, 4, false, XA_CARDINAL);

  3112. 

  3113.                 if (prop.success && prop.actualType == XA_CARDINAL && prop.actualFormat == 32 && prop.numItems == 4)

  3114.                 {

  3115.                     const long* const position = (const long*) prop.data;

  3116. 

  3117.                     Display d;

  3118.                     d.userArea = d.totalArea = Rectangle<int> ((int) position[0], (int) position[1],

  3119.                                                                (int) position[2], (int) position[3]) / masterScale;

  3120.                     d.isMain = (displays.size() == 0);

  3121.                     d.scale = masterScale;

  3122.                     d.dpi = getDisplayDPI (i);

  3123. 

  3124.                     displays.add (d);

  3125.                 }

  3126.             }

  3127.         }

  3128. 

  3129.         if (displays.size() == 0)

  3130.         {

  3131.             Display d;

  3132.             d.userArea = d.totalArea = Rectangle<int> (DisplayWidth  (display, DefaultScreen (display)),

  3133.                                                        DisplayHeight (display, DefaultScreen (display))) * masterScale;

  3134.             d.isMain = true;

  3135.             d.scale = masterScale;

  3136.             d.dpi = getDisplayDPI (0);

  3137. 

  3138.             displays.add (d);

  3139.         }

  3140.     }

  3141. }

  3142. 

  3143. //==============================================================================

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

  3145. {

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

  3147.     {

  3148.         addSource (0, true);

  3149.         return true;

  3150.     }

  3151. 

  3152.     return false;

  3153. }

  3154. 

  3155. bool Desktop::canUseSemiTransparentWindows() noexcept

  3156. {

  3157.    #if JUCE_USE_XRENDER

  3158.     if (XRender::hasCompositingWindowManager())

  3159.     {

  3160.         int matchedDepth = 0, desiredDepth = 32;

  3161. 

  3162.         return Visuals::findVisualFormat (desiredDepth, matchedDepth) != 0

  3163.                  && matchedDepth == desiredDepth;

  3164.     }

  3165.    #endif

  3166. 

  3167.     return false;

  3168. }

  3169. 

  3170. Point<float> MouseInputSource::getCurrentRawMousePosition()

  3171. {

  3172.     if (display == nullptr)

  3173.         return Point<float>();

  3174. 

  3175.     Window root, child;

  3176.     int x, y, winx, winy;

  3177.     unsigned int mask;

  3178. 

  3179.     ScopedXLock xlock;

  3180. 

  3181.     if (XQueryPointer (display,

  3182.                        RootWindow (display, DefaultScreen (display)),

  3183.                        &root, &child,

  3184.                        &x, &y, &winx, &winy, &mask) == False)

  3185.     {

  3186.         // Pointer not on the default screen

  3187.         x = y = -1;

  3188.     }

  3189. 

  3190.     return Point<float> ((float) x, (float) y);

  3191. }

  3192. 

  3193. void MouseInputSource::setRawMousePosition (Point<float> newPosition)

  3194. {

  3195.     if (display != nullptr)

  3196.     {

  3197.         ScopedXLock xlock;

  3198.         Window root = RootWindow (display, DefaultScreen (display));

  3199.         XWarpPointer (display, None, root, 0, 0, 0, 0, roundToInt (newPosition.getX()), roundToInt (newPosition.getY()));

  3200.     }

  3201. }

  3202. 

  3203. double Desktop::getDefaultMasterScale()

  3204. {

  3205.     // Ubuntu and derived distributions now save a per-display scale factor as a configuration

  3206.     // variable. This can be changed in the Monitor system settings panel.

  3207.     ChildProcess dconf;

  3208. 

  3209.     if (dconf.start ("dconf read /com/ubuntu/user-interface/scale-factor", ChildProcess::wantStdOut))

  3210.     {

  3211.         if (dconf.waitForProcessToFinish (200))

  3212.         {

  3213.             String jsonOutput = dconf.readAllProcessOutput().replaceCharacter ('\'', '"');

  3214. 

  3215.             if (dconf.getExitCode() == 0 && jsonOutput.isNotEmpty())

  3216.             {

  3217.                 var jsonVar = JSON::parse (jsonOutput);

  3218. 

  3219.                 if (DynamicObject* object = jsonVar.getDynamicObject())

  3220.                 {

  3221.                     NamedValueSet& scaleFactors = object->getProperties();

  3222. 

  3223.                     double maxScaleFactor = 1.0;

  3224.                     for (int i = 0; i < scaleFactors.size(); ++i)

  3225.                         maxScaleFactor = jmax (maxScaleFactor, (double) (scaleFactors.getValueAt (i)) / 8.0);

  3226. 

  3227.                     return maxScaleFactor;

  3228.                 }

  3229.             }

  3230.         }

  3231.     }

  3232. 

  3233.     return 1.0;

  3234. }

  3235. 

  3236. Desktop::DisplayOrientation Desktop::getCurrentOrientation() const

  3237. {

  3238.     return upright;

  3239. }

  3240. 

  3241. //==============================================================================

  3242. static bool screenSaverAllowed = true;

  3243. 

  3244. void Desktop::setScreenSaverEnabled (const bool isEnabled)

  3245. {

  3246.     if (screenSaverAllowed != isEnabled)

  3247.     {

  3248.         screenSaverAllowed = isEnabled;

  3249. 

  3250.         if (display != nullptr)

  3251.         {

  3252.             typedef void (*tXScreenSaverSuspend) (Display*, Bool);

  3253.             static tXScreenSaverSuspend xScreenSaverSuspend = nullptr;

  3254. 

  3255.             if (xScreenSaverSuspend == nullptr)

  3256.                 if (void* h = dlopen ("libXss.so", RTLD_GLOBAL | RTLD_NOW))

  3257.                     xScreenSaverSuspend = (tXScreenSaverSuspend) dlsym (h, "XScreenSaverSuspend");

  3258. 

  3259.             ScopedXLock xlock;

  3260.             if (xScreenSaverSuspend != nullptr)

  3261.                 xScreenSaverSuspend (display, ! isEnabled);

  3262.         }

  3263.     }

  3264. }

  3265. 

  3266. bool Desktop::isScreenSaverEnabled()

  3267. {

  3268.     return screenSaverAllowed;

  3269. }

  3270. 

  3271. //==============================================================================

  3272. void* CustomMouseCursorInfo::create() const

  3273. {

  3274.     if (display == nullptr)

  3275.         return nullptr;

  3276. 

  3277.     ScopedXLock xlock;

  3278.     const unsigned int imageW = (unsigned int) image.getWidth();

  3279.     const unsigned int imageH = (unsigned int) image.getHeight();

  3280.     int hotspotX = hotspot.x;

  3281.     int hotspotY = hotspot.y;

  3282. 

  3283.   #if JUCE_USE_XCURSOR

  3284.     {

  3285.         typedef XcursorBool (*tXcursorSupportsARGB) (Display*);

  3286.         typedef XcursorImage* (*tXcursorImageCreate) (int, int);

  3287.         typedef void (*tXcursorImageDestroy) (XcursorImage*);

  3288.         typedef Cursor (*tXcursorImageLoadCursor) (Display*, const XcursorImage*);

  3289. 

  3290.         static tXcursorSupportsARGB    xcursorSupportsARGB    = nullptr;

  3291.         static tXcursorImageCreate     xcursorImageCreate     = nullptr;

  3292.         static tXcursorImageDestroy    xcursorImageDestroy    = nullptr;

  3293.         static tXcursorImageLoadCursor xcursorImageLoadCursor = nullptr;

  3294.         static bool hasBeenLoaded = false;

  3295. 

  3296.         if (! hasBeenLoaded)

  3297.         {

  3298.             hasBeenLoaded = true;

  3299. 

  3300.             if (void* h = dlopen ("libXcursor.so", RTLD_GLOBAL | RTLD_NOW))

  3301.             {

  3302.                 xcursorSupportsARGB    = (tXcursorSupportsARGB)    dlsym (h, "XcursorSupportsARGB");

  3303.                 xcursorImageCreate     = (tXcursorImageCreate)     dlsym (h, "XcursorImageCreate");

  3304.                 xcursorImageLoadCursor = (tXcursorImageLoadCursor) dlsym (h, "XcursorImageLoadCursor");

  3305.                 xcursorImageDestroy    = (tXcursorImageDestroy)    dlsym (h, "XcursorImageDestroy");

  3306. 

  3307.                 if (xcursorSupportsARGB == nullptr || xcursorImageCreate == nullptr

  3308.                       || xcursorImageLoadCursor == nullptr || xcursorImageDestroy == nullptr

  3309.                       || ! xcursorSupportsARGB (display))

  3310.                     xcursorSupportsARGB = nullptr;

  3311.             }

  3312.         }

  3313. 

  3314.         if (xcursorSupportsARGB != nullptr)

  3315.         {

  3316.             if (XcursorImage* xcImage = xcursorImageCreate ((int) imageW, (int) imageH))

  3317.             {

  3318.                 xcImage->xhot = (XcursorDim) hotspotX;

  3319.                 xcImage->yhot = (XcursorDim) hotspotY;

  3320.                 XcursorPixel* dest = xcImage->pixels;

  3321. 

  3322.                 for (int y = 0; y < (int) imageH; ++y)

  3323.                     for (int x = 0; x < (int) imageW; ++x)

  3324.                         *dest++ = image.getPixelAt (x, y).getARGB();

  3325. 

  3326.                 void* result = (void*) xcursorImageLoadCursor (display, xcImage);

  3327.                 xcursorImageDestroy (xcImage);

  3328. 

  3329.                 if (result != nullptr)

  3330.                     return result;

  3331.             }

  3332.         }

  3333.     }

  3334.   #endif

  3335. 

  3336.     Window root = RootWindow (display, DefaultScreen (display));

  3337.     unsigned int cursorW, cursorH;

  3338.     if (! XQueryBestCursor (display, root, imageW, imageH, &cursorW, &cursorH))

  3339.         return nullptr;

  3340. 

  3341.     Image im (Image::ARGB, (int) cursorW, (int) cursorH, true);

  3342. 

  3343.     {

  3344.         Graphics g (im);

  3345. 

  3346.         if (imageW > cursorW || imageH > cursorH)

  3347.         {

  3348.             hotspotX = (hotspotX * (int) cursorW) / (int) imageW;

  3349.             hotspotY = (hotspotY * (int) cursorH) / (int) imageH;

  3350. 

  3351.             g.drawImageWithin (image, 0, 0, (int) imageW, (int) imageH,

  3352.                                RectanglePlacement::xLeft | RectanglePlacement::yTop | RectanglePlacement::onlyReduceInSize,

  3353.                                false);

  3354.         }

  3355.         else

  3356.         {

  3357.             g.drawImageAt (image, 0, 0);

  3358.         }

  3359.     }

  3360. 

  3361.     const unsigned int stride = (cursorW + 7) >> 3;

  3362.     HeapBlock<char> maskPlane, sourcePlane;

  3363.     maskPlane.calloc (stride * cursorH);

  3364.     sourcePlane.calloc (stride * cursorH);

  3365. 

  3366.     const bool msbfirst = (BitmapBitOrder (display) == MSBFirst);

  3367. 

  3368.     for (int y = (int) cursorH; --y >= 0;)

  3369.     {

  3370.         for (int x = (int) cursorW; --x >= 0;)

  3371.         {

  3372.             const char mask = (char) (1 << (msbfirst ? (7 - (x & 7)) : (x & 7)));

  3373.             const unsigned int offset = (unsigned int) y * stride + ((unsigned int) x >> 3);

  3374. 

  3375.             const Colour c (im.getPixelAt (x, y));

  3376. 

  3377.             if (c.getAlpha() >= 128)        maskPlane[offset]   |= mask;

  3378.             if (c.getBrightness() >= 0.5f)  sourcePlane[offset] |= mask;

  3379.         }

  3380.     }

  3381. 

  3382.     Pixmap sourcePixmap = XCreatePixmapFromBitmapData (display, root, sourcePlane.getData(), cursorW, cursorH, 0xffff, 0, 1);

  3383.     Pixmap maskPixmap   = XCreatePixmapFromBitmapData (display, root, maskPlane.getData(),   cursorW, cursorH, 0xffff, 0, 1);

  3384. 

  3385.     XColor white, black;

  3386.     black.red = black.green = black.blue = 0;

  3387.     white.red = white.green = white.blue = 0xffff;

  3388. 

  3389.     void* result = (void*) XCreatePixmapCursor (display, sourcePixmap, maskPixmap, &white, &black,

  3390.                                                 (unsigned int) hotspotX, (unsigned int) hotspotY);

  3391. 

  3392.     XFreePixmap (display, sourcePixmap);

  3393.     XFreePixmap (display, maskPixmap);

  3394. 

  3395.     return result;

  3396. }

  3397. 

  3398. void MouseCursor::deleteMouseCursor (void* const cursorHandle, const bool)

  3399. {

  3400.     if (cursorHandle != nullptr && display != nullptr)

  3401.     {

  3402.         ScopedXLock xlock;

  3403.         XFreeCursor (display, (Cursor) cursorHandle);

  3404.     }

  3405. }

  3406. 

  3407. void* MouseCursor::createStandardMouseCursor (MouseCursor::StandardCursorType type)

  3408. {

  3409.     if (display == nullptr)

  3410.         return None;

  3411. 

  3412.     unsigned int shape;

  3413. 

  3414.     switch (type)

  3415.     {

  3416.         case NormalCursor:

  3417.         case ParentCursor:                  return None; // Use parent cursor

  3418.         case NoCursor:                      return CustomMouseCursorInfo (Image (Image::ARGB, 16, 16, true), 0, 0).create();

  3419. 

  3420.         case WaitCursor:                    shape = XC_watch; break;

  3421.         case IBeamCursor:                   shape = XC_xterm; break;

  3422.         case PointingHandCursor:            shape = XC_hand2; break;

  3423.         case LeftRightResizeCursor:         shape = XC_sb_h_double_arrow; break;

  3424.         case UpDownResizeCursor:            shape = XC_sb_v_double_arrow; break;

  3425.         case UpDownLeftRightResizeCursor:   shape = XC_fleur; break;

  3426.         case TopEdgeResizeCursor:           shape = XC_top_side; break;

  3427.         case BottomEdgeResizeCursor:        shape = XC_bottom_side; break;

  3428.         case LeftEdgeResizeCursor:          shape = XC_left_side; break;

  3429.         case RightEdgeResizeCursor:         shape = XC_right_side; break;

  3430.         case TopLeftCornerResizeCursor:     shape = XC_top_left_corner; break;

  3431.         case TopRightCornerResizeCursor:    shape = XC_top_right_corner; break;

  3432.         case BottomLeftCornerResizeCursor:  shape = XC_bottom_left_corner; break;

  3433.         case BottomRightCornerResizeCursor: shape = XC_bottom_right_corner; break;

  3434.         case CrosshairCursor:               shape = XC_crosshair; break;

  3435.         case DraggingHandCursor:            return createDraggingHandCursor();

  3436. 

  3437.         case CopyingCursor:

  3438.         {

  3439.             static unsigned char copyCursorData[] = { 71,73,70,56,57,97,21,0,21,0,145,0,0,0,0,0,255,255,255,0,

  3440.               128,128,255,255,255,33,249,4,1,0,0,3,0,44,0,0,0,0,21,0, 21,0,0,2,72,4,134,169,171,16,199,98,11,79,90,71,161,93,56,111,

  3441.               78,133,218,215,137,31,82,154,100,200,86,91,202,142,12,108,212,87,235,174, 15,54,214,126,237,226,37,96,59,141,16,37,18,201,142,157,230,204,51,112,

  3442.               252,114,147,74,83,5,50,68,147,208,217,16,71,149,252,124,5,0,59,0,0 };

  3443.             const int copyCursorSize = 119;

  3444. 

  3445.             return CustomMouseCursorInfo (ImageFileFormat::loadFrom (copyCursorData, copyCursorSize), 1, 3).create();

  3446.         }

  3447. 

  3448.         default:

  3449.             jassertfalse;

  3450.             return None;

  3451.     }

  3452. 

  3453.     ScopedXLock xlock;

  3454.     return (void*) XCreateFontCursor (display, shape);

  3455. }

  3456. 

  3457. void MouseCursor::showInWindow (ComponentPeer* peer) const

  3458. {

  3459.     if (LinuxComponentPeer* const lp = dynamic_cast<LinuxComponentPeer*> (peer))

  3460.         lp->showMouseCursor ((Cursor) getHandle());

  3461. }

  3462. 

  3463. void MouseCursor::showInAllWindows() const

  3464. {

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

  3466.         showInWindow (ComponentPeer::getPeer (i));

  3467. }

  3468. 

  3469. //==============================================================================

  3470. Image juce_createIconForFile (const File& /* file */)

  3471. {

  3472.     return Image::null;

  3473. }

  3474. 

  3475. //==============================================================================

  3476. bool DragAndDropContainer::performExternalDragDropOfFiles (const StringArray& files, const bool canMoveFiles)

  3477. {

  3478.     if (files.size() == 0)

  3479.         return false;

  3480. 

  3481.     if (MouseInputSource* draggingSource = Desktop::getInstance().getDraggingMouseSource(0))

  3482.         if (Component* sourceComp = draggingSource->getComponentUnderMouse())

  3483.             if (LinuxComponentPeer* const lp = dynamic_cast<LinuxComponentPeer*> (sourceComp->getPeer()))

  3484.                 return lp->externalDragFileInit (files, canMoveFiles);

  3485. 

  3486.     // This method must be called in response to a component's mouseDown or mouseDrag event!

  3487.     jassertfalse;

  3488.     return false;

  3489. }

  3490. 

  3491. bool DragAndDropContainer::performExternalDragDropOfText (const String& text)

  3492. {

  3493.     if (text.isEmpty())

  3494.         return false;

  3495. 

  3496.     if (MouseInputSource* draggingSource = Desktop::getInstance().getDraggingMouseSource(0))

  3497.         if (Component* sourceComp = draggingSource->getComponentUnderMouse())

  3498.             if (LinuxComponentPeer* const lp = dynamic_cast<LinuxComponentPeer*> (sourceComp->getPeer()))

  3499.                 return lp->externalDragTextInit (text);

  3500. 

  3501.     // This method must be called in response to a component's mouseDown or mouseDrag event!

  3502.     jassertfalse;

  3503.     return false;

  3504. }

  3505. 

  3506. //==============================================================================

  3507. void LookAndFeel::playAlertSound()

  3508. {

  3509.     std::cout << "\a" << std::flush;

  3510. }

  3511. 

  3512. 

  3513. //==============================================================================

  3514. #if JUCE_MODAL_LOOPS_PERMITTED

  3515. void JUCE_CALLTYPE NativeMessageBox::showMessageBox (AlertWindow::AlertIconType iconType,

  3516.                                                      const String& title, const String& message,

  3517.                                                      Component* /* associatedComponent */)

  3518. {

  3519.     AlertWindow::showMessageBox (iconType, title, message);

  3520. }

  3521. #endif

  3522. 

  3523. void JUCE_CALLTYPE NativeMessageBox::showMessageBoxAsync (AlertWindow::AlertIconType iconType,

  3524.                                                           const String& title, const String& message,

  3525.                                                           Component* associatedComponent,

  3526.                                                           ModalComponentManager::Callback* callback)

  3527. {

  3528.     AlertWindow::showMessageBoxAsync (iconType, title, message, String::empty, associatedComponent, callback);

  3529. }

  3530. 

  3531. bool JUCE_CALLTYPE NativeMessageBox::showOkCancelBox (AlertWindow::AlertIconType iconType,

  3532.                                                       const String& title, const String& message,

  3533.                                                       Component* associatedComponent,

  3534.                                                       ModalComponentManager::Callback* callback)

  3535. {

  3536.     return AlertWindow::showOkCancelBox (iconType, title, message, String::empty, String::empty,

  3537.                                          associatedComponent, callback);

  3538. }

  3539. 

  3540. int JUCE_CALLTYPE NativeMessageBox::showYesNoCancelBox (AlertWindow::AlertIconType iconType,

  3541.                                                         const String& title, const String& message,

  3542.                                                         Component* associatedComponent,

  3543.                                                         ModalComponentManager::Callback* callback)

  3544. {

  3545.     return AlertWindow::showYesNoCancelBox (iconType, title, message,

  3546.                                             String::empty, String::empty, String::empty,

  3547.                                             associatedComponent, callback);

  3548. }

  3549. 

  3550. 

  3551. //==============================================================================

  3552. const int KeyPress::spaceKey                = XK_space & 0xff;

  3553. const int KeyPress::returnKey               = XK_Return & 0xff;

  3554. const int KeyPress::escapeKey               = XK_Escape & 0xff;

  3555. const int KeyPress::backspaceKey            = XK_BackSpace & 0xff;

  3556. const int KeyPress::leftKey                 = (XK_Left & 0xff) | Keys::extendedKeyModifier;

  3557. const int KeyPress::rightKey                = (XK_Right & 0xff) | Keys::extendedKeyModifier;

  3558. const int KeyPress::upKey                   = (XK_Up & 0xff) | Keys::extendedKeyModifier;

  3559. const int KeyPress::downKey                 = (XK_Down & 0xff) | Keys::extendedKeyModifier;

  3560. const int KeyPress::pageUpKey               = (XK_Page_Up & 0xff) | Keys::extendedKeyModifier;

  3561. const int KeyPress::pageDownKey             = (XK_Page_Down & 0xff) | Keys::extendedKeyModifier;

  3562. const int KeyPress::endKey                  = (XK_End & 0xff) | Keys::extendedKeyModifier;

  3563. const int KeyPress::homeKey                 = (XK_Home & 0xff) | Keys::extendedKeyModifier;

  3564. const int KeyPress::insertKey               = (XK_Insert & 0xff) | Keys::extendedKeyModifier;

  3565. const int KeyPress::deleteKey               = (XK_Delete & 0xff) | Keys::extendedKeyModifier;

  3566. const int KeyPress::tabKey                  = XK_Tab & 0xff;

  3567. const int KeyPress::F1Key                   = (XK_F1 & 0xff) | Keys::extendedKeyModifier;

  3568. const int KeyPress::F2Key                   = (XK_F2 & 0xff) | Keys::extendedKeyModifier;

  3569. const int KeyPress::F3Key                   = (XK_F3 & 0xff) | Keys::extendedKeyModifier;

  3570. const int KeyPress::F4Key                   = (XK_F4 & 0xff) | Keys::extendedKeyModifier;

  3571. const int KeyPress::F5Key                   = (XK_F5 & 0xff) | Keys::extendedKeyModifier;

  3572. const int KeyPress::F6Key                   = (XK_F6 & 0xff) | Keys::extendedKeyModifier;

  3573. const int KeyPress::F7Key                   = (XK_F7 & 0xff) | Keys::extendedKeyModifier;

  3574. const int KeyPress::F8Key                   = (XK_F8 & 0xff) | Keys::extendedKeyModifier;

  3575. const int KeyPress::F9Key                   = (XK_F9 & 0xff) | Keys::extendedKeyModifier;

  3576. const int KeyPress::F10Key                  = (XK_F10 & 0xff) | Keys::extendedKeyModifier;

  3577. const int KeyPress::F11Key                  = (XK_F11 & 0xff) | Keys::extendedKeyModifier;

  3578. const int KeyPress::F12Key                  = (XK_F12 & 0xff) | Keys::extendedKeyModifier;

  3579. const int KeyPress::F13Key                  = (XK_F13 & 0xff) | Keys::extendedKeyModifier;

  3580. const int KeyPress::F14Key                  = (XK_F14 & 0xff) | Keys::extendedKeyModifier;

  3581. const int KeyPress::F15Key                  = (XK_F15 & 0xff) | Keys::extendedKeyModifier;

  3582. const int KeyPress::F16Key                  = (XK_F16 & 0xff) | Keys::extendedKeyModifier;

  3583. const int KeyPress::numberPad0              = (XK_KP_0 & 0xff) | Keys::extendedKeyModifier;

  3584. const int KeyPress::numberPad1              = (XK_KP_1 & 0xff) | Keys::extendedKeyModifier;

  3585. const int KeyPress::numberPad2              = (XK_KP_2 & 0xff) | Keys::extendedKeyModifier;

  3586. const int KeyPress::numberPad3              = (XK_KP_3 & 0xff) | Keys::extendedKeyModifier;

  3587. const int KeyPress::numberPad4              = (XK_KP_4 & 0xff) | Keys::extendedKeyModifier;

  3588. const int KeyPress::numberPad5              = (XK_KP_5 & 0xff) | Keys::extendedKeyModifier;

  3589. const int KeyPress::numberPad6              = (XK_KP_6 & 0xff) | Keys::extendedKeyModifier;

  3590. const int KeyPress::numberPad7              = (XK_KP_7 & 0xff)| Keys::extendedKeyModifier;

  3591. const int KeyPress::numberPad8              = (XK_KP_8 & 0xff)| Keys::extendedKeyModifier;

  3592. const int KeyPress::numberPad9              = (XK_KP_9 & 0xff)| Keys::extendedKeyModifier;

  3593. const int KeyPress::numberPadAdd            = (XK_KP_Add & 0xff)| Keys::extendedKeyModifier;

  3594. const int KeyPress::numberPadSubtract       = (XK_KP_Subtract & 0xff)| Keys::extendedKeyModifier;

  3595. const int KeyPress::numberPadMultiply       = (XK_KP_Multiply & 0xff)| Keys::extendedKeyModifier;

  3596. const int KeyPress::numberPadDivide         = (XK_KP_Divide & 0xff)| Keys::extendedKeyModifier;

  3597. const int KeyPress::numberPadSeparator      = (XK_KP_Separator & 0xff)| Keys::extendedKeyModifier;

  3598. const int KeyPress::numberPadDecimalPoint   = (XK_KP_Decimal & 0xff)| Keys::extendedKeyModifier;

  3599. const int KeyPress::numberPadEquals         = (XK_KP_Equal & 0xff)| Keys::extendedKeyModifier;

  3600. const int KeyPress::numberPadDelete         = (XK_KP_Delete & 0xff)| Keys::extendedKeyModifier;

  3601. const int KeyPress::playKey                 = ((int) 0xffeeff00) | Keys::extendedKeyModifier;

  3602. const int KeyPress::stopKey                 = ((int) 0xffeeff01) | Keys::extendedKeyModifier;

  3603. const int KeyPress::fastForwardKey          = ((int) 0xffeeff02) | Keys::extendedKeyModifier;

  3604. const int KeyPress::rewindKey               = ((int) 0xffeeff03) | Keys::extendedKeyModifier;