?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Blindly add a few stuff from VST
[juce-lv2.git] / juce / source / src / native / linux / juce_linux_Windowing.cpp
bloba22a917002ce9e76330b27671ff20269a09be0e9
1 /*
2 ==============================================================================
3
4 This file is part of the JUCE library - "Jules' Utility Class Extensions"
5 Copyright 2004-11 by Raw Material Software Ltd.
6
7 ------------------------------------------------------------------------------
8
9 JUCE can be redistributed and/or modified under the terms of the GNU General
10 Public License (Version 2), as published by the Free Software Foundation.
11 A copy of the license is included in the JUCE distribution, or can be found
12 online at www.gnu.org/licenses.
13
14 JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
16 A PARTICULAR PURPOSE. See the GNU General Public License for more details.
17
18 ------------------------------------------------------------------------------
19
20 To release a closed-source product which uses JUCE, commercial licenses are
21 available: visit www.rawmaterialsoftware.com/juce for more information.
22
23 ==============================================================================
24 */
25
26 // (This file gets included by juce_linux_NativeCode.cpp, rather than being
27 // compiled on its own).
28 #if JUCE_INCLUDED_FILE
29
30 //==============================================================================
31 // These are defined in juce_linux_Messaging.cpp
32 extern Display* display;
33 extern XContext windowHandleXContext;
34
35 //==============================================================================
36 namespace Atoms
37 {
38 enum ProtocolItems
39 {
40 TAKE_FOCUS = 0,
41 DELETE_WINDOW = 1,
42 PING = 2
43 };
44
45 static Atom Protocols, ProtocolList[3], ChangeState, State,
46 ActiveWin, Pid, WindowType, WindowState,
47 XdndAware, XdndEnter, XdndLeave, XdndPosition, XdndStatus,
48 XdndDrop, XdndFinished, XdndSelection, XdndTypeList, XdndActionList,
49 XdndActionDescription, XdndActionCopy,
50 allowedActions[5],
51 allowedMimeTypes[2];
52
53 const unsigned long DndVersion = 3;
54
55 //==============================================================================
56 static void initialiseAtoms()
57 {
58 static bool atomsInitialised = false;
59
60 if (! atomsInitialised)
61 {
62 atomsInitialised = true;
63
64 Protocols = XInternAtom (display, "WM_PROTOCOLS", True);
65 ProtocolList [TAKE_FOCUS] = XInternAtom (display, "WM_TAKE_FOCUS", True);
66 ProtocolList [DELETE_WINDOW] = XInternAtom (display, "WM_DELETE_WINDOW", True);
67 ProtocolList [PING] = XInternAtom (display, "_NET_WM_PING", True);
68 ChangeState = XInternAtom (display, "WM_CHANGE_STATE", True);
69 State = XInternAtom (display, "WM_STATE", True);
70 ActiveWin = XInternAtom (display, "_NET_ACTIVE_WINDOW", False);
71 Pid = XInternAtom (display, "_NET_WM_PID", False);
72 WindowType = XInternAtom (display, "_NET_WM_WINDOW_TYPE", True);
73 WindowState = XInternAtom (display, "_NET_WM_STATE", True);
74
75 XdndAware = XInternAtom (display, "XdndAware", False);
76 XdndEnter = XInternAtom (display, "XdndEnter", False);
77 XdndLeave = XInternAtom (display, "XdndLeave", False);
78 XdndPosition = XInternAtom (display, "XdndPosition", False);
79 XdndStatus = XInternAtom (display, "XdndStatus", False);
80 XdndDrop = XInternAtom (display, "XdndDrop", False);
81 XdndFinished = XInternAtom (display, "XdndFinished", False);
82 XdndSelection = XInternAtom (display, "XdndSelection", False);
83
84 XdndTypeList = XInternAtom (display, "XdndTypeList", False);
85 XdndActionList = XInternAtom (display, "XdndActionList", False);
86 XdndActionCopy = XInternAtom (display, "XdndActionCopy", False);
87 XdndActionDescription = XInternAtom (display, "XdndActionDescription", False);
88
89 allowedMimeTypes[0] = XInternAtom (display, "text/plain", False);
90 allowedMimeTypes[1] = XInternAtom (display, "text/uri-list", False);
91
92 allowedActions[0] = XInternAtom (display, "XdndActionMove", False);
93 allowedActions[1] = XdndActionCopy;
94 allowedActions[2] = XInternAtom (display, "XdndActionLink", False);
95 allowedActions[3] = XInternAtom (display, "XdndActionAsk", False);
96 allowedActions[4] = XInternAtom (display, "XdndActionPrivate", False);
97 }
98 }
99 }
100
101 //==============================================================================
102 namespace Keys
103 {
104 enum MouseButtons
105 {
106 NoButton = 0,
107 LeftButton = 1,
108 MiddleButton = 2,
109 RightButton = 3,
110 WheelUp = 4,
111 WheelDown = 5
112 };
113
114 static int AltMask = 0;
115 static int NumLockMask = 0;
116 static bool numLock = false;
117 static bool capsLock = false;
118 static char keyStates [32];
119 static const int extendedKeyModifier = 0x10000000;
120 }
121
122 bool KeyPress::isKeyCurrentlyDown (const int keyCode)
123 {
124 int keysym;
125
126 if (keyCode & Keys::extendedKeyModifier)
127 {
128 keysym = 0xff00 | (keyCode & 0xff);
129 }
130 else
131 {
132 keysym = keyCode;
133
134 if (keysym == (XK_Tab & 0xff)
135 || keysym == (XK_Return & 0xff)
136 || keysym == (XK_Escape & 0xff)
137 || keysym == (XK_BackSpace & 0xff))
138 {
139 keysym |= 0xff00;
140 }
141 }
142
143 ScopedXLock xlock;
144
145 const int keycode = XKeysymToKeycode (display, keysym);
146
147 const int keybyte = keycode >> 3;
148 const int keybit = (1 << (keycode & 7));
149 return (Keys::keyStates [keybyte] & keybit) != 0;
150 }
151
152 //==============================================================================
153 #if JUCE_USE_XSHM
154 namespace XSHMHelpers
155 {
156 static int trappedErrorCode = 0;
157 extern "C" int errorTrapHandler (Display*, XErrorEvent* err)
158 {
159 trappedErrorCode = err->error_code;
160 return 0;
161 }
162
163 static bool isShmAvailable() noexcept
164 {
165 static bool isChecked = false;
166 static bool isAvailable = false;
167
168 if (! isChecked)
169 {
170 isChecked = true;
171 int major, minor;
172 Bool pixmaps;
173
174 ScopedXLock xlock;
175
176 if (XShmQueryVersion (display, &major, &minor, &pixmaps))
177 {
178 trappedErrorCode = 0;
179 XErrorHandler oldHandler = XSetErrorHandler (errorTrapHandler);
180
181 XShmSegmentInfo segmentInfo = { 0 };
182 XImage* xImage = XShmCreateImage (display, DefaultVisual (display, DefaultScreen (display)),
183 24, ZPixmap, 0, &segmentInfo, 50, 50);
184
185 if ((segmentInfo.shmid = shmget (IPC_PRIVATE,
186 xImage->bytes_per_line * xImage->height,
187 IPC_CREAT | 0777)) >= 0)
188 {
189 segmentInfo.shmaddr = (char*) shmat (segmentInfo.shmid, 0, 0);
190
191 if (segmentInfo.shmaddr != (void*) -1)
192 {
193 segmentInfo.readOnly = False;
194 xImage->data = segmentInfo.shmaddr;
195 XSync (display, False);
196
197 if (XShmAttach (display, &segmentInfo) != 0)
198 {
199 XSync (display, False);
200 XShmDetach (display, &segmentInfo);
201
202 isAvailable = true;
203 }
204 }
205
206 XFlush (display);
207 XDestroyImage (xImage);
208
209 shmdt (segmentInfo.shmaddr);
210 }
211
212 shmctl (segmentInfo.shmid, IPC_RMID, 0);
213
214 XSetErrorHandler (oldHandler);
215 if (trappedErrorCode != 0)
216 isAvailable = false;
217 }
218 }
219
220 return isAvailable;
221 }
222 }
223 #endif
224
225 //==============================================================================
226 #if JUCE_USE_XRENDER
227 namespace XRender
228 {
229 typedef Status (*tXRenderQueryVersion) (Display*, int*, int*);
230 typedef XRenderPictFormat* (*tXrenderFindStandardFormat) (Display*, int);
231 typedef XRenderPictFormat* (*tXRenderFindFormat) (Display*, unsigned long, XRenderPictFormat*, int);
232 typedef XRenderPictFormat* (*tXRenderFindVisualFormat) (Display*, Visual*);
233
234 static tXRenderQueryVersion xRenderQueryVersion = 0;
235 static tXrenderFindStandardFormat xRenderFindStandardFormat = 0;
236 static tXRenderFindFormat xRenderFindFormat = 0;
237 static tXRenderFindVisualFormat xRenderFindVisualFormat = 0;
238
239 static bool isAvailable()
240 {
241 static bool hasLoaded = false;
242
243 if (! hasLoaded)
244 {
245 ScopedXLock xlock;
246 hasLoaded = true;
247
248 void* h = dlopen ("libXrender.so", RTLD_GLOBAL | RTLD_NOW);
249
250 if (h != 0)
251 {
252 xRenderQueryVersion = (tXRenderQueryVersion) dlsym (h, "XRenderQueryVersion");
253 xRenderFindStandardFormat = (tXrenderFindStandardFormat) dlsym (h, "XrenderFindStandardFormat");
254 xRenderFindFormat = (tXRenderFindFormat) dlsym (h, "XRenderFindFormat");
255 xRenderFindVisualFormat = (tXRenderFindVisualFormat) dlsym (h, "XRenderFindVisualFormat");
256 }
257
258 if (xRenderQueryVersion != 0
259 && xRenderFindStandardFormat != 0
260 && xRenderFindFormat != 0
261 && xRenderFindVisualFormat != 0)
262 {
263 int major, minor;
264 if (xRenderQueryVersion (display, &major, &minor))
265 return true;
266 }
267
268 xRenderQueryVersion = 0;
269 }
270
271 return xRenderQueryVersion != 0;
272 }
273
274 static XRenderPictFormat* findPictureFormat()
275 {
276 ScopedXLock xlock;
277
278 XRenderPictFormat* pictFormat = nullptr;
279
280 if (isAvailable())
281 {
282 pictFormat = xRenderFindStandardFormat (display, PictStandardARGB32);
283
284 if (pictFormat == 0)
285 {
286 XRenderPictFormat desiredFormat;
287 desiredFormat.type = PictTypeDirect;
288 desiredFormat.depth = 32;
289
290 desiredFormat.direct.alphaMask = 0xff;
291 desiredFormat.direct.redMask = 0xff;
292 desiredFormat.direct.greenMask = 0xff;
293 desiredFormat.direct.blueMask = 0xff;
294
295 desiredFormat.direct.alpha = 24;
296 desiredFormat.direct.red = 16;
297 desiredFormat.direct.green = 8;
298 desiredFormat.direct.blue = 0;
299
300 pictFormat = xRenderFindFormat (display,
301 PictFormatType | PictFormatDepth
302 | PictFormatRedMask | PictFormatRed
303 | PictFormatGreenMask | PictFormatGreen
304 | PictFormatBlueMask | PictFormatBlue
305 | PictFormatAlphaMask | PictFormatAlpha,
306 &desiredFormat,
307 0);
308 }
309 }
310
311 return pictFormat;
312 }
313 }
314 #endif
315
316 //==============================================================================
317 namespace Visuals
318 {
319 static Visual* findVisualWithDepth (const int desiredDepth) noexcept
320 {
321 ScopedXLock xlock;
322
323 Visual* visual = nullptr;
324 int numVisuals = 0;
325 long desiredMask = VisualNoMask;
326 XVisualInfo desiredVisual;
327
328 desiredVisual.screen = DefaultScreen (display);
329 desiredVisual.depth = desiredDepth;
330
331 desiredMask = VisualScreenMask | VisualDepthMask;
332
333 if (desiredDepth == 32)
334 {
335 desiredVisual.c_class = TrueColor;
336 desiredVisual.red_mask = 0x00FF0000;
337 desiredVisual.green_mask = 0x0000FF00;
338 desiredVisual.blue_mask = 0x000000FF;
339 desiredVisual.bits_per_rgb = 8;
340
341 desiredMask |= VisualClassMask;
342 desiredMask |= VisualRedMaskMask;
343 desiredMask |= VisualGreenMaskMask;
344 desiredMask |= VisualBlueMaskMask;
345 desiredMask |= VisualBitsPerRGBMask;
346 }
347
348 XVisualInfo* xvinfos = XGetVisualInfo (display,
349 desiredMask,
350 &desiredVisual,
351 &numVisuals);
352
353 if (xvinfos != 0)
354 {
355 for (int i = 0; i < numVisuals; i++)
356 {
357 if (xvinfos[i].depth == desiredDepth)
358 {
359 visual = xvinfos[i].visual;
360 break;
361 }
362 }
363
364 XFree (xvinfos);
365 }
366
367 return visual;
368 }
369
370 static Visual* findVisualFormat (const int desiredDepth, int& matchedDepth) noexcept
371 {
372 Visual* visual = nullptr;
373
374 if (desiredDepth == 32)
375 {
376 #if JUCE_USE_XSHM
377 if (XSHMHelpers::isShmAvailable())
378 {
379 #if JUCE_USE_XRENDER
380 if (XRender::isAvailable())
381 {
382 XRenderPictFormat* pictFormat = XRender::findPictureFormat();
383
384 if (pictFormat != 0)
385 {
386 int numVisuals = 0;
387 XVisualInfo desiredVisual;
388 desiredVisual.screen = DefaultScreen (display);
389 desiredVisual.depth = 32;
390 desiredVisual.bits_per_rgb = 8;
391
392 XVisualInfo* xvinfos = XGetVisualInfo (display,
393 VisualScreenMask | VisualDepthMask | VisualBitsPerRGBMask,
394 &desiredVisual, &numVisuals);
395 if (xvinfos != 0)
396 {
397 for (int i = 0; i < numVisuals; ++i)
398 {
399 XRenderPictFormat* pictVisualFormat = XRender::xRenderFindVisualFormat (display, xvinfos[i].visual);
400
401 if (pictVisualFormat != 0
402 && pictVisualFormat->type == PictTypeDirect
403 && pictVisualFormat->direct.alphaMask)
404 {
405 visual = xvinfos[i].visual;
406 matchedDepth = 32;
407 break;
408 }
409 }
410
411 XFree (xvinfos);
412 }
413 }
414 }
415 #endif
416 if (visual == 0)
417 {
418 visual = findVisualWithDepth (32);
419 if (visual != 0)
420 matchedDepth = 32;
421 }
422 }
423 #endif
424 }
425
426 if (visual == 0 && desiredDepth >= 24)
427 {
428 visual = findVisualWithDepth (24);
429 if (visual != 0)
430 matchedDepth = 24;
431 }
432
433 if (visual == 0 && desiredDepth >= 16)
434 {
435 visual = findVisualWithDepth (16);
436 if (visual != 0)
437 matchedDepth = 16;
438 }
439
440 return visual;
441 }
442 }
443
444 //==============================================================================
445 class XBitmapImage : public Image::SharedImage
446 {
447 public:
448 //==============================================================================
449 XBitmapImage (const Image::PixelFormat format_, const int w, const int h,
450 const bool clearImage, const int imageDepth_, Visual* visual)
451 : Image::SharedImage (format_, w, h),
452 imageDepth (imageDepth_),
453 gc (None)
454 {
455 jassert (format_ == Image::RGB || format_ == Image::ARGB);
456
457 pixelStride = (format_ == Image::RGB) ? 3 : 4;
458 lineStride = ((w * pixelStride + 3) & ~3);
459
460 ScopedXLock xlock;
461
462 #if JUCE_USE_XSHM
463 usingXShm = false;
464
465 if ((imageDepth > 16) && XSHMHelpers::isShmAvailable())
466 {
467 zerostruct (segmentInfo);
468
469 segmentInfo.shmid = -1;
470 segmentInfo.shmaddr = (char *) -1;
471 segmentInfo.readOnly = False;
472
473 xImage = XShmCreateImage (display, visual, imageDepth, ZPixmap, 0, &segmentInfo, w, h);
474
475 if (xImage != 0)
476 {
477 if ((segmentInfo.shmid = shmget (IPC_PRIVATE,
478 xImage->bytes_per_line * xImage->height,
479 IPC_CREAT | 0777)) >= 0)
480 {
481 if (segmentInfo.shmid != -1)
482 {
483 segmentInfo.shmaddr = (char*) shmat (segmentInfo.shmid, 0, 0);
484
485 if (segmentInfo.shmaddr != (void*) -1)
486 {
487 segmentInfo.readOnly = False;
488
489 xImage->data = segmentInfo.shmaddr;
490 imageData = (uint8*) segmentInfo.shmaddr;
491
492 if (XShmAttach (display, &segmentInfo) != 0)
493 usingXShm = true;
494 else
495 jassertfalse;
496 }
497 else
498 {
499 shmctl (segmentInfo.shmid, IPC_RMID, 0);
500 }
501 }
502 }
503 }
504 }
505
506 if (! usingXShm)
507 #endif
508 {
509 imageDataAllocated.allocate (lineStride * h, format_ == Image::ARGB && clearImage);
510 imageData = imageDataAllocated;
511
512 xImage = (XImage*) ::calloc (1, sizeof (XImage));
513
514 xImage->width = w;
515 xImage->height = h;
516 xImage->xoffset = 0;
517 xImage->format = ZPixmap;
518 xImage->data = (char*) imageData;
519 xImage->byte_order = ImageByteOrder (display);
520 xImage->bitmap_unit = BitmapUnit (display);
521 xImage->bitmap_bit_order = BitmapBitOrder (display);
522 xImage->bitmap_pad = 32;
523 xImage->depth = pixelStride * 8;
524 xImage->bytes_per_line = lineStride;
525 xImage->bits_per_pixel = pixelStride * 8;
526 xImage->red_mask = 0x00FF0000;
527 xImage->green_mask = 0x0000FF00;
528 xImage->blue_mask = 0x000000FF;
529
530 if (imageDepth == 16)
531 {
532 const int pixelStride = 2;
533 const int lineStride = ((w * pixelStride + 3) & ~3);
534
535 imageData16Bit.malloc (lineStride * h);
536 xImage->data = imageData16Bit;
537 xImage->bitmap_pad = 16;
538 xImage->depth = pixelStride * 8;
539 xImage->bytes_per_line = lineStride;
540 xImage->bits_per_pixel = pixelStride * 8;
541 xImage->red_mask = visual->red_mask;
542 xImage->green_mask = visual->green_mask;
543 xImage->blue_mask = visual->blue_mask;
544 }
545
546 if (! XInitImage (xImage))
547 jassertfalse;
548 }
549 }
550
551 ~XBitmapImage()
552 {
553 ScopedXLock xlock;
554
555 if (gc != None)
556 XFreeGC (display, gc);
557
558 #if JUCE_USE_XSHM
559 if (usingXShm)
560 {
561 XShmDetach (display, &segmentInfo);
562
563 XFlush (display);
564 XDestroyImage (xImage);
565
566 shmdt (segmentInfo.shmaddr);
567 shmctl (segmentInfo.shmid, IPC_RMID, 0);
568 }
569 else
570 #endif
571 {
572 xImage->data = nullptr;
573 XDestroyImage (xImage);
574 }
575 }
576
577 Image::ImageType getType() const { return Image::NativeImage; }
578
579 LowLevelGraphicsContext* createLowLevelContext()
580 {
581 return new LowLevelGraphicsSoftwareRenderer (Image (this));
582 }
583
584 void initialiseBitmapData (Image::BitmapData& bitmap, int x, int y, Image::BitmapData::ReadWriteMode /*mode*/)
585 {
586 bitmap.data = imageData + x * pixelStride + y * lineStride;
587 bitmap.pixelFormat = format;
588 bitmap.lineStride = lineStride;
589 bitmap.pixelStride = pixelStride;
590 }
591
592 SharedImage* clone()
593 {
594 jassertfalse;
595 return nullptr;
596 }
597
598 void blitToWindow (Window window, int dx, int dy, int dw, int dh, int sx, int sy)
599 {
600 ScopedXLock xlock;
601
602 if (gc == None)
603 {
604 XGCValues gcvalues;
605 gcvalues.foreground = None;
606 gcvalues.background = None;
607 gcvalues.function = GXcopy;
608 gcvalues.plane_mask = AllPlanes;
609 gcvalues.clip_mask = None;
610 gcvalues.graphics_exposures = False;
611
612 gc = XCreateGC (display, window,
613 GCBackground | GCForeground | GCFunction | GCPlaneMask | GCClipMask | GCGraphicsExposures,
614 &gcvalues);
615 }
616
617 if (imageDepth == 16)
618 {
619 const uint32 rMask = xImage->red_mask;
620 const uint32 rShiftL = jmax (0, getShiftNeeded (rMask));
621 const uint32 rShiftR = jmax (0, -getShiftNeeded (rMask));
622 const uint32 gMask = xImage->green_mask;
623 const uint32 gShiftL = jmax (0, getShiftNeeded (gMask));
624 const uint32 gShiftR = jmax (0, -getShiftNeeded (gMask));
625 const uint32 bMask = xImage->blue_mask;
626 const uint32 bShiftL = jmax (0, getShiftNeeded (bMask));
627 const uint32 bShiftR = jmax (0, -getShiftNeeded (bMask));
628
629 const Image::BitmapData srcData (Image (this), Image::BitmapData::readOnly);
630
631 for (int y = sy; y < sy + dh; ++y)
632 {
633 const uint8* p = srcData.getPixelPointer (sx, y);
634
635 for (int x = sx; x < sx + dw; ++x)
636 {
637 const PixelRGB* const pixel = (const PixelRGB*) p;
638 p += srcData.pixelStride;
639
640 XPutPixel (xImage, x, y,
641 (((((uint32) pixel->getRed()) << rShiftL) >> rShiftR) & rMask)
642 | (((((uint32) pixel->getGreen()) << gShiftL) >> gShiftR) & gMask)
643 | (((((uint32) pixel->getBlue()) << bShiftL) >> bShiftR) & bMask));
644 }
645 }
646 }
647
648 // blit results to screen.
649 #if JUCE_USE_XSHM
650 if (usingXShm)
651 XShmPutImage (display, (::Drawable) window, gc, xImage, sx, sy, dx, dy, dw, dh, True);
652 else
653 #endif
654 XPutImage (display, (::Drawable) window, gc, xImage, sx, sy, dx, dy, dw, dh);
655 }
656
657 //==============================================================================
658 private:
659 XImage* xImage;
660 const int imageDepth;
661 HeapBlock <uint8> imageDataAllocated;
662 HeapBlock <char> imageData16Bit;
663 int pixelStride, lineStride;
664 uint8* imageData;
665 GC gc;
666
667 #if JUCE_USE_XSHM
668 XShmSegmentInfo segmentInfo;
669 bool usingXShm;
670 #endif
671
672 static int getShiftNeeded (const uint32 mask) noexcept
673 {
674 for (int i = 32; --i >= 0;)
675 if (((mask >> i) & 1) != 0)
676 return i - 7;
677
678 jassertfalse;
679 return 0;
680 }
681
682 JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (XBitmapImage);
683 };
684
685 namespace PixmapHelpers
686 {
687 Pixmap createColourPixmapFromImage (Display* display, const Image& image)
688 {
689 ScopedXLock xlock;
690
691 const int width = image.getWidth();
692 const int height = image.getHeight();
693 HeapBlock <uint32> colour (width * height);
694 int index = 0;
695
696 for (int y = 0; y < height; ++y)
697 for (int x = 0; x < width; ++x)
698 colour[index++] = image.getPixelAt (x, y).getARGB();
699
700 XImage* ximage = XCreateImage (display, CopyFromParent, 24, ZPixmap,
701 0, reinterpret_cast<char*> (colour.getData()),
702 width, height, 32, 0);
703
704 Pixmap pixmap = XCreatePixmap (display, DefaultRootWindow (display),
705 width, height, 24);
706
707 GC gc = XCreateGC (display, pixmap, 0, 0);
708 XPutImage (display, pixmap, gc, ximage, 0, 0, 0, 0, width, height);
709 XFreeGC (display, gc);
710
711 return pixmap;
712 }
713
714 Pixmap createMaskPixmapFromImage (Display* display, const Image& image)
715 {
716 ScopedXLock xlock;
717
718 const int width = image.getWidth();
719 const int height = image.getHeight();
720 const int stride = (width + 7) >> 3;
721 HeapBlock <char> mask;
722 mask.calloc (stride * height);
723 const bool msbfirst = (BitmapBitOrder (display) == MSBFirst);
724
725 for (int y = 0; y < height; ++y)
726 {
727 for (int x = 0; x < width; ++x)
728 {
729 const char bit = (char) (1 << (msbfirst ? (7 - (x & 7)) : (x & 7)));
730 const int offset = y * stride + (x >> 3);
731
732 if (image.getPixelAt (x, y).getAlpha() >= 128)
733 mask[offset] |= bit;
734 }
735 }
736
737 return XCreatePixmapFromBitmapData (display, DefaultRootWindow (display),
738 mask.getData(), width, height, 1, 0, 1);
739 }
740 }
741
742
743 //==============================================================================
744 class LinuxComponentPeer : public ComponentPeer
745 {
746 public:
747 //==============================================================================
748 LinuxComponentPeer (Component* const component, const int windowStyleFlags, Window parentToAddTo)
749 : ComponentPeer (component, windowStyleFlags),
750 windowH (0), parentWindow (0),
751 wx (0), wy (0), ww (0), wh (0),
752 fullScreen (false), mapped (false),
753 visual (0), depth (0)
754 {
755 // it's dangerous to create a window on a thread other than the message thread..
756 jassert (MessageManager::getInstance()->currentThreadHasLockedMessageManager());
757
758 repainter = new LinuxRepaintManager (this);
759
760 createWindow (parentToAddTo);
761
762 setTitle (component->getName());
763 }
764
765 ~LinuxComponentPeer()
766 {
767 // it's dangerous to delete a window on a thread other than the message thread..
768 jassert (MessageManager::getInstance()->currentThreadHasLockedMessageManager());
769
770 deleteIconPixmaps();
771
772 destroyWindow();
773
774 windowH = 0;
775 }
776
777 //==============================================================================
778 void* getNativeHandle() const
779 {
780 return (void*) windowH;
781 }
782
783 static LinuxComponentPeer* getPeerFor (Window windowHandle) noexcept
784 {
785 XPointer peer = 0;
786
787 ScopedXLock xlock;
788 if (! XFindContext (display, (XID) windowHandle, windowHandleXContext, &peer))
789 {
790 if (peer != nullptr && ! ComponentPeer::isValidPeer ((LinuxComponentPeer*) peer))
791 peer = 0;
792 }
793
794 return (LinuxComponentPeer*) peer;
795 }
796
797 void setVisible (bool shouldBeVisible)
798 {
799 ScopedXLock xlock;
800 if (shouldBeVisible)
801 XMapWindow (display, windowH);
802 else
803 XUnmapWindow (display, windowH);
804 }
805
806 void setTitle (const String& title)
807 {
808 XTextProperty nameProperty;
809 char* strings[] = { const_cast <char*> (title.toUTF8().getAddress()) };
810 ScopedXLock xlock;
811
812 if (XStringListToTextProperty (strings, 1, &nameProperty))
813 {
814 XSetWMName (display, windowH, &nameProperty);
815 XSetWMIconName (display, windowH, &nameProperty);
816
817 XFree (nameProperty.value);
818 }
819 }
820
821 void setBounds (int x, int y, int w, int h, bool isNowFullScreen)
822 {
823 fullScreen = isNowFullScreen;
824
825 if (windowH != 0)
826 {
827 WeakReference<Component> deletionChecker (component);
828
829 wx = x;
830 wy = y;
831 ww = jmax (1, w);
832 wh = jmax (1, h);
833
834 ScopedXLock xlock;
835
836 // Make sure the Window manager does what we want
837 XSizeHints* hints = XAllocSizeHints();
838 hints->flags = USSize | USPosition;
839 hints->width = ww;
840 hints->height = wh;
841 hints->x = wx;
842 hints->y = wy;
843
844 if ((getStyleFlags() & (windowHasTitleBar | windowIsResizable)) == windowHasTitleBar)
845 {
846 hints->min_width = hints->max_width = hints->width;
847 hints->min_height = hints->max_height = hints->height;
848 hints->flags |= PMinSize | PMaxSize;
849 }
850
851 XSetWMNormalHints (display, windowH, hints);
852 XFree (hints);
853
854 XMoveResizeWindow (display, windowH,
855 wx - windowBorder.getLeft(),
856 wy - windowBorder.getTop(), ww, wh);
857
858 if (deletionChecker != 0)
859 {
860 updateBorderSize();
861 handleMovedOrResized();
862 }
863 }
864 }
865
866 void setPosition (int x, int y) { setBounds (x, y, ww, wh, false); }
867 void setSize (int w, int h) { setBounds (wx, wy, w, h, false); }
868 const Rectangle<int> getBounds() const { return Rectangle<int> (wx, wy, ww, wh); }
869 const Point<int> getScreenPosition() const { return Point<int> (wx, wy); }
870
871 const Point<int> localToGlobal (const Point<int>& relativePosition)
872 {
873 return relativePosition + getScreenPosition();
874 }
875
876 const Point<int> globalToLocal (const Point<int>& screenPosition)
877 {
878 return screenPosition - getScreenPosition();
879 }
880
881 void setAlpha (float newAlpha)
882 {
883 //xxx todo!
884 }
885
886 void setMinimised (bool shouldBeMinimised)
887 {
888 if (shouldBeMinimised)
889 {
890 Window root = RootWindow (display, DefaultScreen (display));
891
892 XClientMessageEvent clientMsg;
893 clientMsg.display = display;
894 clientMsg.window = windowH;
895 clientMsg.type = ClientMessage;
896 clientMsg.format = 32;
897 clientMsg.message_type = Atoms::ChangeState;
898 clientMsg.data.l[0] = IconicState;
899
900 ScopedXLock xlock;
901 XSendEvent (display, root, false, SubstructureRedirectMask | SubstructureNotifyMask, (XEvent*) &clientMsg);
902 }
903 else
904 {
905 setVisible (true);
906 }
907 }
908
909 bool isMinimised() const
910 {
911 bool minimised = false;
912
913 unsigned char* stateProp;
914 unsigned long nitems, bytesLeft;
915 Atom actualType;
916 int actualFormat;
917
918 ScopedXLock xlock;
919 if (XGetWindowProperty (display, windowH, Atoms::State, 0, 64, False,
920 Atoms::State, &actualType, &actualFormat, &nitems, &bytesLeft,
921 &stateProp) == Success
922 && actualType == Atoms::State
923 && actualFormat == 32
924 && nitems > 0)
925 {
926 if (((unsigned long*) stateProp)[0] == IconicState)
927 minimised = true;
928
929 XFree (stateProp);
930 }
931
932 return minimised;
933 }
934
935 void setFullScreen (const bool shouldBeFullScreen)
936 {
937 Rectangle<int> r (lastNonFullscreenBounds); // (get a copy of this before de-minimising)
938
939 setMinimised (false);
940
941 if (fullScreen != shouldBeFullScreen)
942 {
943 if (shouldBeFullScreen)
944 r = Desktop::getInstance().getMainMonitorArea();
945
946 if (! r.isEmpty())
947 setBounds (r.getX(), r.getY(), r.getWidth(), r.getHeight(), shouldBeFullScreen);
948
949 getComponent()->repaint();
950 }
951 }
952
953 bool isFullScreen() const
954 {
955 return fullScreen;
956 }
957
958 bool isChildWindowOf (Window possibleParent) const
959 {
960 Window* windowList = nullptr;
961 uint32 windowListSize = 0;
962 Window parent, root;
963
964 ScopedXLock xlock;
965 if (XQueryTree (display, windowH, &root, &parent, &windowList, &windowListSize) != 0)
966 {
967 if (windowList != 0)
968 XFree (windowList);
969
970 return parent == possibleParent;
971 }
972
973 return false;
974 }
975
976 bool isFrontWindow() const
977 {
978 Window* windowList = nullptr;
979 uint32 windowListSize = 0;
980 bool result = false;
981
982 ScopedXLock xlock;
983 Window parent, root = RootWindow (display, DefaultScreen (display));
984
985 if (XQueryTree (display, root, &root, &parent, &windowList, &windowListSize) != 0)
986 {
987 for (int i = windowListSize; --i >= 0;)
988 {
989 LinuxComponentPeer* const peer = LinuxComponentPeer::getPeerFor (windowList[i]);
990
991 if (peer != 0)
992 {
993 result = (peer == this);
994 break;
995 }
996 }
997 }
998
999 if (windowList != 0)
1000 XFree (windowList);
1001
1002 return result;
1003 }
1004
1005 bool contains (const Point<int>& position, bool trueIfInAChildWindow) const
1006 {
1007 if (! (isPositiveAndBelow (position.getX(), ww) && isPositiveAndBelow (position.getY(), wh)))
1008 return false;
1009
1010 for (int i = Desktop::getInstance().getNumComponents(); --i >= 0;)
1011 {
1012 Component* const c = Desktop::getInstance().getComponent (i);
1013
1014 if (c == getComponent())
1015 break;
1016
1017 if (c->contains (position + Point<int> (wx, wy) - c->getScreenPosition()))
1018 return false;
1019 }
1020
1021 if (trueIfInAChildWindow)
1022 return true;
1023
1024 ::Window root, child;
1025 unsigned int bw, depth;
1026 int wx, wy, w, h;
1027
1028 ScopedXLock xlock;
1029 if (! XGetGeometry (display, (::Drawable) windowH, &root,
1030 &wx, &wy, (unsigned int*) &w, (unsigned int*) &h,
1031 &bw, &depth))
1032 {
1033 return false;
1034 }
1035
1036 if (! XTranslateCoordinates (display, windowH, windowH, position.getX(), position.getY(), &wx, &wy, &child))
1037 return false;
1038
1039 return child == None;
1040 }
1041
1042 const BorderSize<int> getFrameSize() const
1043 {
1044 return BorderSize<int>();
1045 }
1046
1047 bool setAlwaysOnTop (bool alwaysOnTop)
1048 {
1049 return false;
1050 }
1051
1052 void toFront (bool makeActive)
1053 {
1054 if (makeActive)
1055 {
1056 setVisible (true);
1057 grabFocus();
1058 }
1059
1060 XEvent ev;
1061 ev.xclient.type = ClientMessage;
1062 ev.xclient.serial = 0;
1063 ev.xclient.send_event = True;
1064 ev.xclient.message_type = Atoms::ActiveWin;
1065 ev.xclient.window = windowH;
1066 ev.xclient.format = 32;
1067 ev.xclient.data.l[0] = 2;
1068 ev.xclient.data.l[1] = CurrentTime;
1069 ev.xclient.data.l[2] = 0;
1070 ev.xclient.data.l[3] = 0;
1071 ev.xclient.data.l[4] = 0;
1072
1073 {
1074 ScopedXLock xlock;
1075 XSendEvent (display, RootWindow (display, DefaultScreen (display)),
1076 False, SubstructureRedirectMask | SubstructureNotifyMask, &ev);
1077
1078 XWindowAttributes attr;
1079 XGetWindowAttributes (display, windowH, &attr);
1080
1081 if (component->isAlwaysOnTop())
1082 XRaiseWindow (display, windowH);
1083
1084 XSync (display, False);
1085 }
1086
1087 handleBroughtToFront();
1088 }
1089
1090 void toBehind (ComponentPeer* other)
1091 {
1092 LinuxComponentPeer* const otherPeer = dynamic_cast <LinuxComponentPeer*> (other);
1093 jassert (otherPeer != nullptr); // wrong type of window?
1094
1095 if (otherPeer != nullptr)
1096 {
1097 setMinimised (false);
1098
1099 Window newStack[] = { otherPeer->windowH, windowH };
1100
1101 ScopedXLock xlock;
1102 XRestackWindows (display, newStack, 2);
1103 }
1104 }
1105
1106 bool isFocused() const
1107 {
1108 int revert = 0;
1109 Window focusedWindow = 0;
1110 ScopedXLock xlock;
1111 XGetInputFocus (display, &focusedWindow, &revert);
1112
1113 return focusedWindow == windowH;
1114 }
1115
1116 void grabFocus()
1117 {
1118 XWindowAttributes atts;
1119 ScopedXLock xlock;
1120
1121 if (windowH != 0
1122 && XGetWindowAttributes (display, windowH, &atts)
1123 && atts.map_state == IsViewable
1124 && ! isFocused())
1125 {
1126 XSetInputFocus (display, windowH, RevertToParent, CurrentTime);
1127 isActiveApplication = true;
1128 }
1129 }
1130
1131 void textInputRequired (const Point<int>&)
1132 {
1133 }
1134
1135 void repaint (const Rectangle<int>& area)
1136 {
1137 repainter->repaint (area.getIntersection (getComponent()->getLocalBounds()));
1138 }
1139
1140 void performAnyPendingRepaintsNow()
1141 {
1142 repainter->performAnyPendingRepaintsNow();
1143 }
1144
1145 void setIcon (const Image& newIcon)
1146 {
1147 const int dataSize = newIcon.getWidth() * newIcon.getHeight() + 2;
1148 HeapBlock <unsigned long> data (dataSize);
1149
1150 int index = 0;
1151 data[index++] = newIcon.getWidth();
1152 data[index++] = newIcon.getHeight();
1153
1154 for (int y = 0; y < newIcon.getHeight(); ++y)
1155 for (int x = 0; x < newIcon.getWidth(); ++x)
1156 data[index++] = newIcon.getPixelAt (x, y).getARGB();
1157
1158 ScopedXLock xlock;
1159 XChangeProperty (display, windowH,
1160 XInternAtom (display, "_NET_WM_ICON", False),
1161 XA_CARDINAL, 32, PropModeReplace,
1162 reinterpret_cast<unsigned char*> (data.getData()), dataSize);
1163
1164 deleteIconPixmaps();
1165
1166 XWMHints* wmHints = XGetWMHints (display, windowH);
1167
1168 if (wmHints == 0)
1169 wmHints = XAllocWMHints();
1170
1171 wmHints->flags |= IconPixmapHint | IconMaskHint;
1172 wmHints->icon_pixmap = PixmapHelpers::createColourPixmapFromImage (display, newIcon);
1173 wmHints->icon_mask = PixmapHelpers::createMaskPixmapFromImage (display, newIcon);
1174
1175 XSetWMHints (display, windowH, wmHints);
1176 XFree (wmHints);
1177
1178 XSync (display, False);
1179 }
1180
1181 void deleteIconPixmaps()
1182 {
1183 ScopedXLock xlock;
1184 XWMHints* wmHints = XGetWMHints (display, windowH);
1185
1186 if (wmHints != 0)
1187 {
1188 if ((wmHints->flags & IconPixmapHint) != 0)
1189 {
1190 wmHints->flags &= ~IconPixmapHint;
1191 XFreePixmap (display, wmHints->icon_pixmap);
1192 }
1193
1194 if ((wmHints->flags & IconMaskHint) != 0)
1195 {
1196 wmHints->flags &= ~IconMaskHint;
1197 XFreePixmap (display, wmHints->icon_mask);
1198 }
1199
1200 XSetWMHints (display, windowH, wmHints);
1201 XFree (wmHints);
1202 }
1203 }
1204
1205 //==============================================================================
1206 void handleWindowMessage (XEvent* event)
1207 {
1208 switch (event->xany.type)
1209 {
1210 case 2: /* KeyPress */ handleKeyPressEvent ((XKeyEvent*) &event->xkey); break;
1211 case KeyRelease: handleKeyReleaseEvent ((const XKeyEvent*) &event->xkey); break;
1212 case ButtonPress: handleButtonPressEvent ((const XButtonPressedEvent*) &event->xbutton); break;
1213 case ButtonRelease: handleButtonReleaseEvent ((const XButtonReleasedEvent*) &event->xbutton); break;
1214 case MotionNotify: handleMotionNotifyEvent ((const XPointerMovedEvent*) &event->xmotion); break;
1215 case EnterNotify: handleEnterNotifyEvent ((const XEnterWindowEvent*) &event->xcrossing); break;
1216 case LeaveNotify: handleLeaveNotifyEvent ((const XLeaveWindowEvent*) &event->xcrossing); break;
1217 case FocusIn: handleFocusInEvent(); break;
1218 case FocusOut: handleFocusOutEvent(); break;
1219 case Expose: handleExposeEvent ((XExposeEvent*) &event->xexpose); break;
1220 case MappingNotify: handleMappingNotify ((XMappingEvent*) &event->xmapping); break;
1221 case ClientMessage: handleClientMessageEvent ((XClientMessageEvent*) &event->xclient, event); break;
1222 case SelectionNotify: handleDragAndDropSelection (event); break;
1223 case ConfigureNotify: handleConfigureNotifyEvent ((XConfigureEvent*) &event->xconfigure); break;
1224 case ReparentNotify: handleReparentNotifyEvent(); break;
1225 case GravityNotify: handleGravityNotify(); break;
1226
1227 case CirculateNotify:
1228 case CreateNotify:
1229 case DestroyNotify:
1230 // Think we can ignore these
1231 break;
1232
1233 case MapNotify:
1234 mapped = true;
1235 handleBroughtToFront();
1236 break;
1237
1238 case UnmapNotify:
1239 mapped = false;
1240 break;
1241
1242 case SelectionClear:
1243 case SelectionRequest:
1244 break;
1245
1246 default:
1247 #if JUCE_USE_XSHM
1248 {
1249 ScopedXLock xlock;
1250 if (event->xany.type == XShmGetEventBase (display))
1251 repainter->notifyPaintCompleted();
1252 }
1253 #endif
1254 break;
1255 }
1256 }
1257
1258 void handleKeyPressEvent (XKeyEvent* const keyEvent)
1259 {
1260 char utf8 [64] = { 0 };
1261 juce_wchar unicodeChar = 0;
1262 int keyCode = 0;
1263 bool keyDownChange = false;
1264 KeySym sym;
1265
1266 {
1267 ScopedXLock xlock;
1268 updateKeyStates (keyEvent->keycode, true);
1269
1270 const char* oldLocale = ::setlocale (LC_ALL, 0);
1271 ::setlocale (LC_ALL, "");
1272 XLookupString (keyEvent, utf8, sizeof (utf8), &sym, 0);
1273 ::setlocale (LC_ALL, oldLocale);
1274
1275 unicodeChar = String::fromUTF8 (utf8, sizeof (utf8) - 1) [0];
1276 keyCode = (int) unicodeChar;
1277
1278 if (keyCode < 0x20)
1279 keyCode = XKeycodeToKeysym (display, keyEvent->keycode, currentModifiers.isShiftDown() ? 1 : 0);
1280
1281 keyDownChange = (sym != NoSymbol) && ! updateKeyModifiersFromSym (sym, true);
1282 }
1283
1284 const ModifierKeys oldMods (currentModifiers);
1285 bool keyPressed = false;
1286
1287 if ((sym & 0xff00) == 0xff00)
1288 {
1289 switch (sym) // Translate keypad
1290 {
1291 case XK_KP_Divide: keyCode = XK_slash; break;
1292 case XK_KP_Multiply: keyCode = XK_asterisk; break;
1293 case XK_KP_Subtract: keyCode = XK_hyphen; break;
1294 case XK_KP_Add: keyCode = XK_plus; break;
1295 case XK_KP_Enter: keyCode = XK_Return; break;
1296 case XK_KP_Decimal: keyCode = Keys::numLock ? XK_period : XK_Delete; break;
1297 case XK_KP_0: keyCode = Keys::numLock ? XK_0 : XK_Insert; break;
1298 case XK_KP_1: keyCode = Keys::numLock ? XK_1 : XK_End; break;
1299 case XK_KP_2: keyCode = Keys::numLock ? XK_2 : XK_Down; break;
1300 case XK_KP_3: keyCode = Keys::numLock ? XK_3 : XK_Page_Down; break;
1301 case XK_KP_4: keyCode = Keys::numLock ? XK_4 : XK_Left; break;
1302 case XK_KP_5: keyCode = XK_5; break;
1303 case XK_KP_6: keyCode = Keys::numLock ? XK_6 : XK_Right; break;
1304 case XK_KP_7: keyCode = Keys::numLock ? XK_7 : XK_Home; break;
1305 case XK_KP_8: keyCode = Keys::numLock ? XK_8 : XK_Up; break;
1306 case XK_KP_9: keyCode = Keys::numLock ? XK_9 : XK_Page_Up; break;
1307 default: break;
1308 }
1309
1310 switch (sym)
1311 {
1312 case XK_Left:
1313 case XK_Right:
1314 case XK_Up:
1315 case XK_Down:
1316 case XK_Page_Up:
1317 case XK_Page_Down:
1318 case XK_End:
1319 case XK_Home:
1320 case XK_Delete:
1321 case XK_Insert:
1322 keyPressed = true;
1323 keyCode = (sym & 0xff) | Keys::extendedKeyModifier;
1324 break;
1325
1326 case XK_Tab:
1327 case XK_Return:
1328 case XK_Escape:
1329 case XK_BackSpace:
1330 keyPressed = true;
1331 keyCode &= 0xff;
1332 break;
1333
1334 default:
1335 if (sym >= XK_F1 && sym <= XK_F16)
1336 {
1337 keyPressed = true;
1338 keyCode = (sym & 0xff) | Keys::extendedKeyModifier;
1339 }
1340 break;
1341 }
1342 }
1343
1344 if (utf8[0] != 0 || ((sym & 0xff00) == 0 && sym >= 8))
1345 keyPressed = true;
1346
1347 if (oldMods != currentModifiers)
1348 handleModifierKeysChange();
1349
1350 if (keyDownChange)
1351 handleKeyUpOrDown (true);
1352
1353 if (keyPressed)
1354 handleKeyPress (keyCode, unicodeChar);
1355 }
1356
1357 void handleKeyReleaseEvent (const XKeyEvent* const keyEvent)
1358 {
1359 updateKeyStates (keyEvent->keycode, false);
1360 KeySym sym;
1361
1362 {
1363 ScopedXLock xlock;
1364 sym = XKeycodeToKeysym (display, keyEvent->keycode, 0);
1365 }
1366
1367 const ModifierKeys oldMods (currentModifiers);
1368 const bool keyDownChange = (sym != NoSymbol) && ! updateKeyModifiersFromSym (sym, false);
1369
1370 if (oldMods != currentModifiers)
1371 handleModifierKeysChange();
1372
1373 if (keyDownChange)
1374 handleKeyUpOrDown (false);
1375 }
1376
1377 void handleButtonPressEvent (const XButtonPressedEvent* const buttonPressEvent)
1378 {
1379 updateKeyModifiers (buttonPressEvent->state);
1380
1381 bool buttonMsg = false;
1382 const int map = pointerMap [buttonPressEvent->button - Button1];
1383
1384 if (map == Keys::WheelUp || map == Keys::WheelDown)
1385 {
1386 handleMouseWheel (0, Point<int> (buttonPressEvent->x, buttonPressEvent->y),
1387 getEventTime (buttonPressEvent->time), 0, map == Keys::WheelDown ? -84.0f : 84.0f);
1388 }
1389 if (map == Keys::LeftButton)
1390 {
1391 currentModifiers = currentModifiers.withFlags (ModifierKeys::leftButtonModifier);
1392 buttonMsg = true;
1393 }
1394 else if (map == Keys::RightButton)
1395 {
1396 currentModifiers = currentModifiers.withFlags (ModifierKeys::rightButtonModifier);
1397 buttonMsg = true;
1398 }
1399 else if (map == Keys::MiddleButton)
1400 {
1401 currentModifiers = currentModifiers.withFlags (ModifierKeys::middleButtonModifier);
1402 buttonMsg = true;
1403 }
1404
1405 if (buttonMsg)
1406 {
1407 toFront (true);
1408
1409 handleMouseEvent (0, Point<int> (buttonPressEvent->x, buttonPressEvent->y), currentModifiers,
1410 getEventTime (buttonPressEvent->time));
1411 }
1412
1413 clearLastMousePos();
1414 }
1415
1416 void handleButtonReleaseEvent (const XButtonReleasedEvent* const buttonRelEvent)
1417 {
1418 updateKeyModifiers (buttonRelEvent->state);
1419 const int map = pointerMap [buttonRelEvent->button - Button1];
1420
1421 if (map == Keys::LeftButton) currentModifiers = currentModifiers.withoutFlags (ModifierKeys::leftButtonModifier);
1422 else if (map == Keys::RightButton) currentModifiers = currentModifiers.withoutFlags (ModifierKeys::rightButtonModifier);
1423 else if (map == Keys::MiddleButton) currentModifiers = currentModifiers.withoutFlags (ModifierKeys::middleButtonModifier);
1424
1425 handleMouseEvent (0, Point<int> (buttonRelEvent->x, buttonRelEvent->y), currentModifiers,
1426 getEventTime (buttonRelEvent->time));
1427
1428 clearLastMousePos();
1429 }
1430
1431 void handleMotionNotifyEvent (const XPointerMovedEvent* const movedEvent)
1432 {
1433 updateKeyModifiers (movedEvent->state);
1434 const Point<int> mousePos (movedEvent->x_root, movedEvent->y_root);
1435
1436 if (lastMousePos != mousePos)
1437 {
1438 lastMousePos = mousePos;
1439
1440 if (parentWindow != nullptr && (styleFlags & windowHasTitleBar) == 0)
1441 {
1442 Window wRoot = 0, wParent = 0;
1443
1444 {
1445 ScopedXLock xlock;
1446 unsigned int numChildren;
1447 Window* wChild = nullptr;
1448 XQueryTree (display, windowH, &wRoot, &wParent, &wChild, &numChildren);
1449 }
1450
1451 if (wParent != 0
1452 && wParent != windowH
1453 && wParent != wRoot)
1454 {
1455 parentWindow = wParent;
1456 updateBounds();
1457 }
1458 else
1459 {
1460 parentWindow = 0;
1461 }
1462 }
1463
1464 handleMouseEvent (0, mousePos - getScreenPosition(), currentModifiers, getEventTime (movedEvent->time));
1465 }
1466 }
1467
1468 void handleEnterNotifyEvent (const XEnterWindowEvent* const enterEvent)
1469 {
1470 clearLastMousePos();
1471
1472 if (! currentModifiers.isAnyMouseButtonDown())
1473 {
1474 updateKeyModifiers (enterEvent->state);
1475 handleMouseEvent (0, Point<int> (enterEvent->x, enterEvent->y), currentModifiers, getEventTime (enterEvent->time));
1476 }
1477 }
1478
1479 void handleLeaveNotifyEvent (const XLeaveWindowEvent* const leaveEvent)
1480 {
1481 // Suppress the normal leave if we've got a pointer grab, or if
1482 // it's a bogus one caused by clicking a mouse button when running
1483 // in a Window manager
1484 if (((! currentModifiers.isAnyMouseButtonDown()) && leaveEvent->mode == NotifyNormal)
1485 || leaveEvent->mode == NotifyUngrab)
1486 {
1487 updateKeyModifiers (leaveEvent->state);
1488 handleMouseEvent (0, Point<int> (leaveEvent->x, leaveEvent->y), currentModifiers, getEventTime (leaveEvent->time));
1489 }
1490 }
1491
1492 void handleFocusInEvent()
1493 {
1494 isActiveApplication = true;
1495 if (isFocused())
1496 handleFocusGain();
1497 }
1498
1499 void handleFocusOutEvent()
1500 {
1501 isActiveApplication = false;
1502 if (! isFocused())
1503 handleFocusLoss();
1504 }
1505
1506 void handleExposeEvent (XExposeEvent* exposeEvent)
1507 {
1508 // Batch together all pending expose events
1509 XEvent nextEvent;
1510 ScopedXLock xlock;
1511
1512 if (exposeEvent->window != windowH)
1513 {
1514 Window child;
1515 XTranslateCoordinates (display, exposeEvent->window, windowH,
1516 exposeEvent->x, exposeEvent->y, &exposeEvent->x, &exposeEvent->y,
1517 &child);
1518 }
1519
1520 repaint (Rectangle<int> (exposeEvent->x, exposeEvent->y,
1521 exposeEvent->width, exposeEvent->height));
1522
1523 while (XEventsQueued (display, QueuedAfterFlush) > 0)
1524 {
1525 XPeekEvent (display, (XEvent*) &nextEvent);
1526 if (nextEvent.type != Expose || nextEvent.xany.window != exposeEvent->window)
1527 break;
1528
1529 XNextEvent (display, (XEvent*) &nextEvent);
1530 XExposeEvent* nextExposeEvent = (XExposeEvent*) &nextEvent.xexpose;
1531 repaint (Rectangle<int> (nextExposeEvent->x, nextExposeEvent->y,
1532 nextExposeEvent->width, nextExposeEvent->height));
1533 }
1534 }
1535
1536 void handleConfigureNotifyEvent (XConfigureEvent* const confEvent)
1537 {
1538 updateBounds();
1539 updateBorderSize();
1540 handleMovedOrResized();
1541
1542 // if the native title bar is dragged, need to tell any active menus, etc.
1543 if ((styleFlags & windowHasTitleBar) != 0
1544 && component->isCurrentlyBlockedByAnotherModalComponent())
1545 {
1546 Component* const currentModalComp = Component::getCurrentlyModalComponent();
1547
1548 if (currentModalComp != 0)
1549 currentModalComp->inputAttemptWhenModal();
1550 }
1551
1552 if (confEvent->window == windowH
1553 && confEvent->above != 0
1554 && isFrontWindow())
1555 {
1556 handleBroughtToFront();
1557 }
1558 }
1559
1560 void handleReparentNotifyEvent()
1561 {
1562 parentWindow = 0;
1563 Window wRoot = 0;
1564 Window* wChild = nullptr;
1565 unsigned int numChildren;
1566
1567 {
1568 ScopedXLock xlock;
1569 XQueryTree (display, windowH, &wRoot, &parentWindow, &wChild, &numChildren);
1570 }
1571
1572 if (parentWindow == windowH || parentWindow == wRoot)
1573 parentWindow = 0;
1574
1575 handleGravityNotify();
1576 }
1577
1578 void handleGravityNotify()
1579 {
1580 updateBounds();
1581 updateBorderSize();
1582 handleMovedOrResized();
1583 }
1584
1585 void handleMappingNotify (XMappingEvent* const mappingEvent)
1586 {
1587 if (mappingEvent->request != MappingPointer)
1588 {
1589 // Deal with modifier/keyboard mapping
1590 ScopedXLock xlock;
1591 XRefreshKeyboardMapping (mappingEvent);
1592 updateModifierMappings();
1593 }
1594 }
1595
1596 void handleClientMessageEvent (XClientMessageEvent* const clientMsg, XEvent* event)
1597 {
1598 if (clientMsg->message_type == Atoms::Protocols && clientMsg->format == 32)
1599 {
1600 const Atom atom = (Atom) clientMsg->data.l[0];
1601
1602 if (atom == Atoms::ProtocolList [Atoms::PING])
1603 {
1604 Window root = RootWindow (display, DefaultScreen (display));
1605
1606 clientMsg->window = root;
1607
1608 XSendEvent (display, root, False, NoEventMask, event);
1609 XFlush (display);
1610 }
1611 else if (atom == Atoms::ProtocolList [Atoms::TAKE_FOCUS])
1612 {
1613 XWindowAttributes atts;
1614
1615 ScopedXLock xlock;
1616 if (clientMsg->window != 0
1617 && XGetWindowAttributes (display, clientMsg->window, &atts))
1618 {
1619 if (atts.map_state == IsViewable)
1620 XSetInputFocus (display, clientMsg->window, RevertToParent, clientMsg->data.l[1]);
1621 }
1622 }
1623 else if (atom == Atoms::ProtocolList [Atoms::DELETE_WINDOW])
1624 {
1625 handleUserClosingWindow();
1626 }
1627 }
1628 else if (clientMsg->message_type == Atoms::XdndEnter)
1629 {
1630 handleDragAndDropEnter (clientMsg);
1631 }
1632 else if (clientMsg->message_type == Atoms::XdndLeave)
1633 {
1634 resetDragAndDrop();
1635 }
1636 else if (clientMsg->message_type == Atoms::XdndPosition)
1637 {
1638 handleDragAndDropPosition (clientMsg);
1639 }
1640 else if (clientMsg->message_type == Atoms::XdndDrop)
1641 {
1642 handleDragAndDropDrop (clientMsg);
1643 }
1644 else if (clientMsg->message_type == Atoms::XdndStatus)
1645 {
1646 handleDragAndDropStatus (clientMsg);
1647 }
1648 else if (clientMsg->message_type == Atoms::XdndFinished)
1649 {
1650 resetDragAndDrop();
1651 }
1652 }
1653
1654 //==============================================================================
1655 void showMouseCursor (Cursor cursor) noexcept
1656 {
1657 ScopedXLock xlock;
1658 XDefineCursor (display, windowH, cursor);
1659 }
1660
1661 //==============================================================================
1662 void setTaskBarIcon (const Image& image)
1663 {
1664 ScopedXLock xlock;
1665 taskbarImage = image;
1666
1667 Screen* const screen = XDefaultScreenOfDisplay (display);
1668 const int screenNumber = XScreenNumberOfScreen (screen);
1669
1670 String screenAtom ("_NET_SYSTEM_TRAY_S");
1671 screenAtom << screenNumber;
1672 Atom selectionAtom = XInternAtom (display, screenAtom.toUTF8(), false);
1673
1674 XGrabServer (display);
1675 Window managerWin = XGetSelectionOwner (display, selectionAtom);
1676
1677 if (managerWin != None)
1678 XSelectInput (display, managerWin, StructureNotifyMask);
1679
1680 XUngrabServer (display);
1681 XFlush (display);
1682
1683 if (managerWin != None)
1684 {
1685 XEvent ev = { 0 };
1686 ev.xclient.type = ClientMessage;
1687 ev.xclient.window = managerWin;
1688 ev.xclient.message_type = XInternAtom (display, "_NET_SYSTEM_TRAY_OPCODE", False);
1689 ev.xclient.format = 32;
1690 ev.xclient.data.l[0] = CurrentTime;
1691 ev.xclient.data.l[1] = 0 /*SYSTEM_TRAY_REQUEST_DOCK*/;
1692 ev.xclient.data.l[2] = windowH;
1693 ev.xclient.data.l[3] = 0;
1694 ev.xclient.data.l[4] = 0;
1695
1696 XSendEvent (display, managerWin, False, NoEventMask, &ev);
1697 XSync (display, False);
1698 }
1699
1700 // For older KDE's ...
1701 long atomData = 1;
1702 Atom trayAtom = XInternAtom (display, "KWM_DOCKWINDOW", false);
1703 XChangeProperty (display, windowH, trayAtom, trayAtom, 32, PropModeReplace, (unsigned char*) &atomData, 1);
1704
1705 // For more recent KDE's...
1706 trayAtom = XInternAtom (display, "_KDE_NET_WM_SYSTEM_TRAY_WINDOW_FOR", false);
1707 XChangeProperty (display, windowH, trayAtom, XA_WINDOW, 32, PropModeReplace, (unsigned char*) &windowH, 1);
1708
1709 // a minimum size must be specified for GNOME and Xfce, otherwise the icon is displayed with a width of 1
1710 XSizeHints* hints = XAllocSizeHints();
1711 hints->flags = PMinSize;
1712 hints->min_width = 22;
1713 hints->min_height = 22;
1714 XSetWMNormalHints (display, windowH, hints);
1715 XFree (hints);
1716 }
1717
1718 const Image& getTaskbarIcon() const noexcept { return taskbarImage; }
1719
1720 //==============================================================================
1721 bool dontRepaint;
1722
1723 static ModifierKeys currentModifiers;
1724 static bool isActiveApplication;
1725
1726 private:
1727 //==============================================================================
1728 class LinuxRepaintManager : public Timer
1729 {
1730 public:
1731 LinuxRepaintManager (LinuxComponentPeer* const peer_)
1732 : peer (peer_),
1733 lastTimeImageUsed (0)
1734 {
1735 #if JUCE_USE_XSHM
1736 shmCompletedDrawing = true;
1737
1738 useARGBImagesForRendering = XSHMHelpers::isShmAvailable();
1739
1740 if (useARGBImagesForRendering)
1741 {
1742 ScopedXLock xlock;
1743 XShmSegmentInfo segmentinfo;
1744
1745 XImage* const testImage
1746 = XShmCreateImage (display, DefaultVisual (display, DefaultScreen (display)),
1747 24, ZPixmap, 0, &segmentinfo, 64, 64);
1748
1749 useARGBImagesForRendering = (testImage->bits_per_pixel == 32);
1750 XDestroyImage (testImage);
1751 }
1752 #endif
1753 }
1754
1755 void timerCallback()
1756 {
1757 #if JUCE_USE_XSHM
1758 if (! shmCompletedDrawing)
1759 return;
1760 #endif
1761 if (! regionsNeedingRepaint.isEmpty())
1762 {
1763 stopTimer();
1764 performAnyPendingRepaintsNow();
1765 }
1766 else if (Time::getApproximateMillisecondCounter() > lastTimeImageUsed + 3000)
1767 {
1768 stopTimer();
1769 image = Image::null;
1770 }
1771 }
1772
1773 void repaint (const Rectangle<int>& area)
1774 {
1775 if (! isTimerRunning())
1776 startTimer (repaintTimerPeriod);
1777
1778 regionsNeedingRepaint.add (area);
1779 }
1780
1781 void performAnyPendingRepaintsNow()
1782 {
1783 #if JUCE_USE_XSHM
1784 if (! shmCompletedDrawing)
1785 {
1786 startTimer (repaintTimerPeriod);
1787 return;
1788 }
1789 #endif
1790
1791 peer->clearMaskedRegion();
1792
1793 RectangleList originalRepaintRegion (regionsNeedingRepaint);
1794 regionsNeedingRepaint.clear();
1795 const Rectangle<int> totalArea (originalRepaintRegion.getBounds());
1796
1797 if (! totalArea.isEmpty())
1798 {
1799 if (image.isNull() || image.getWidth() < totalArea.getWidth()
1800 || image.getHeight() < totalArea.getHeight())
1801 {
1802 #if JUCE_USE_XSHM
1803 image = Image (new XBitmapImage (useARGBImagesForRendering ? Image::ARGB
1804 : Image::RGB,
1805 #else
1806 image = Image (new XBitmapImage (Image::RGB,
1807 #endif
1808 (totalArea.getWidth() + 31) & ~31,
1809 (totalArea.getHeight() + 31) & ~31,
1810 false, peer->depth, peer->visual));
1811 }
1812
1813 startTimer (repaintTimerPeriod);
1814
1815 RectangleList adjustedList (originalRepaintRegion);
1816 adjustedList.offsetAll (-totalArea.getX(), -totalArea.getY());
1817 LowLevelGraphicsSoftwareRenderer context (image, -totalArea.getX(), -totalArea.getY(), adjustedList);
1818
1819 if (peer->depth == 32)
1820 {
1821 RectangleList::Iterator i (originalRepaintRegion);
1822
1823 while (i.next())
1824 image.clear (*i.getRectangle() - totalArea.getPosition());
1825 }
1826
1827 peer->handlePaint (context);
1828
1829 if (! peer->maskedRegion.isEmpty())
1830 originalRepaintRegion.subtract (peer->maskedRegion);
1831
1832 for (RectangleList::Iterator i (originalRepaintRegion); i.next();)
1833 {
1834 #if JUCE_USE_XSHM
1835 shmCompletedDrawing = false;
1836 #endif
1837 const Rectangle<int>& r = *i.getRectangle();
1838
1839 static_cast<XBitmapImage*> (image.getSharedImage())
1840 ->blitToWindow (peer->windowH,
1841 r.getX(), r.getY(), r.getWidth(), r.getHeight(),
1842 r.getX() - totalArea.getX(), r.getY() - totalArea.getY());
1843 }
1844 }
1845
1846 lastTimeImageUsed = Time::getApproximateMillisecondCounter();
1847 startTimer (repaintTimerPeriod);
1848 }
1849
1850 #if JUCE_USE_XSHM
1851 void notifyPaintCompleted() { shmCompletedDrawing = true; }
1852 #endif
1853
1854 private:
1855 enum { repaintTimerPeriod = 1000 / 100 };
1856
1857 LinuxComponentPeer* const peer;
1858 Image image;
1859 uint32 lastTimeImageUsed;
1860 RectangleList regionsNeedingRepaint;
1861
1862 #if JUCE_USE_XSHM
1863 bool useARGBImagesForRendering, shmCompletedDrawing;
1864 #endif
1865 JUCE_DECLARE_NON_COPYABLE (LinuxRepaintManager);
1866 };
1867
1868 ScopedPointer <LinuxRepaintManager> repainter;
1869
1870 friend class LinuxRepaintManager;
1871 Window windowH, parentWindow;
1872 int wx, wy, ww, wh;
1873 Image taskbarImage;
1874 bool fullScreen, mapped;
1875 Visual* visual;
1876 int depth;
1877 BorderSize<int> windowBorder;
1878
1879 struct MotifWmHints
1880 {
1881 unsigned long flags;
1882 unsigned long functions;
1883 unsigned long decorations;
1884 long input_mode;
1885 unsigned long status;
1886 };
1887
1888 static void updateKeyStates (const int keycode, const bool press) noexcept
1889 {
1890 const int keybyte = keycode >> 3;
1891 const int keybit = (1 << (keycode & 7));
1892
1893 if (press)
1894 Keys::keyStates [keybyte] |= keybit;
1895 else
1896 Keys::keyStates [keybyte] &= ~keybit;
1897 }
1898
1899 static void updateKeyModifiers (const int status) noexcept
1900 {
1901 int keyMods = 0;
1902
1903 if ((status & ShiftMask) != 0) keyMods |= ModifierKeys::shiftModifier;
1904 if ((status & ControlMask) != 0) keyMods |= ModifierKeys::ctrlModifier;
1905 if ((status & Keys::AltMask) != 0) keyMods |= ModifierKeys::altModifier;
1906
1907 currentModifiers = currentModifiers.withOnlyMouseButtons().withFlags (keyMods);
1908
1909 Keys::numLock = ((status & Keys::NumLockMask) != 0);
1910 Keys::capsLock = ((status & LockMask) != 0);
1911 }
1912
1913 static bool updateKeyModifiersFromSym (KeySym sym, const bool press) noexcept
1914 {
1915 int modifier = 0;
1916 bool isModifier = true;
1917
1918 switch (sym)
1919 {
1920 case XK_Shift_L:
1921 case XK_Shift_R:
1922 modifier = ModifierKeys::shiftModifier;
1923 break;
1924
1925 case XK_Control_L:
1926 case XK_Control_R:
1927 modifier = ModifierKeys::ctrlModifier;
1928 break;
1929
1930 case XK_Alt_L:
1931 case XK_Alt_R:
1932 modifier = ModifierKeys::altModifier;
1933 break;
1934
1935 case XK_Num_Lock:
1936 if (press)
1937 Keys::numLock = ! Keys::numLock;
1938
1939 break;
1940
1941 case XK_Caps_Lock:
1942 if (press)
1943 Keys::capsLock = ! Keys::capsLock;
1944
1945 break;
1946
1947 case XK_Scroll_Lock:
1948 break;
1949
1950 default:
1951 isModifier = false;
1952 break;
1953 }
1954
1955 if (modifier != 0)
1956 {
1957 if (press)
1958 currentModifiers = currentModifiers.withFlags (modifier);
1959 else
1960 currentModifiers = currentModifiers.withoutFlags (modifier);
1961 }
1962
1963 return isModifier;
1964 }
1965
1966 // Alt and Num lock are not defined by standard X
1967 // modifier constants: check what they're mapped to
1968 static void updateModifierMappings() noexcept
1969 {
1970 ScopedXLock xlock;
1971 const int altLeftCode = XKeysymToKeycode (display, XK_Alt_L);
1972 const int numLockCode = XKeysymToKeycode (display, XK_Num_Lock);
1973
1974 Keys::AltMask = 0;
1975 Keys::NumLockMask = 0;
1976
1977 XModifierKeymap* mapping = XGetModifierMapping (display);
1978
1979 if (mapping)
1980 {
1981 for (int i = 0; i < 8; i++)
1982 {
1983 if (mapping->modifiermap [i << 1] == altLeftCode)
1984 Keys::AltMask = 1 << i;
1985 else if (mapping->modifiermap [i << 1] == numLockCode)
1986 Keys::NumLockMask = 1 << i;
1987 }
1988
1989 XFreeModifiermap (mapping);
1990 }
1991 }
1992
1993 //==============================================================================
1994 void removeWindowDecorations (Window wndH)
1995 {
1996 Atom hints = XInternAtom (display, "_MOTIF_WM_HINTS", True);
1997
1998 if (hints != None)
1999 {
2000 MotifWmHints motifHints = { 0 };
2001 motifHints.flags = 2; /* MWM_HINTS_DECORATIONS */
2002 motifHints.decorations = 0;
2003
2004 ScopedXLock xlock;
2005 XChangeProperty (display, wndH, hints, hints, 32, PropModeReplace,
2006 (unsigned char*) &motifHints, 4);
2007 }
2008
2009 hints = XInternAtom (display, "_WIN_HINTS", True);
2010
2011 if (hints != None)
2012 {
2013 long gnomeHints = 0;
2014
2015 ScopedXLock xlock;
2016 XChangeProperty (display, wndH, hints, hints, 32, PropModeReplace,
2017 (unsigned char*) &gnomeHints, 1);
2018 }
2019
2020 hints = XInternAtom (display, "KWM_WIN_DECORATION", True);
2021
2022 if (hints != None)
2023 {
2024 long kwmHints = 2; /*KDE_tinyDecoration*/
2025
2026 ScopedXLock xlock;
2027 XChangeProperty (display, wndH, hints, hints, 32, PropModeReplace,
2028 (unsigned char*) &kwmHints, 1);
2029 }
2030 }
2031
2032 void addWindowButtons (Window wndH)
2033 {
2034 ScopedXLock xlock;
2035 Atom hints = XInternAtom (display, "_MOTIF_WM_HINTS", True);
2036
2037 if (hints != None)
2038 {
2039 MotifWmHints motifHints = { 0 };
2040 motifHints.flags = 1 | 2; /* MWM_HINTS_FUNCTIONS | MWM_HINTS_DECORATIONS */
2041 motifHints.decorations = 2 /* MWM_DECOR_BORDER */ | 8 /* MWM_DECOR_TITLE */ | 16; /* MWM_DECOR_MENU */
2042
2043 motifHints.functions = 4 /* MWM_FUNC_MOVE */;
2044
2045 if ((styleFlags & windowHasCloseButton) != 0)
2046 motifHints.functions |= 32; /* MWM_FUNC_CLOSE */
2047
2048 if ((styleFlags & windowHasMinimiseButton) != 0)
2049 {
2050 motifHints.functions |= 8; /* MWM_FUNC_MINIMIZE */
2051 motifHints.decorations |= 0x20; /* MWM_DECOR_MINIMIZE */
2052 }
2053
2054 if ((styleFlags & windowHasMaximiseButton) != 0)
2055 {
2056 motifHints.functions |= 0x10; /* MWM_FUNC_MAXIMIZE */
2057 motifHints.decorations |= 0x40; /* MWM_DECOR_MAXIMIZE */
2058 }
2059
2060 if ((styleFlags & windowIsResizable) != 0)
2061 {
2062 motifHints.functions |= 2; /* MWM_FUNC_RESIZE */
2063 motifHints.decorations |= 0x4; /* MWM_DECOR_RESIZEH */
2064 }
2065
2066 XChangeProperty (display, wndH, hints, hints, 32, 0, (unsigned char*) &motifHints, 5);
2067 }
2068
2069 hints = XInternAtom (display, "_NET_WM_ALLOWED_ACTIONS", True);
2070
2071 if (hints != None)
2072 {
2073 int netHints [6];
2074 int num = 0;
2075
2076 if ((styleFlags & windowIsResizable) != 0)
2077 netHints [num++] = XInternAtom (display, "_NET_WM_ACTION_RESIZE", True);
2078
2079 if ((styleFlags & windowHasMaximiseButton) != 0)
2080 netHints [num++] = XInternAtom (display, "_NET_WM_ACTION_FULLSCREEN", True);
2081
2082 if ((styleFlags & windowHasMinimiseButton) != 0)
2083 netHints [num++] = XInternAtom (display, "_NET_WM_ACTION_MINIMIZE", True);
2084
2085 if ((styleFlags & windowHasCloseButton) != 0)
2086 netHints [num++] = XInternAtom (display, "_NET_WM_ACTION_CLOSE", True);
2087
2088 XChangeProperty (display, wndH, hints, XA_ATOM, 32, PropModeReplace, (unsigned char*) &netHints, num);
2089 }
2090 }
2091
2092 void setWindowType()
2093 {
2094 int netHints [2];
2095 int numHints = 0;
2096
2097 if ((styleFlags & windowIsTemporary) != 0
2098 || ((styleFlags & windowHasDropShadow) == 0 && Desktop::canUseSemiTransparentWindows()))
2099 netHints [numHints++] = XInternAtom (display, "_NET_WM_WINDOW_TYPE_COMBO", True);
2100 else
2101 netHints [numHints++] = XInternAtom (display, "_NET_WM_WINDOW_TYPE_NORMAL", True);
2102
2103 netHints[numHints++] = XInternAtom (display, "_KDE_NET_WM_WINDOW_TYPE_OVERRIDE", True);
2104
2105 XChangeProperty (display, windowH, Atoms::WindowType, XA_ATOM, 32, PropModeReplace,
2106 (unsigned char*) &netHints, numHints);
2107
2108 numHints = 0;
2109
2110 if ((styleFlags & windowAppearsOnTaskbar) == 0)
2111 netHints [numHints++] = XInternAtom (display, "_NET_WM_STATE_SKIP_TASKBAR", True);
2112
2113 if (component->isAlwaysOnTop())
2114 netHints [numHints++] = XInternAtom (display, "_NET_WM_STATE_ABOVE", True);
2115
2116 if (numHints > 0)
2117 XChangeProperty (display, windowH, Atoms::WindowState, XA_ATOM, 32, PropModeReplace,
2118 (unsigned char*) &netHints, numHints);
2119 }
2120
2121 void createWindow (Window parentToAddTo)
2122 {
2123 ScopedXLock xlock;
2124 Atoms::initialiseAtoms();
2125 resetDragAndDrop();
2126
2127 // Get defaults for various properties
2128 const int screen = DefaultScreen (display);
2129 Window root = RootWindow (display, screen);
2130
2131 // Try to obtain a 32-bit visual or fallback to 24 or 16
2132 visual = Visuals::findVisualFormat ((styleFlags & windowIsSemiTransparent) ? 32 : 24, depth);
2133
2134 if (visual == 0)
2135 {
2136 Logger::outputDebugString ("ERROR: System doesn't support 32, 24 or 16 bit RGB display.\n");
2137 Process::terminate();
2138 }
2139
2140 // Create and install a colormap suitable fr our visual
2141 Colormap colormap = XCreateColormap (display, root, visual, AllocNone);
2142 XInstallColormap (display, colormap);
2143
2144 // Set up the window attributes
2145 XSetWindowAttributes swa;
2146 swa.border_pixel = 0;
2147 swa.background_pixmap = None;
2148 swa.colormap = colormap;
2149 swa.event_mask = getAllEventsMask();
2150
2151 windowH = XCreateWindow (display, parentToAddTo != 0 ? parentToAddTo : root,
2152 0, 0, 1, 1,
2153 0, depth, InputOutput, visual,
2154 CWBorderPixel | CWColormap | CWBackPixmap | CWEventMask,
2155 &swa);
2156
2157 XGrabButton (display, AnyButton, AnyModifier, windowH, False,
2158 ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask,
2159 GrabModeAsync, GrabModeAsync, None, None);
2160
2161 // Set the window context to identify the window handle object
2162 if (XSaveContext (display, (XID) windowH, windowHandleXContext, (XPointer) this))
2163 {
2164 // Failed
2165 jassertfalse;
2166 Logger::outputDebugString ("Failed to create context information for window.\n");
2167 XDestroyWindow (display, windowH);
2168 windowH = 0;
2169 return;
2170 }
2171
2172 // Set window manager hints
2173 XWMHints* wmHints = XAllocWMHints();
2174 wmHints->flags = InputHint | StateHint;
2175 wmHints->input = True; // Locally active input model
2176 wmHints->initial_state = NormalState;
2177 XSetWMHints (display, windowH, wmHints);
2178 XFree (wmHints);
2179
2180 // Set the window type
2181 setWindowType();
2182
2183 // Define decoration
2184 if ((styleFlags & windowHasTitleBar) == 0)
2185 removeWindowDecorations (windowH);
2186 else
2187 addWindowButtons (windowH);
2188
2189 setTitle (getComponent()->getName());
2190
2191 // Associate the PID, allowing to be shut down when something goes wrong
2192 unsigned long pid = getpid();
2193 XChangeProperty (display, windowH, Atoms::Pid, XA_CARDINAL, 32, PropModeReplace,
2194 (unsigned char*) &pid, 1);
2195
2196 // Set window manager protocols
2197 XChangeProperty (display, windowH, Atoms::Protocols, XA_ATOM, 32, PropModeReplace,
2198 (unsigned char*) Atoms::ProtocolList, 2);
2199
2200 // Set drag and drop flags
2201 XChangeProperty (display, windowH, Atoms::XdndTypeList, XA_ATOM, 32, PropModeReplace,
2202 (const unsigned char*) Atoms::allowedMimeTypes, numElementsInArray (Atoms::allowedMimeTypes));
2203
2204 XChangeProperty (display, windowH, Atoms::XdndActionList, XA_ATOM, 32, PropModeReplace,
2205 (const unsigned char*) Atoms::allowedActions, numElementsInArray (Atoms::allowedActions));
2206
2207 XChangeProperty (display, windowH, Atoms::XdndActionDescription, XA_STRING, 8, PropModeReplace,
2208 (const unsigned char*) "", 0);
2209
2210 unsigned long dndVersion = Atoms::DndVersion;
2211 XChangeProperty (display, windowH, Atoms::XdndAware, XA_ATOM, 32, PropModeReplace,
2212 (const unsigned char*) &dndVersion, 1);
2213
2214 // Initialise the pointer and keyboard mapping
2215 // This is not the same as the logical pointer mapping the X server uses:
2216 // we don't mess with this.
2217 static bool mappingInitialised = false;
2218
2219 if (! mappingInitialised)
2220 {
2221 mappingInitialised = true;
2222
2223 const int numButtons = XGetPointerMapping (display, 0, 0);
2224
2225 if (numButtons == 2)
2226 {
2227 pointerMap[0] = Keys::LeftButton;
2228 pointerMap[1] = Keys::RightButton;
2229 pointerMap[2] = pointerMap[3] = pointerMap[4] = Keys::NoButton;
2230 }
2231 else if (numButtons >= 3)
2232 {
2233 pointerMap[0] = Keys::LeftButton;
2234 pointerMap[1] = Keys::MiddleButton;
2235 pointerMap[2] = Keys::RightButton;
2236
2237 if (numButtons >= 5)
2238 {
2239 pointerMap[3] = Keys::WheelUp;
2240 pointerMap[4] = Keys::WheelDown;
2241 }
2242 }
2243
2244 updateModifierMappings();
2245 }
2246 }
2247
2248 void destroyWindow()
2249 {
2250 ScopedXLock xlock;
2251
2252 XPointer handlePointer;
2253 if (! XFindContext (display, (XID) windowH, windowHandleXContext, &handlePointer))
2254 XDeleteContext (display, (XID) windowH, windowHandleXContext);
2255
2256 XDestroyWindow (display, windowH);
2257
2258 // Wait for it to complete and then remove any events for this
2259 // window from the event queue.
2260 XSync (display, false);
2261
2262 XEvent event;
2263 while (XCheckWindowEvent (display, windowH, getAllEventsMask(), &event) == True)
2264 {}
2265 }
2266
2267 static int getAllEventsMask() noexcept
2268 {
2269 return NoEventMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask
2270 | EnterWindowMask | LeaveWindowMask | PointerMotionMask | KeymapStateMask
2271 | ExposureMask | StructureNotifyMask | FocusChangeMask;
2272 }
2273
2274 static int64 getEventTime (::Time t)
2275 {
2276 static int64 eventTimeOffset = 0x12345678;
2277 const int64 thisMessageTime = t;
2278
2279 if (eventTimeOffset == 0x12345678)
2280 eventTimeOffset = Time::currentTimeMillis() - thisMessageTime;
2281
2282 return eventTimeOffset + thisMessageTime;
2283 }
2284
2285 void updateBorderSize()
2286 {
2287 if ((styleFlags & windowHasTitleBar) == 0)
2288 {
2289 windowBorder = BorderSize<int> (0);
2290 }
2291 else if (windowBorder.getTopAndBottom() == 0 && windowBorder.getLeftAndRight() == 0)
2292 {
2293 ScopedXLock xlock;
2294 Atom hints = XInternAtom (display, "_NET_FRAME_EXTENTS", True);
2295
2296 if (hints != None)
2297 {
2298 unsigned char* data = nullptr;
2299 unsigned long nitems, bytesLeft;
2300 Atom actualType;
2301 int actualFormat;
2302
2303 if (XGetWindowProperty (display, windowH, hints, 0, 4, False,
2304 XA_CARDINAL, &actualType, &actualFormat, &nitems, &bytesLeft,
2305 &data) == Success)
2306 {
2307 const unsigned long* const sizes = (const unsigned long*) data;
2308
2309 if (actualFormat == 32)
2310 windowBorder = BorderSize<int> ((int) sizes[2], (int) sizes[0],
2311 (int) sizes[3], (int) sizes[1]);
2312
2313 XFree (data);
2314 }
2315 }
2316 }
2317 }
2318
2319 void updateBounds()
2320 {
2321 jassert (windowH != 0);
2322 if (windowH != 0)
2323 {
2324 Window root, child;
2325 unsigned int bw, depth;
2326 ScopedXLock xlock;
2327
2328 if (! XGetGeometry (display, (::Drawable) windowH, &root,
2329 &wx, &wy, (unsigned int*) &ww, (unsigned int*) &wh,
2330 &bw, &depth))
2331 {
2332 wx = wy = ww = wh = 0;
2333 }
2334 else if (! XTranslateCoordinates (display, windowH, root, 0, 0, &wx, &wy, &child))
2335 {
2336 wx = wy = 0;
2337 }
2338 }
2339 }
2340
2341 //==============================================================================
2342 void resetDragAndDrop()
2343 {
2344 dragAndDropFiles.clear();
2345 lastDropPos = Point<int> (-1, -1);
2346 dragAndDropCurrentMimeType = 0;
2347 dragAndDropSourceWindow = 0;
2348 srcMimeTypeAtomList.clear();
2349 }
2350
2351 void sendDragAndDropMessage (XClientMessageEvent& msg)
2352 {
2353 msg.type = ClientMessage;
2354 msg.display = display;
2355 msg.window = dragAndDropSourceWindow;
2356 msg.format = 32;
2357 msg.data.l[0] = windowH;
2358
2359 ScopedXLock xlock;
2360 XSendEvent (display, dragAndDropSourceWindow, False, 0, (XEvent*) &msg);
2361 }
2362
2363 void sendDragAndDropStatus (const bool acceptDrop, Atom dropAction)
2364 {
2365 XClientMessageEvent msg = { 0 };
2366 msg.message_type = Atoms::XdndStatus;
2367 msg.data.l[1] = (acceptDrop ? 1 : 0) | 2; // 2 indicates that we want to receive position messages
2368 msg.data.l[4] = dropAction;
2369
2370 sendDragAndDropMessage (msg);
2371 }
2372
2373 void sendDragAndDropLeave()
2374 {
2375 XClientMessageEvent msg = { 0 };
2376 msg.message_type = Atoms::XdndLeave;
2377 sendDragAndDropMessage (msg);
2378 }
2379
2380 void sendDragAndDropFinish()
2381 {
2382 XClientMessageEvent msg = { 0 };
2383 msg.message_type = Atoms::XdndFinished;
2384 sendDragAndDropMessage (msg);
2385 }
2386
2387 void handleDragAndDropStatus (const XClientMessageEvent* const clientMsg)
2388 {
2389 if ((clientMsg->data.l[1] & 1) == 0)
2390 {
2391 sendDragAndDropLeave();
2392
2393 if (dragAndDropFiles.size() > 0)
2394 handleFileDragExit (dragAndDropFiles);
2395
2396 dragAndDropFiles.clear();
2397 }
2398 }
2399
2400 void handleDragAndDropPosition (const XClientMessageEvent* const clientMsg)
2401 {
2402 if (dragAndDropSourceWindow == 0)
2403 return;
2404
2405 dragAndDropSourceWindow = clientMsg->data.l[0];
2406
2407 Point<int> dropPos ((int) clientMsg->data.l[2] >> 16,
2408 (int) clientMsg->data.l[2] & 0xffff);
2409 dropPos -= getScreenPosition();
2410
2411 if (lastDropPos != dropPos)
2412 {
2413 lastDropPos = dropPos;
2414 dragAndDropTimestamp = clientMsg->data.l[3];
2415
2416 Atom targetAction = Atoms::XdndActionCopy;
2417
2418 for (int i = numElementsInArray (Atoms::allowedActions); --i >= 0;)
2419 {
2420 if ((Atom) clientMsg->data.l[4] == Atoms::allowedActions[i])
2421 {
2422 targetAction = Atoms::allowedActions[i];
2423 break;
2424 }
2425 }
2426
2427 sendDragAndDropStatus (true, targetAction);
2428
2429 if (dragAndDropFiles.size() == 0)
2430 updateDraggedFileList (clientMsg);
2431
2432 if (dragAndDropFiles.size() > 0)
2433 handleFileDragMove (dragAndDropFiles, dropPos);
2434 }
2435 }
2436
2437 void handleDragAndDropDrop (const XClientMessageEvent* const clientMsg)
2438 {
2439 if (dragAndDropFiles.size() == 0)
2440 updateDraggedFileList (clientMsg);
2441
2442 const StringArray files (dragAndDropFiles);
2443 const Point<int> lastPos (lastDropPos);
2444
2445 sendDragAndDropFinish();
2446 resetDragAndDrop();
2447
2448 if (files.size() > 0)
2449 handleFileDragDrop (files, lastPos);
2450 }
2451
2452 void handleDragAndDropEnter (const XClientMessageEvent* const clientMsg)
2453 {
2454 dragAndDropFiles.clear();
2455 srcMimeTypeAtomList.clear();
2456
2457 dragAndDropCurrentMimeType = 0;
2458 const unsigned long dndCurrentVersion = static_cast <unsigned long> (clientMsg->data.l[1] & 0xff000000) >> 24;
2459
2460 if (dndCurrentVersion < 3 || dndCurrentVersion > Atoms::DndVersion)
2461 {
2462 dragAndDropSourceWindow = 0;
2463 return;
2464 }
2465
2466 dragAndDropSourceWindow = clientMsg->data.l[0];
2467
2468 if ((clientMsg->data.l[1] & 1) != 0)
2469 {
2470 Atom actual;
2471 int format;
2472 unsigned long count = 0, remaining = 0;
2473 unsigned char* data = 0;
2474
2475 ScopedXLock xlock;
2476 XGetWindowProperty (display, dragAndDropSourceWindow, Atoms::XdndTypeList,
2477 0, 0x8000000L, False, XA_ATOM, &actual, &format,
2478 &count, &remaining, &data);
2479
2480 if (data != 0)
2481 {
2482 if (actual == XA_ATOM && format == 32 && count != 0)
2483 {
2484 const unsigned long* const types = (const unsigned long*) data;
2485
2486 for (unsigned int i = 0; i < count; ++i)
2487 if (types[i] != None)
2488 srcMimeTypeAtomList.add (types[i]);
2489 }
2490
2491 XFree (data);
2492 }
2493 }
2494
2495 if (srcMimeTypeAtomList.size() == 0)
2496 {
2497 for (int i = 2; i < 5; ++i)
2498 if (clientMsg->data.l[i] != None)
2499 srcMimeTypeAtomList.add (clientMsg->data.l[i]);
2500
2501 if (srcMimeTypeAtomList.size() == 0)
2502 {
2503 dragAndDropSourceWindow = 0;
2504 return;
2505 }
2506 }
2507
2508 for (int i = 0; i < srcMimeTypeAtomList.size() && dragAndDropCurrentMimeType == 0; ++i)
2509 for (int j = 0; j < numElementsInArray (Atoms::allowedMimeTypes); ++j)
2510 if (srcMimeTypeAtomList[i] == Atoms::allowedMimeTypes[j])
2511 dragAndDropCurrentMimeType = Atoms::allowedMimeTypes[j];
2512
2513 handleDragAndDropPosition (clientMsg);
2514 }
2515
2516 void handleDragAndDropSelection (const XEvent* const evt)
2517 {
2518 dragAndDropFiles.clear();
2519
2520 if (evt->xselection.property != 0)
2521 {
2522 StringArray lines;
2523
2524 {
2525 MemoryBlock dropData;
2526
2527 for (;;)
2528 {
2529 Atom actual;
2530 uint8* data = 0;
2531 unsigned long count = 0, remaining = 0;
2532 int format = 0;
2533 ScopedXLock xlock;
2534
2535 if (XGetWindowProperty (display, evt->xany.window, evt->xselection.property,
2536 dropData.getSize() / 4, 65536, 1, AnyPropertyType, &actual,
2537 &format, &count, &remaining, &data) == Success)
2538 {
2539 dropData.append (data, count * format / 8);
2540 XFree (data);
2541
2542 if (remaining == 0)
2543 break;
2544 }
2545 else
2546 {
2547 XFree (data);
2548 break;
2549 }
2550 }
2551
2552 lines.addLines (dropData.toString());
2553 }
2554
2555 for (int i = 0; i < lines.size(); ++i)
2556 dragAndDropFiles.add (URL::removeEscapeChars (lines[i].fromFirstOccurrenceOf ("file://", false, true)));
2557
2558 dragAndDropFiles.trim();
2559 dragAndDropFiles.removeEmptyStrings();
2560 }
2561 }
2562
2563 void updateDraggedFileList (const XClientMessageEvent* const clientMsg)
2564 {
2565 dragAndDropFiles.clear();
2566
2567 if (dragAndDropSourceWindow != None
2568 && dragAndDropCurrentMimeType != 0)
2569 {
2570 dragAndDropTimestamp = clientMsg->data.l[2];
2571
2572 ScopedXLock xlock;
2573 XConvertSelection (display,
2574 Atoms::XdndSelection,
2575 dragAndDropCurrentMimeType,
2576 XInternAtom (display, "JXSelectionWindowProperty", 0),
2577 windowH,
2578 dragAndDropTimestamp);
2579 }
2580 }
2581
2582 StringArray dragAndDropFiles;
2583 int dragAndDropTimestamp;
2584 Point<int> lastDropPos;
2585
2586 Atom dragAndDropCurrentMimeType;
2587 Window dragAndDropSourceWindow;
2588
2589 Array <Atom> srcMimeTypeAtomList;
2590
2591 static int pointerMap[5];
2592 static Point<int> lastMousePos;
2593
2594 static void clearLastMousePos() noexcept
2595 {
2596 lastMousePos = Point<int> (0x100000, 0x100000);
2597 }
2598
2599 JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (LinuxComponentPeer);
2600 };
2601
2602 ModifierKeys LinuxComponentPeer::currentModifiers;
2603 bool LinuxComponentPeer::isActiveApplication = false;
2604 int LinuxComponentPeer::pointerMap[5];
2605 Point<int> LinuxComponentPeer::lastMousePos;
2606
2607 //==============================================================================
2608 bool Process::isForegroundProcess()
2609 {
2610 return LinuxComponentPeer::isActiveApplication;
2611 }
2612
2613 //==============================================================================
2614 void ModifierKeys::updateCurrentModifiers() noexcept
2615 {
2616 currentModifiers = LinuxComponentPeer::currentModifiers;
2617 }
2618
2619 const ModifierKeys ModifierKeys::getCurrentModifiersRealtime() noexcept
2620 {
2621 Window root, child;
2622 int x, y, winx, winy;
2623 unsigned int mask;
2624 int mouseMods = 0;
2625
2626 ScopedXLock xlock;
2627
2628 if (XQueryPointer (display, RootWindow (display, DefaultScreen (display)),
2629 &root, &child, &x, &y, &winx, &winy, &mask) != False)
2630 {
2631 if ((mask & Button1Mask) != 0) mouseMods |= ModifierKeys::leftButtonModifier;
2632 if ((mask & Button2Mask) != 0) mouseMods |= ModifierKeys::middleButtonModifier;
2633 if ((mask & Button3Mask) != 0) mouseMods |= ModifierKeys::rightButtonModifier;
2634 }
2635
2636 LinuxComponentPeer::currentModifiers = LinuxComponentPeer::currentModifiers.withoutMouseButtons().withFlags (mouseMods);
2637 return LinuxComponentPeer::currentModifiers;
2638 }
2639
2640
2641 //==============================================================================
2642 void Desktop::setKioskComponent (Component* kioskModeComponent, bool enableOrDisable, bool allowMenusAndBars)
2643 {
2644 if (enableOrDisable)
2645 kioskModeComponent->setBounds (Desktop::getInstance().getMainMonitorArea (false));
2646 }
2647
2648 //==============================================================================
2649 ComponentPeer* Component::createNewPeer (int styleFlags, void* nativeWindowToAttachTo)
2650 {
2651 return new LinuxComponentPeer (this, styleFlags, (Window) nativeWindowToAttachTo);
2652 }
2653
2654
2655 //==============================================================================
2656 // (this callback is hooked up in the messaging code)
2657 void juce_windowMessageReceive (XEvent* event)
2658 {
2659 if (event->xany.window != None)
2660 {
2661 LinuxComponentPeer* const peer = LinuxComponentPeer::getPeerFor (event->xany.window);
2662
2663 if (ComponentPeer::isValidPeer (peer))
2664 peer->handleWindowMessage (event);
2665 }
2666 else
2667 {
2668 switch (event->xany.type)
2669 {
2670 case KeymapNotify:
2671 {
2672 const XKeymapEvent* const keymapEvent = (const XKeymapEvent*) &event->xkeymap;
2673 memcpy (Keys::keyStates, keymapEvent->key_vector, 32);
2674 break;
2675 }
2676
2677 default:
2678 break;
2679 }
2680 }
2681 }
2682
2683 //==============================================================================
2684 void Desktop::getCurrentMonitorPositions (Array <Rectangle<int> >& monitorCoords, const bool /*clipToWorkArea*/)
2685 {
2686 if (display == 0)
2687 return;
2688
2689 #if JUCE_USE_XINERAMA
2690 int major_opcode, first_event, first_error;
2691
2692 ScopedXLock xlock;
2693 if (XQueryExtension (display, "XINERAMA", &major_opcode, &first_event, &first_error))
2694 {
2695 typedef Bool (*tXineramaIsActive) (Display*);
2696 typedef XineramaScreenInfo* (*tXineramaQueryScreens) (Display*, int*);
2697
2698 static tXineramaIsActive xXineramaIsActive = 0;
2699 static tXineramaQueryScreens xXineramaQueryScreens = 0;
2700
2701 if (xXineramaIsActive == 0 || xXineramaQueryScreens == 0)
2702 {
2703 void* h = dlopen ("libXinerama.so", RTLD_GLOBAL | RTLD_NOW);
2704
2705 if (h == 0)
2706 h = dlopen ("libXinerama.so.1", RTLD_GLOBAL | RTLD_NOW);
2707
2708 if (h != 0)
2709 {
2710 xXineramaIsActive = (tXineramaIsActive) dlsym (h, "XineramaIsActive");
2711 xXineramaQueryScreens = (tXineramaQueryScreens) dlsym (h, "XineramaQueryScreens");
2712 }
2713 }
2714
2715 if (xXineramaIsActive != 0
2716 && xXineramaQueryScreens != 0
2717 && xXineramaIsActive (display))
2718 {
2719 int numMonitors = 0;
2720 XineramaScreenInfo* const screens = xXineramaQueryScreens (display, &numMonitors);
2721
2722 if (screens != 0)
2723 {
2724 for (int i = numMonitors; --i >= 0;)
2725 {
2726 int index = screens[i].screen_number;
2727
2728 if (index >= 0)
2729 {
2730 while (monitorCoords.size() < index)
2731 monitorCoords.add (Rectangle<int>());
2732
2733 monitorCoords.set (index, Rectangle<int> (screens[i].x_org,
2734 screens[i].y_org,
2735 screens[i].width,
2736 screens[i].height));
2737 }
2738 }
2739
2740 XFree (screens);
2741 }
2742 }
2743 }
2744
2745 if (monitorCoords.size() == 0)
2746 #endif
2747 {
2748 Atom hints = XInternAtom (display, "_NET_WORKAREA", True);
2749
2750 if (hints != None)
2751 {
2752 const int numMonitors = ScreenCount (display);
2753
2754 for (int i = 0; i < numMonitors; ++i)
2755 {
2756 Window root = RootWindow (display, i);
2757
2758 unsigned long nitems, bytesLeft;
2759 Atom actualType;
2760 int actualFormat;
2761 unsigned char* data = nullptr;
2762
2763 if (XGetWindowProperty (display, root, hints, 0, 4, False,
2764 XA_CARDINAL, &actualType, &actualFormat, &nitems, &bytesLeft,
2765 &data) == Success)
2766 {
2767 const long* const position = (const long*) data;
2768
2769 if (actualType == XA_CARDINAL && actualFormat == 32 && nitems == 4)
2770 monitorCoords.add (Rectangle<int> (position[0], position[1],
2771 position[2], position[3]));
2772
2773 XFree (data);
2774 }
2775 }
2776 }
2777
2778 if (monitorCoords.size() == 0)
2779 {
2780 monitorCoords.add (Rectangle<int> (DisplayWidth (display, DefaultScreen (display)),
2781 DisplayHeight (display, DefaultScreen (display))));
2782 }
2783 }
2784 }
2785
2786 //==============================================================================
2787 void Desktop::createMouseInputSources()
2788 {
2789 mouseSources.add (new MouseInputSource (0, true));
2790 }
2791
2792 bool Desktop::canUseSemiTransparentWindows() noexcept
2793 {
2794 int matchedDepth = 0;
2795 const int desiredDepth = 32;
2796
2797 return Visuals::findVisualFormat (desiredDepth, matchedDepth) != 0
2798 && (matchedDepth == desiredDepth);
2799 }
2800
2801 const Point<int> MouseInputSource::getCurrentMousePosition()
2802 {
2803 Window root, child;
2804 int x, y, winx, winy;
2805 unsigned int mask;
2806
2807 ScopedXLock xlock;
2808
2809 if (XQueryPointer (display,
2810 RootWindow (display, DefaultScreen (display)),
2811 &root, &child,
2812 &x, &y, &winx, &winy, &mask) == False)
2813 {
2814 // Pointer not on the default screen
2815 x = y = -1;
2816 }
2817
2818 return Point<int> (x, y);
2819 }
2820
2821 void Desktop::setMousePosition (const Point<int>& newPosition)
2822 {
2823 ScopedXLock xlock;
2824 Window root = RootWindow (display, DefaultScreen (display));
2825 XWarpPointer (display, None, root, 0, 0, 0, 0, newPosition.getX(), newPosition.getY());
2826 }
2827
2828 Desktop::DisplayOrientation Desktop::getCurrentOrientation() const
2829 {
2830 return upright;
2831 }
2832
2833 //==============================================================================
2834 static bool screenSaverAllowed = true;
2835
2836 void Desktop::setScreenSaverEnabled (const bool isEnabled)
2837 {
2838 if (screenSaverAllowed != isEnabled)
2839 {
2840 screenSaverAllowed = isEnabled;
2841
2842 typedef void (*tXScreenSaverSuspend) (Display*, Bool);
2843 static tXScreenSaverSuspend xScreenSaverSuspend = 0;
2844
2845 if (xScreenSaverSuspend == 0)
2846 {
2847 void* h = dlopen ("libXss.so", RTLD_GLOBAL | RTLD_NOW);
2848
2849 if (h != 0)
2850 xScreenSaverSuspend = (tXScreenSaverSuspend) dlsym (h, "XScreenSaverSuspend");
2851 }
2852
2853 ScopedXLock xlock;
2854 if (xScreenSaverSuspend != 0)
2855 xScreenSaverSuspend (display, ! isEnabled);
2856 }
2857 }
2858
2859 bool Desktop::isScreenSaverEnabled()
2860 {
2861 return screenSaverAllowed;
2862 }
2863
2864 //==============================================================================
2865 void* MouseCursor::createMouseCursorFromImage (const Image& image, int hotspotX, int hotspotY)
2866 {
2867 ScopedXLock xlock;
2868 const unsigned int imageW = image.getWidth();
2869 const unsigned int imageH = image.getHeight();
2870
2871 #if JUCE_USE_XCURSOR
2872 {
2873 typedef XcursorBool (*tXcursorSupportsARGB) (Display*);
2874 typedef XcursorImage* (*tXcursorImageCreate) (int, int);
2875 typedef void (*tXcursorImageDestroy) (XcursorImage*);
2876 typedef Cursor (*tXcursorImageLoadCursor) (Display*, const XcursorImage*);
2877
2878 static tXcursorSupportsARGB xXcursorSupportsARGB = 0;
2879 static tXcursorImageCreate xXcursorImageCreate = 0;
2880 static tXcursorImageDestroy xXcursorImageDestroy = 0;
2881 static tXcursorImageLoadCursor xXcursorImageLoadCursor = 0;
2882 static bool hasBeenLoaded = false;
2883
2884 if (! hasBeenLoaded)
2885 {
2886 hasBeenLoaded = true;
2887 void* h = dlopen ("libXcursor.so", RTLD_GLOBAL | RTLD_NOW);
2888
2889 if (h != 0)
2890 {
2891 xXcursorSupportsARGB = (tXcursorSupportsARGB) dlsym (h, "XcursorSupportsARGB");
2892 xXcursorImageCreate = (tXcursorImageCreate) dlsym (h, "XcursorImageCreate");
2893 xXcursorImageLoadCursor = (tXcursorImageLoadCursor) dlsym (h, "XcursorImageLoadCursor");
2894 xXcursorImageDestroy = (tXcursorImageDestroy) dlsym (h, "XcursorImageDestroy");
2895
2896 if (xXcursorSupportsARGB == 0 || xXcursorImageCreate == 0
2897 || xXcursorImageLoadCursor == 0 || xXcursorImageDestroy == 0
2898 || ! xXcursorSupportsARGB (display))
2899 xXcursorSupportsARGB = 0;
2900 }
2901 }
2902
2903 if (xXcursorSupportsARGB != 0)
2904 {
2905 XcursorImage* xcImage = xXcursorImageCreate (imageW, imageH);
2906
2907 if (xcImage != 0)
2908 {
2909 xcImage->xhot = hotspotX;
2910 xcImage->yhot = hotspotY;
2911 XcursorPixel* dest = xcImage->pixels;
2912
2913 for (int y = 0; y < (int) imageH; ++y)
2914 for (int x = 0; x < (int) imageW; ++x)
2915 *dest++ = image.getPixelAt (x, y).getARGB();
2916
2917 void* result = (void*) xXcursorImageLoadCursor (display, xcImage);
2918 xXcursorImageDestroy (xcImage);
2919
2920 if (result != 0)
2921 return result;
2922 }
2923 }
2924 }
2925 #endif
2926
2927 Window root = RootWindow (display, DefaultScreen (display));
2928 unsigned int cursorW, cursorH;
2929 if (! XQueryBestCursor (display, root, imageW, imageH, &cursorW, &cursorH))
2930 return nullptr;
2931
2932 Image im (Image::ARGB, cursorW, cursorH, true);
2933
2934 {
2935 Graphics g (im);
2936
2937 if (imageW > cursorW || imageH > cursorH)
2938 {
2939 hotspotX = (hotspotX * cursorW) / imageW;
2940 hotspotY = (hotspotY * cursorH) / imageH;
2941
2942 g.drawImageWithin (image, 0, 0, imageW, imageH,
2943 RectanglePlacement::xLeft | RectanglePlacement::yTop | RectanglePlacement::onlyReduceInSize,
2944 false);
2945 }
2946 else
2947 {
2948 g.drawImageAt (image, 0, 0);
2949 }
2950 }
2951
2952 const int stride = (cursorW + 7) >> 3;
2953 HeapBlock <char> maskPlane, sourcePlane;
2954 maskPlane.calloc (stride * cursorH);
2955 sourcePlane.calloc (stride * cursorH);
2956
2957 const bool msbfirst = (BitmapBitOrder (display) == MSBFirst);
2958
2959 for (int y = cursorH; --y >= 0;)
2960 {
2961 for (int x = cursorW; --x >= 0;)
2962 {
2963 const char mask = (char) (1 << (msbfirst ? (7 - (x & 7)) : (x & 7)));
2964 const int offset = y * stride + (x >> 3);
2965
2966 const Colour c (im.getPixelAt (x, y));
2967
2968 if (c.getAlpha() >= 128)
2969 maskPlane[offset] |= mask;
2970
2971 if (c.getBrightness() >= 0.5f)
2972 sourcePlane[offset] |= mask;
2973 }
2974 }
2975
2976 Pixmap sourcePixmap = XCreatePixmapFromBitmapData (display, root, sourcePlane.getData(), cursorW, cursorH, 0xffff, 0, 1);
2977 Pixmap maskPixmap = XCreatePixmapFromBitmapData (display, root, maskPlane.getData(), cursorW, cursorH, 0xffff, 0, 1);
2978
2979 XColor white, black;
2980 black.red = black.green = black.blue = 0;
2981 white.red = white.green = white.blue = 0xffff;
2982
2983 void* result = (void*) XCreatePixmapCursor (display, sourcePixmap, maskPixmap, &white, &black, hotspotX, hotspotY);
2984
2985 XFreePixmap (display, sourcePixmap);
2986 XFreePixmap (display, maskPixmap);
2987
2988 return result;
2989 }
2990
2991 void MouseCursor::deleteMouseCursor (void* const cursorHandle, const bool)
2992 {
2993 ScopedXLock xlock;
2994 if (cursorHandle != 0)
2995 XFreeCursor (display, (Cursor) cursorHandle);
2996 }
2997
2998 void* MouseCursor::createStandardMouseCursor (MouseCursor::StandardCursorType type)
2999 {
3000 unsigned int shape;
3001
3002 switch (type)
3003 {
3004 case NormalCursor: return None; // Use parent cursor
3005 case NoCursor: return createMouseCursorFromImage (Image (Image::ARGB, 16, 16, true), 0, 0);
3006
3007 case WaitCursor: shape = XC_watch; break;
3008 case IBeamCursor: shape = XC_xterm; break;
3009 case PointingHandCursor: shape = XC_hand2; break;
3010 case LeftRightResizeCursor: shape = XC_sb_h_double_arrow; break;
3011 case UpDownResizeCursor: shape = XC_sb_v_double_arrow; break;
3012 case UpDownLeftRightResizeCursor: shape = XC_fleur; break;
3013 case TopEdgeResizeCursor: shape = XC_top_side; break;
3014 case BottomEdgeResizeCursor: shape = XC_bottom_side; break;
3015 case LeftEdgeResizeCursor: shape = XC_left_side; break;
3016 case RightEdgeResizeCursor: shape = XC_right_side; break;
3017 case TopLeftCornerResizeCursor: shape = XC_top_left_corner; break;
3018 case TopRightCornerResizeCursor: shape = XC_top_right_corner; break;
3019 case BottomLeftCornerResizeCursor: shape = XC_bottom_left_corner; break;
3020 case BottomRightCornerResizeCursor: shape = XC_bottom_right_corner; break;
3021 case CrosshairCursor: shape = XC_crosshair; break;
3022
3023 case DraggingHandCursor:
3024 {
3025 static unsigned char dragHandData[] = { 71,73,70,56,57,97,16,0,16,0,145,2,0,0,0,0,255,255,255,0,
3026 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,
3027 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 };
3028 const int dragHandDataSize = 99;
3029
3030 return createMouseCursorFromImage (ImageFileFormat::loadFrom (dragHandData, dragHandDataSize), 8, 7);
3031 }
3032
3033 case CopyingCursor:
3034 {
3035 static unsigned char copyCursorData[] = { 71,73,70,56,57,97,21,0,21,0,145,0,0,0,0,0,255,255,255,0,
3036 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,
3037 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,
3038 252,114,147,74,83,5,50,68,147,208,217,16,71,149,252,124,5,0,59,0,0 };
3039 const int copyCursorSize = 119;
3040
3041 return createMouseCursorFromImage (ImageFileFormat::loadFrom (copyCursorData, copyCursorSize), 1, 3);
3042 }
3043
3044 default:
3045 jassertfalse;
3046 return None;
3047 }
3048
3049 ScopedXLock xlock;
3050 return (void*) XCreateFontCursor (display, shape);
3051 }
3052
3053 void MouseCursor::showInWindow (ComponentPeer* peer) const
3054 {
3055 LinuxComponentPeer* const lp = dynamic_cast <LinuxComponentPeer*> (peer);
3056
3057 if (lp != 0)
3058 lp->showMouseCursor ((Cursor) getHandle());
3059 }
3060
3061 void MouseCursor::showInAllWindows() const
3062 {
3063 for (int i = ComponentPeer::getNumPeers(); --i >= 0;)
3064 showInWindow (ComponentPeer::getPeer (i));
3065 }
3066
3067 //==============================================================================
3068 Image juce_createIconForFile (const File& file)
3069 {
3070 return Image::null;
3071 }
3072
3073 Image::SharedImage* Image::SharedImage::createNativeImage (PixelFormat format, int width, int height, bool clearImage)
3074 {
3075 return createSoftwareImage (format, width, height, clearImage);
3076 }
3077
3078
3079 //==============================================================================
3080 #if JUCE_OPENGL
3081
3082
3083 //==============================================================================
3084 class WindowedGLContext : public OpenGLContext
3085 {
3086 public:
3087 WindowedGLContext (Component* const component,
3088 const OpenGLPixelFormat& pixelFormat_,
3089 GLXContext sharedContext)
3090 : renderContext (0),
3091 embeddedWindow (0),
3092 pixelFormat (pixelFormat_),
3093 swapInterval (0)
3094 {
3095 jassert (component != nullptr);
3096 LinuxComponentPeer* const peer = dynamic_cast <LinuxComponentPeer*> (component->getTopLevelComponent()->getPeer());
3097 if (peer == nullptr)
3098 return;
3099
3100 ScopedXLock xlock;
3101 XSync (display, False);
3102
3103 GLint attribs [64];
3104 int n = 0;
3105 attribs[n++] = GLX_RGBA;
3106 attribs[n++] = GLX_DOUBLEBUFFER;
3107 attribs[n++] = GLX_RED_SIZE;
3108 attribs[n++] = pixelFormat.redBits;
3109 attribs[n++] = GLX_GREEN_SIZE;
3110 attribs[n++] = pixelFormat.greenBits;
3111 attribs[n++] = GLX_BLUE_SIZE;
3112 attribs[n++] = pixelFormat.blueBits;
3113 attribs[n++] = GLX_ALPHA_SIZE;
3114 attribs[n++] = pixelFormat.alphaBits;
3115 attribs[n++] = GLX_DEPTH_SIZE;
3116 attribs[n++] = pixelFormat.depthBufferBits;
3117 attribs[n++] = GLX_STENCIL_SIZE;
3118 attribs[n++] = pixelFormat.stencilBufferBits;
3119 attribs[n++] = GLX_ACCUM_RED_SIZE;
3120 attribs[n++] = pixelFormat.accumulationBufferRedBits;
3121 attribs[n++] = GLX_ACCUM_GREEN_SIZE;
3122 attribs[n++] = pixelFormat.accumulationBufferGreenBits;
3123 attribs[n++] = GLX_ACCUM_BLUE_SIZE;
3124 attribs[n++] = pixelFormat.accumulationBufferBlueBits;
3125 attribs[n++] = GLX_ACCUM_ALPHA_SIZE;
3126 attribs[n++] = pixelFormat.accumulationBufferAlphaBits;
3127
3128 // xxx not sure how to do fullSceneAntiAliasingNumSamples on linux..
3129
3130 attribs[n++] = None;
3131
3132 XVisualInfo* const bestVisual = glXChooseVisual (display, DefaultScreen (display), attribs);
3133
3134 if (bestVisual == 0)
3135 return;
3136
3137 renderContext = glXCreateContext (display, bestVisual, sharedContext, GL_TRUE);
3138
3139 Window windowH = (Window) peer->getNativeHandle();
3140
3141 Colormap colourMap = XCreateColormap (display, windowH, bestVisual->visual, AllocNone);
3142 XSetWindowAttributes swa;
3143 swa.colormap = colourMap;
3144 swa.border_pixel = 0;
3145 swa.event_mask = ExposureMask | StructureNotifyMask;
3146
3147 embeddedWindow = XCreateWindow (display, windowH,
3148 0, 0, 1, 1, 0,
3149 bestVisual->depth,
3150 InputOutput,
3151 bestVisual->visual,
3152 CWBorderPixel | CWColormap | CWEventMask,
3153 &swa);
3154
3155 XSaveContext (display, (XID) embeddedWindow, windowHandleXContext, (XPointer) peer);
3156
3157 XMapWindow (display, embeddedWindow);
3158 XFreeColormap (display, colourMap);
3159
3160 XFree (bestVisual);
3161 XSync (display, False);
3162 }
3163
3164 ~WindowedGLContext()
3165 {
3166 ScopedXLock xlock;
3167 deleteContext();
3168
3169 XUnmapWindow (display, embeddedWindow);
3170 XDestroyWindow (display, embeddedWindow);
3171 }
3172
3173 void deleteContext()
3174 {
3175 makeInactive();
3176
3177 if (renderContext != 0)
3178 {
3179 ScopedXLock xlock;
3180 glXDestroyContext (display, renderContext);
3181 renderContext = nullptr;
3182 }
3183 }
3184
3185 bool makeActive() const noexcept
3186 {
3187 jassert (renderContext != 0);
3188
3189 ScopedXLock xlock;
3190 return glXMakeCurrent (display, embeddedWindow, renderContext)
3191 && XSync (display, False);
3192 }
3193
3194 bool makeInactive() const noexcept
3195 {
3196 ScopedXLock xlock;
3197 return (! isActive()) || glXMakeCurrent (display, None, 0);
3198 }
3199
3200 bool isActive() const noexcept
3201 {
3202 ScopedXLock xlock;
3203 return glXGetCurrentContext() == renderContext;
3204 }
3205
3206 const OpenGLPixelFormat getPixelFormat() const
3207 {
3208 return pixelFormat;
3209 }
3210
3211 void* getRawContext() const noexcept
3212 {
3213 return renderContext;
3214 }
3215
3216 void updateWindowPosition (const Rectangle<int>& bounds)
3217 {
3218 ScopedXLock xlock;
3219 XMoveResizeWindow (display, embeddedWindow,
3220 bounds.getX(), bounds.getY(), jmax (1, bounds.getWidth()), jmax (1, bounds.getHeight()));
3221 }
3222
3223 void swapBuffers()
3224 {
3225 ScopedXLock xlock;
3226 glXSwapBuffers (display, embeddedWindow);
3227 }
3228
3229 bool setSwapInterval (const int numFramesPerSwap)
3230 {
3231 static PFNGLXSWAPINTERVALSGIPROC GLXSwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC) glXGetProcAddress ((const GLubyte*) "glXSwapIntervalSGI");
3232
3233 if (GLXSwapIntervalSGI != 0)
3234 {
3235 swapInterval = numFramesPerSwap;
3236 GLXSwapIntervalSGI (numFramesPerSwap);
3237 return true;
3238 }
3239
3240 return false;
3241 }
3242
3243 int getSwapInterval() const
3244 {
3245 return swapInterval;
3246 }
3247
3248 void repaint()
3249 {
3250 }
3251
3252 //==============================================================================
3253 GLXContext renderContext;
3254
3255 private:
3256 Window embeddedWindow;
3257 OpenGLPixelFormat pixelFormat;
3258 int swapInterval;
3259
3260 //==============================================================================
3261 JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (WindowedGLContext);
3262 };
3263
3264 //==============================================================================
3265 OpenGLContext* OpenGLComponent::createContext()
3266 {
3267 ScopedPointer<WindowedGLContext> c (new WindowedGLContext (this, preferredPixelFormat,
3268 contextToShareListsWith != 0 ? (GLXContext) contextToShareListsWith->getRawContext() : 0));
3269
3270 return (c->renderContext != 0) ? c.release() : nullptr;
3271 }
3272
3273 void juce_glViewport (const int w, const int h)
3274 {
3275 glViewport (0, 0, w, h);
3276 }
3277
3278 void OpenGLPixelFormat::getAvailablePixelFormats (Component* component,
3279 OwnedArray <OpenGLPixelFormat>& results)
3280 {
3281 results.add (new OpenGLPixelFormat()); // xxx
3282 }
3283
3284 #endif
3285
3286
3287 //==============================================================================
3288 bool DragAndDropContainer::performExternalDragDropOfFiles (const StringArray& files, const bool canMoveFiles)
3289 {
3290 jassertfalse; // not implemented!
3291 return false;
3292 }
3293
3294 bool DragAndDropContainer::performExternalDragDropOfText (const String& text)
3295 {
3296 jassertfalse; // not implemented!
3297 return false;
3298 }
3299
3300 //==============================================================================
3301 void SystemTrayIconComponent::setIconImage (const Image& newImage)
3302 {
3303 if (! isOnDesktop ())
3304 addToDesktop (0);
3305
3306 LinuxComponentPeer* const wp = dynamic_cast <LinuxComponentPeer*> (getPeer());
3307
3308 if (wp != 0)
3309 {
3310 wp->setTaskBarIcon (newImage);
3311
3312 setVisible (true);
3313 toFront (false);
3314 repaint();
3315 }
3316 }
3317
3318 void SystemTrayIconComponent::paint (Graphics& g)
3319 {
3320 LinuxComponentPeer* const wp = dynamic_cast <LinuxComponentPeer*> (getPeer());
3321
3322 if (wp != 0)
3323 {
3324 g.drawImageWithin (wp->getTaskbarIcon(), 0, 0, getWidth(), getHeight(),
3325 RectanglePlacement::xLeft | RectanglePlacement::yTop | RectanglePlacement::onlyReduceInSize,
3326 false);
3327 }
3328 }
3329
3330 void SystemTrayIconComponent::setIconTooltip (const String& tooltip)
3331 {
3332 // xxx not yet implemented!
3333 }
3334
3335
3336 //==============================================================================
3337 void PlatformUtilities::beep()
3338 {
3339 std::cout << "\a" << std::flush;
3340 }
3341
3342
3343 //==============================================================================
3344 void JUCE_CALLTYPE NativeMessageBox::showMessageBox (AlertWindow::AlertIconType iconType,
3345 const String& title, const String& message,
3346 Component* associatedComponent)
3347 {
3348 AlertWindow::showMessageBox (AlertWindow::NoIcon, title, message);
3349 }
3350
3351 void JUCE_CALLTYPE NativeMessageBox::showMessageBoxAsync (AlertWindow::AlertIconType iconType,
3352 const String& title, const String& message,
3353 Component* associatedComponent)
3354 {
3355 AlertWindow::showMessageBoxAsync (AlertWindow::NoIcon, title, message);
3356 }
3357
3358 bool JUCE_CALLTYPE NativeMessageBox::showOkCancelBox (AlertWindow::AlertIconType iconType,
3359 const String& title, const String& message,
3360 Component* associatedComponent,
3361 ModalComponentManager::Callback* callback)
3362 {
3363 return AlertWindow::showOkCancelBox (iconType, title, message, String::empty, String::empty,
3364 associatedComponent, callback);
3365 }
3366
3367 int JUCE_CALLTYPE NativeMessageBox::showYesNoCancelBox (AlertWindow::AlertIconType iconType,
3368 const String& title, const String& message,
3369 Component* associatedComponent,
3370 ModalComponentManager::Callback* callback)
3371 {
3372 return AlertWindow::showYesNoCancelBox (iconType, title, message,
3373 String::empty, String::empty, String::empty,
3374 associatedComponent, callback);
3375 }
3376
3377
3378 //==============================================================================
3379 const int KeyPress::spaceKey = XK_space & 0xff;
3380 const int KeyPress::returnKey = XK_Return & 0xff;
3381 const int KeyPress::escapeKey = XK_Escape & 0xff;
3382 const int KeyPress::backspaceKey = XK_BackSpace & 0xff;
3383 const int KeyPress::leftKey = (XK_Left & 0xff) | Keys::extendedKeyModifier;
3384 const int KeyPress::rightKey = (XK_Right & 0xff) | Keys::extendedKeyModifier;
3385 const int KeyPress::upKey = (XK_Up & 0xff) | Keys::extendedKeyModifier;
3386 const int KeyPress::downKey = (XK_Down & 0xff) | Keys::extendedKeyModifier;
3387 const int KeyPress::pageUpKey = (XK_Page_Up & 0xff) | Keys::extendedKeyModifier;
3388 const int KeyPress::pageDownKey = (XK_Page_Down & 0xff) | Keys::extendedKeyModifier;
3389 const int KeyPress::endKey = (XK_End & 0xff) | Keys::extendedKeyModifier;
3390 const int KeyPress::homeKey = (XK_Home & 0xff) | Keys::extendedKeyModifier;
3391 const int KeyPress::insertKey = (XK_Insert & 0xff) | Keys::extendedKeyModifier;
3392 const int KeyPress::deleteKey = (XK_Delete & 0xff) | Keys::extendedKeyModifier;
3393 const int KeyPress::tabKey = XK_Tab & 0xff;
3394 const int KeyPress::F1Key = (XK_F1 & 0xff) | Keys::extendedKeyModifier;
3395 const int KeyPress::F2Key = (XK_F2 & 0xff) | Keys::extendedKeyModifier;
3396 const int KeyPress::F3Key = (XK_F3 & 0xff) | Keys::extendedKeyModifier;
3397 const int KeyPress::F4Key = (XK_F4 & 0xff) | Keys::extendedKeyModifier;
3398 const int KeyPress::F5Key = (XK_F5 & 0xff) | Keys::extendedKeyModifier;
3399 const int KeyPress::F6Key = (XK_F6 & 0xff) | Keys::extendedKeyModifier;
3400 const int KeyPress::F7Key = (XK_F7 & 0xff) | Keys::extendedKeyModifier;
3401 const int KeyPress::F8Key = (XK_F8 & 0xff) | Keys::extendedKeyModifier;
3402 const int KeyPress::F9Key = (XK_F9 & 0xff) | Keys::extendedKeyModifier;
3403 const int KeyPress::F10Key = (XK_F10 & 0xff) | Keys::extendedKeyModifier;
3404 const int KeyPress::F11Key = (XK_F11 & 0xff) | Keys::extendedKeyModifier;
3405 const int KeyPress::F12Key = (XK_F12 & 0xff) | Keys::extendedKeyModifier;
3406 const int KeyPress::F13Key = (XK_F13 & 0xff) | Keys::extendedKeyModifier;
3407 const int KeyPress::F14Key = (XK_F14 & 0xff) | Keys::extendedKeyModifier;
3408 const int KeyPress::F15Key = (XK_F15 & 0xff) | Keys::extendedKeyModifier;
3409 const int KeyPress::F16Key = (XK_F16 & 0xff) | Keys::extendedKeyModifier;
3410 const int KeyPress::numberPad0 = (XK_KP_0 & 0xff) | Keys::extendedKeyModifier;
3411 const int KeyPress::numberPad1 = (XK_KP_1 & 0xff) | Keys::extendedKeyModifier;
3412 const int KeyPress::numberPad2 = (XK_KP_2 & 0xff) | Keys::extendedKeyModifier;
3413 const int KeyPress::numberPad3 = (XK_KP_3 & 0xff) | Keys::extendedKeyModifier;
3414 const int KeyPress::numberPad4 = (XK_KP_4 & 0xff) | Keys::extendedKeyModifier;
3415 const int KeyPress::numberPad5 = (XK_KP_5 & 0xff) | Keys::extendedKeyModifier;
3416 const int KeyPress::numberPad6 = (XK_KP_6 & 0xff) | Keys::extendedKeyModifier;
3417 const int KeyPress::numberPad7 = (XK_KP_7 & 0xff)| Keys::extendedKeyModifier;
3418 const int KeyPress::numberPad8 = (XK_KP_8 & 0xff)| Keys::extendedKeyModifier;
3419 const int KeyPress::numberPad9 = (XK_KP_9 & 0xff)| Keys::extendedKeyModifier;
3420 const int KeyPress::numberPadAdd = (XK_KP_Add & 0xff)| Keys::extendedKeyModifier;
3421 const int KeyPress::numberPadSubtract = (XK_KP_Subtract & 0xff)| Keys::extendedKeyModifier;
3422 const int KeyPress::numberPadMultiply = (XK_KP_Multiply & 0xff)| Keys::extendedKeyModifier;
3423 const int KeyPress::numberPadDivide = (XK_KP_Divide & 0xff)| Keys::extendedKeyModifier;
3424 const int KeyPress::numberPadSeparator = (XK_KP_Separator & 0xff)| Keys::extendedKeyModifier;
3425 const int KeyPress::numberPadDecimalPoint = (XK_KP_Decimal & 0xff)| Keys::extendedKeyModifier;
3426 const int KeyPress::numberPadEquals = (XK_KP_Equal & 0xff)| Keys::extendedKeyModifier;
3427 const int KeyPress::numberPadDelete = (XK_KP_Delete & 0xff)| Keys::extendedKeyModifier;
3428 const int KeyPress::playKey = (0xffeeff00) | Keys::extendedKeyModifier;
3429 const int KeyPress::stopKey = (0xffeeff01) | Keys::extendedKeyModifier;
3430 const int KeyPress::fastForwardKey = (0xffeeff02) | Keys::extendedKeyModifier;
3431 const int KeyPress::rewindKey = (0xffeeff03) | Keys::extendedKeyModifier;
3432
3433
3434 #endif
JUCE LV2 wrapper