27 files changed, 7045 insertions, 48 deletions

diff --git a/conf/distro/angstrom-2006.9.conf b/conf/distro/angstrom-2006.9.conf
index beef9b9fac..2fc1e31c72 100644
--- a/conf/distro/angstrom-2006.9.conf
+++ b/conf/distro/angstrom-2006.9.conf
@@ -67,9 +67,13 @@ PREFERRED_VERSION_glibc-intermediate ?= "2.4"
 
 PREFERRED_VERSION_orinoco-modules_h3600 = "0.13e"
 PREFERRED_VERSION_orinoco-modules_h3900 = "0.13e"
-PREFERRED_VERSION_dbus = "0.61"
-PREFERRED_VERSION_gstreamer = "0.10.4"
-PREFERRED_PROVIDER_hostap-conf = "hostap-conf"
+PREFERRED_VERSION_dbus ?= "0.61"
+PREFERRED_VERSION_gstreamer ?= "0.10.4"
+
+PREFERRED_PROVIDER_hostap-conf ?= "hostap-conf"
+PREFERRED_PROVIDER_hostap-modules_h2200 ?= "hostap-modules"
+PREFERRED_PROVIDER_hostap-modules_hx4700 ?= "hostap-modules"
+PREFERRED_VERSION_hostap-modules ?= "0.4.7"
 
 #Down here we put stuff we want to install into machines without polluting conf/machine/ with distro stuff
 # c7x0, akita, spitz, nokia770, h2200, h6300, ipaq-pxa270, simpad
diff --git a/conf/machine/h2200.conf b/conf/machine/h2200.conf
index 9aec6866bb..8af4d3577a 100644
--- a/conf/machine/h2200.conf
+++ b/conf/machine/h2200.conf
@@ -26,7 +26,6 @@ SERIAL_CONSOLE = "115200 tts/0 vt100"
 
 USE_VT = "0"
 
-include conf/machine/include/ipaq-common.conf
 include conf/machine/include/handheld-common.conf
 
 GUI_MACHINE_CLASS = "smallscreen"
diff --git a/conf/machine/ipaq-pxa270.conf b/conf/machine/ipaq-pxa270.conf
index c6f4804d5f..66d3eb38ff 100644
--- a/conf/machine/ipaq-pxa270.conf
+++ b/conf/machine/ipaq-pxa270.conf
@@ -31,7 +31,6 @@ PXA270_MODULES = "g_ether g_file_storage g_serial gadgetfs pxa27x_udc \
 
 SERIAL_CONSOLE = "115200 ttyS0"
 
-include conf/machine/include/ipaq-common.conf
 include conf/machine/include/handheld-common.conf
 
 GUI_MACHINE_CLASS = "bigscreen"
diff --git a/packages/frodo/frodo_4.2.bb b/packages/frodo/frodo_4.2.bb
index 8158cb2d5b..0c7772d729 100644
--- a/packages/frodo/frodo_4.2.bb
+++ b/packages/frodo/frodo_4.2.bb
@@ -6,7 +6,7 @@ LICENSE = "GPL"
 SRCDATE = "20040801"
 PR = "r1"
 
-SRC_URI = "cvs://anoncvs:anoncvs@down.physik.uni-mainz.de/cvs;module=Frodo4 \
+SRC_URI = "cvs://anoncvs:anoncvs@cvs.cebix.net/home/cvs/cebix;module=Frodo4 \
            file://m4.patch;patch=1 \
            file://configure.patch;patch=1 \
            file://frodorc \
diff --git a/packages/gnome/gnome-vfs-dbus_svn.bb b/packages/gnome/gnome-vfs-dbus_svn.bb
index c4612808ed..604da1168c 100644
--- a/packages/gnome/gnome-vfs-dbus_svn.bb
+++ b/packages/gnome/gnome-vfs-dbus_svn.bb
@@ -4,7 +4,7 @@ PR = "r0"
 PROVIDES = "gnome-vfs"
 RPROVIDES = "gnome-vfs"
 
-DEFAULT_PREFERENCE = "-1"
+PV = "2.8.4.4+svn${SRCDATE}"
 
 inherit gnome pkgconfig
 
@@ -84,6 +84,10 @@ do_configure_prepend() {
 	install ${WORKDIR}/gtk-doc.make ./
 }
 
+do_compile_prepend() {
+    find ${S} -name Makefile | xargs sed -i 's:-Werror::'
+}
+
 do_stage() {
 	oe_libinstall -so -C libgnomevfs libgnomevfs-2 ${STAGING_LIBDIR}
 	install -d ${STAGING_INCDIR}/gnome-vfs-2.0/libgnomevfs
diff --git a/packages/gpe-what/gpe-what_0.43.bb b/packages/gpe-what/gpe-what_0.43.bb
new file mode 100644
index 0000000000..383e31995f
--- /dev/null
+++ b/packages/gpe-what/gpe-what_0.43.bb
@@ -0,0 +1,8 @@
+LICENSE = "GPL"
+DESCRIPTION = "GPE modal help"
+DEPENDS = "libx11 gtk+"
+
+
+GPE_TARBALL_SUFFIX= "bz2"
+inherit autotools gpe
+
diff --git a/packages/juce/.mtn2git_empty b/packages/juce/.mtn2git_empty
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/packages/juce/.mtn2git_empty
diff --git a/packages/juce/files/.mtn2git_empty b/packages/juce/files/.mtn2git_empty
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/packages/juce/files/.mtn2git_empty
diff --git a/packages/juce/files/no-opengl.patch b/packages/juce/files/no-opengl.patch
new file mode 100644
index 0000000000..dd379349f4
--- /dev/null
+++ b/packages/juce/files/no-opengl.patch
@@ -0,0 +1,4477 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- juce/demo/build/linux/JuceDemo.make~no-opengl
++++ juce/demo/build/linux/JuceDemo.make
+@@ -13,7 +13,7 @@
+   CPPFLAGS := -MD -D "LINUX=1" -D "DEBUG=1" -D "_DEBUG=1" -I "/usr/include"
+   CFLAGS += $(CPPFLAGS) -g -D_DEBUG -ggdb
+   CXXFLAGS := $(CFLAGS)
+-  LDFLAGS += -L$(BINDIR) -L$(LIBDIR) -L "/usr/X11R6/lib/" -L "../../../bin" -lfreetype -lpthread -lX11 -lGL -lGLU -lXinerama -lasound -ljuce_debug
++  LDFLAGS += -L$(BINDIR) -L$(LIBDIR) -L "/usr/X11R6/lib/" -L "../../../bin" -lfreetype -lpthread -lX11 -lasound -ljuce_debug
+   LDDEPS :=
+   TARGET := jucedemo
+ endif
+@@ -26,7 +26,7 @@
+   CPPFLAGS := -MD -D "LINUX=1" -D "NDEBUG=1" -I "/usr/include"
+   CFLAGS += $(CPPFLAGS) -O2
+   CXXFLAGS := $(CFLAGS)
+-  LDFLAGS += -L$(BINDIR) -L$(LIBDIR) -s -L "/usr/X11R6/lib/" -L "../../../bin" -lfreetype -lpthread -lX11 -lGL -lGLU -lXinerama -lasound -ljuce
++  LDFLAGS += -L$(BINDIR) -L$(LIBDIR) -s -L "/usr/X11R6/lib/" -L "../../../bin" -lfreetype -lpthread -lX11 -lasound -ljuce
+   LDDEPS :=
+   TARGET := jucedemo
+ endif
+@@ -39,7 +39,6 @@
+ 	$(OBJDIR)/DragAndDropDemo.o \
+ 	$(OBJDIR)/FontsAndTextDemo.o \
+ 	$(OBJDIR)/InterprocessCommsDemo.o \
+-	$(OBJDIR)/OpenGLDemo.o \
+ 	$(OBJDIR)/PathsAndTransformsDemo.o \
+ 	$(OBJDIR)/QuickTimeDemo.o \
+ 	$(OBJDIR)/ThreadingDemo.o \
+--- juce/platform_specific_code/juce_linux_Windowing.cpp
++++ /dev/null
+--- juce/linux/platform_specific_code/juce_linux_Windowing.cpp
++++ /dev/null
+--- juce/build/linux/platform_specific_code/juce_linux_Windowing.cpp~no-opengl
++++ juce/build/linux/platform_specific_code/juce_linux_Windowing.cpp
+@@ -1,2218 +1,2219 @@
+-/*

+-  ==============================================================================

+-

+-   This file is part of the JUCE library - "Jules' Utility Class Extensions"

+-   Copyright 2004-6 by Raw Material Software ltd.

+-

+-  ------------------------------------------------------------------------------

+-

+-   JUCE can be redistributed and/or modified under the terms of the

+-   GNU General Public License, as published by the Free Software Foundation;

+-   either version 2 of the License, or (at your option) any later version.

+-

+-   JUCE is distributed in the hope that it will be useful,

+-   but WITHOUT ANY WARRANTY; without even the implied warranty of

+-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+-   GNU General Public License for more details.

+-

+-   You should have received a copy of the GNU General Public License

+-   along with JUCE; if not, visit www.gnu.org/licenses or write to the

+-   Free Software Foundation, Inc., 59 Temple Place, Suite 330, 

+-   Boston, MA 02111-1307 USA

+-

+-  ------------------------------------------------------------------------------

+-

+-   If you'd like to release a closed-source product which uses JUCE, commercial

+-   licenses are also available: visit www.rawmaterialsoftware.com/juce for

+-   more information.

+-

+-  ==============================================================================

+-*/

+-

+-#include "juce_Config.h"

+-#if JUCE_BUILD_GUI_CLASSES

+-

+-#include "linuxincludes.h"

+-#include <X11/Xlib.h>

+-#include <X11/Xutil.h>

+-#include <X11/Xatom.h>

+-#include <X11/Xmd.h>

+-#include <X11/keysym.h>

+-#include <X11/cursorfont.h>

+-

+-#include "../../../juce_Config.h"

+-

+-#if JUCE_USE_XINERAMA

+-#include <X11/extensions/Xinerama.h>

+-#endif

+-

+-#if JUCE_OPENGL

+-#include <X11/Xlib.h>

+-#include <GL/glx.h>

+-#endif

+-

+-#undef KeyPress

+-

+-#include "../../../src/juce_core/basics/juce_StandardHeader.h"

+-

+-BEGIN_JUCE_NAMESPACE

+-

+-#include "../../../src/juce_appframework/events/juce_Timer.h"

+-#include "../../../src/juce_appframework/application/juce_DeletedAtShutdown.h"

+-#include "../../../src/juce_appframework/gui/components/keyboard/juce_KeyPress.h"

+-#include "../../../src/juce_appframework/application/juce_SystemClipboard.h"

+-#include "../../../src/juce_appframework/gui/components/windows/juce_AlertWindow.h"

+-#include "../../../src/juce_appframework/gui/components/special/juce_OpenGLComponent.h"

+-#include "../../../src/juce_appframework/gui/components/juce_Desktop.h"

+-#include "../../../src/juce_appframework/events/juce_MessageManager.h"

+-#include "../../../src/juce_appframework/gui/components/juce_RepaintManager.h"

+-#include "../../../src/juce_appframework/gui/components/juce_ComponentDeletionWatcher.h"

+-#include "../../../src/juce_appframework/gui/graphics/geometry/juce_RectangleList.h"

+-#include "../../../src/juce_appframework/gui/graphics/imaging/juce_ImageFileFormat.h"

+-#include "../../../src/juce_appframework/gui/components/mouse/juce_DragAndDropContainer.h"

+-#include "../../../src/juce_core/basics/juce_Logger.h"

+-#include "../../../src/juce_core/threads/juce_Process.h"

+-#include "../../../src/juce_core/misc/juce_PlatformUtilities.h"

+-

+-

+-//==============================================================================

+-static Atom wm_ChangeState = None;

+-static Atom wm_State = None;

+-static Atom wm_Protocols = None;

+-static Atom wm_ProtocolList [2] = { None, None };

+-static Atom wm_ActiveWin = None;

+-static Atom repaintId = None;

+-

+-#define TAKE_FOCUS 0

+-#define DELETE_WINDOW 1

+-

+-//==============================================================================

+-static bool isActiveApplication = false;

+-

+-bool Process::isForegroundProcess()

+-{

+-    return isActiveApplication;

+-}

+-

+-//==============================================================================

+-// These are defined in juce_linux_Messages.cpp

+-extern Display* display;

+-extern XContext improbableNumber;

+-

+-const int juce_windowIsSemiTransparentFlag = (1 << 31); // also in component.cpp

+-

+-static const int eventMask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask

+-                             | EnterWindowMask | LeaveWindowMask | PointerMotionMask | KeymapStateMask

+-                             | ExposureMask | StructureNotifyMask | FocusChangeMask;

+-

+-//==============================================================================

+-static int pointerMap[5];

+-static int lastMousePosX = 0, lastMousePosY = 0;

+-

+-enum MouseButtons

+-{

+-    NoButton = 0,

+-    LeftButton = 1,

+-    MiddleButton = 2,

+-    RightButton = 3,

+-    WheelUp = 4,

+-    WheelDown = 5

+-};

+-

+-static void getMousePos (int& x, int& y, int& mouseMods)

+-{

+-    Window root, child;

+-    int winx, winy;

+-    unsigned int mask;

+-

+-    mouseMods = 0;

+-

+-    if (XQueryPointer (display,

+-                       RootWindow (display, DefaultScreen (display)),

+-                       &root, &child,

+-                       &x, &y, &winx, &winy, &mask) == False)

+-    {

+-        // Pointer not on the default screen

+-        x = y = -1;

+-    }

+-    else

+-    {

+-        if ((mask & Button1Mask) != 0)

+-            mouseMods |= ModifierKeys::leftButtonModifier;

+-

+-        if ((mask & Button2Mask) != 0)

+-            mouseMods |= ModifierKeys::middleButtonModifier;

+-

+-        if ((mask & Button3Mask) != 0)

+-            mouseMods |= ModifierKeys::rightButtonModifier;

+-    }

+-}

+-

+-//==============================================================================

+-static int AltMask = 0;

+-static int NumLockMask = 0;

+-static bool numLock = 0;

+-static bool capsLock = 0;

+-static char keyStates [32];

+-

+-static void updateKeyStates (const int keycode, const bool press)

+-{

+-    const int keybyte = keycode >> 3;

+-    const int keybit = (1 << (keycode & 7));

+-

+-    if (press)

+-        keyStates [keybyte] |= keybit;

+-    else

+-        keyStates [keybyte] &= ~keybit;

+-}

+-

+-static bool keyDown (const int keycode)

+-{

+-    const int keybyte = keycode >> 3;

+-    const int keybit = (1 << (keycode & 7));

+-

+-    return (keyStates [keybyte] & keybit) != 0;

+-}

+-

+-static const int nonAsciiModifier = 0x10000;

+-

+-bool KeyPress::isKeyCurrentlyDown (int keyCode)

+-{

+-    int keysym;

+-

+-    if (keyCode & nonAsciiModifier)

+-    {

+-        keysym = 0xff00 | (keyCode & 0xff);

+-    }

+-    else

+-    {

+-        keysym = keyCode;

+-

+-        if (keysym == (XK_Tab & 0xff)

+-            || keysym == (XK_Return & 0xff)

+-            || keysym == (XK_Escape & 0xff)

+-            || keysym == (XK_BackSpace & 0xff))

+-        {

+-            keysym |= 0xff00;

+-        }

+-    }

+-

+-    return keyDown (XKeysymToKeycode (display, keysym));

+-}

+-

+-//==============================================================================

+-// Alt and Num lock are not defined by standard X

+-// modifier constants: check what they're mapped to

+-static void getModifierMapping()

+-{

+-    const int altLeftCode = XKeysymToKeycode (display, XK_Alt_L);

+-    const int numLockCode = XKeysymToKeycode (display, XK_Num_Lock);

+-

+-    AltMask = 0;

+-    NumLockMask = 0;

+-

+-    XModifierKeymap* mapping = XGetModifierMapping (display);

+-

+-    if (mapping)

+-    {

+-        for (int i = 0; i < 8; i++)

+-        {

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

+-                AltMask = 1 << i;

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

+-                NumLockMask = 1 << i;

+-        }

+-

+-        XFreeModifiermap (mapping);

+-    }

+-}

+-

+-static int currentModifiers = 0;

+-

+-void ModifierKeys::updateCurrentModifiers()

+-{

+-    currentModifierFlags = currentModifiers;

+-}

+-

+-const ModifierKeys ModifierKeys::getCurrentModifiersRealtime()

+-{

+-    int x, y, mouseMods;

+-    getMousePos (x, y, mouseMods);

+-

+-    currentModifiers &= ~ModifierKeys::allMouseButtonModifiers;

+-    currentModifiers |= mouseMods;

+-

+-    return ModifierKeys (currentModifiers);

+-}

+-

+-static void updateKeyModifiers (const int status)

+-{

+-    currentModifiers &= ~(ModifierKeys::shiftModifier

+-                           | ModifierKeys::ctrlModifier

+-                           | ModifierKeys::altModifier);

+-

+-    if (status & ShiftMask)

+-        currentModifiers |= ModifierKeys::shiftModifier;

+-

+-    if (status & ControlMask)

+-        currentModifiers |= ModifierKeys::ctrlModifier;

+-

+-    if (status & AltMask)

+-        currentModifiers |= ModifierKeys::altModifier;

+-

+-    numLock  = ((status & NumLockMask) != 0);

+-    capsLock = ((status & LockMask) != 0);

+-}

+-

+-static bool updateKeyModifiersFromSym (KeySym sym, const bool press)

+-{

+-    int modifier = 0;

+-    bool isModifier = true;

+-

+-    switch (sym)

+-    {

+-        case XK_Shift_L:

+-        case XK_Shift_R:

+-            modifier = ModifierKeys::shiftModifier;

+-            break;

+-

+-        case XK_Control_L:

+-        case XK_Control_R:

+-            modifier = ModifierKeys::ctrlModifier;

+-            break;

+-

+-        case XK_Alt_L:

+-        case XK_Alt_R:

+-            modifier = ModifierKeys::altModifier;

+-            break;

+-

+-        case XK_Num_Lock:

+-            if (press)

+-                numLock = ! numLock;

+-

+-            break;

+-

+-        case XK_Caps_Lock:

+-            if (press)

+-                capsLock = ! capsLock;

+-

+-            break;

+-

+-        case XK_Scroll_Lock:

+-            break;

+-

+-        default:

+-            isModifier = false;

+-            break;

+-    }

+-

+-    if (modifier != 0)

+-    {

+-        if (press)

+-            currentModifiers |= modifier;

+-        else

+-            currentModifiers &= ~modifier;

+-    }

+-

+-    return isModifier;

+-}

+-

+-

+-//==============================================================================

+-class XBitmapImage  : public Image

+-{

+-public:

+-    //==============================================================================

+-    XBitmapImage (const PixelFormat format_, const int w, const int h, const bool clearImage)

+-        : Image (format_, w, h)

+-    {

+-        jassert (format_ == RGB || format_ == ARGB);

+-

+-        pixelStride = (format_ == RGB) ? 3 : 4;

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

+-        imageData = (uint8*) juce_malloc (lineStride * h);

+-

+-        if (format_ == ARGB && clearImage)

+-            zeromem (xImage->data, h * lineStride);

+-

+-        xImage = new XImage();

+-        xImage->width = w;

+-        xImage->height = h;

+-        xImage->xoffset = 0;

+-        xImage->format = ZPixmap;

+-        xImage->data = (char*) imageData;

+-        xImage->byte_order = ImageByteOrder (display);

+-        xImage->bitmap_unit = BitmapUnit (display);

+-        xImage->bitmap_bit_order = BitmapBitOrder (display);

+-        xImage->bitmap_pad = 32;

+-        xImage->depth = pixelStride * 8;

+-        xImage->bytes_per_line = lineStride;

+-        xImage->bits_per_pixel = pixelStride * 8;

+-        xImage->red_mask   = 0x00FF0000;

+-        xImage->green_mask = 0x0000FF00;

+-        xImage->blue_mask  = 0x000000FF;

+-

+-        if (! XInitImage (xImage))

+-        {

+-            jassertfalse

+-        }

+-    }

+-

+-    ~XBitmapImage()

+-    {

+-        juce_free (xImage->data);

+-        xImage->data = 0;

+-        XDestroyImage (xImage);

+-        imageData = 0; // to stop the base class freeing this

+-    }

+-

+-    void blitToWindow (Window window, int dx, int dy, int dw, int dh, int sx, int sy)

+-    {

+-        static GC gc = 0;

+-

+-        if (gc == 0)

+-            gc = DefaultGC (display, DefaultScreen (display));

+-

+-        // blit results to screen.

+-        XPutImage (display, (Drawable) window, gc, xImage, sx, sy, dx, dy, dw, dh);

+-    }

+-

+-    //==============================================================================

+-    juce_UseDebuggingNewOperator

+-

+-private:

+-    XImage* xImage;

+-};

+-

+-

+-//==============================================================================

+-class LinuxComponentPeer  : public ComponentPeer

+-{

+-public:

+-    //==============================================================================

+-    LinuxComponentPeer (Component* const component, const int windowStyleFlags)

+-        : ComponentPeer (component, windowStyleFlags),

+-          windowH (0),

+-          wx (0),

+-          wy (0),

+-          ww (0),

+-          wh (0),

+-          fullScreen (false),

+-          entered (false),

+-          mapped (false)

+-    {

+-        repainter = new LinuxRepaintManager (this, component, 3000);

+-

+-        MessageManager::getInstance()

+-           ->callFunctionOnMessageThread (&createWindowCallback, (void*) this);

+-

+-        setTitle (component->getName());

+-    }

+-

+-    ~LinuxComponentPeer()

+-    {

+-        MessageManager::getInstance()

+-            ->callFunctionOnMessageThread (&destroyWindowCallback, (void*) windowH);

+-

+-        windowH = 0;

+-        delete repainter;

+-    }

+-

+-    //==============================================================================

+-    void* getNativeHandle() const

+-    {

+-        return (void*) windowH;

+-    }

+-

+-    void setVisible (bool shouldBeVisible)

+-    {

+-        if (shouldBeVisible)

+-            XMapWindow (display, windowH);

+-        else

+-            XUnmapWindow (display, windowH);

+-    }

+-

+-    void setTitle (const String& title)

+-    {

+-        setWindowTitle (windowH, title);

+-    }

+-

+-    void setPosition (int x, int y)

+-    {

+-        setBounds (x, y, ww, wh, false);

+-    }

+-

+-    void setSize (int w, int h)

+-    {

+-        setBounds (wx, wy, w, h, false);

+-    }

+-

+-    void setBounds (int x, int y, int w, int h, const bool isNowFullScreen)

+-    {

+-        fullScreen = isNowFullScreen;

+-

+-        if (windowH != 0)

+-        {

+-            const ComponentDeletionWatcher deletionChecker (component);

+-

+-            wx = x;

+-            wy = y;

+-            ww = jmax (1, w);

+-            wh = jmax (1, h);

+-

+-            if (! mapped)

+-            {

+-                // Make sure the Window manager does what we want

+-                XSizeHints* hints = XAllocSizeHints();

+-                hints->flags = USSize | USPosition;

+-                hints->width = ww + windowBorder.getLeftAndRight();

+-                hints->height = wh + windowBorder.getTopAndBottom();

+-                hints->x = wx - windowBorder.getLeft();

+-                hints->y = wy - windowBorder.getTop();

+-                XSetWMNormalHints (display, windowH, hints);

+-                XFree (hints);

+-            }

+-

+-            XMoveResizeWindow (display, windowH,

+-                               wx - windowBorder.getLeft(),

+-                               wy - windowBorder.getTop(),

+-                               ww + windowBorder.getLeftAndRight(),

+-                               wh + windowBorder.getTopAndBottom());

+-

+-            if (! deletionChecker.hasBeenDeleted())

+-            {

+-                updateBorderSize();

+-                handleMovedOrResized();

+-            }

+-        }

+-    }

+-

+-    void getBounds (int& x, int& y, int& w, int& h) const

+-    {

+-        x = wx;

+-        y = wy;

+-        w = ww;

+-        h = wh;

+-    }

+-

+-    int getScreenX() const

+-    {

+-        return wx;

+-    }

+-

+-    int getScreenY() const

+-    {

+-        return wy;

+-    }

+-

+-    void setMinimised (bool shouldBeMinimised)

+-    {

+-        if (shouldBeMinimised)

+-        {

+-            Window root = RootWindow (display, DefaultScreen (display));

+-

+-            XClientMessageEvent clientMsg;

+-            clientMsg.display = display;

+-            clientMsg.window = windowH;

+-            clientMsg.type = ClientMessage;

+-            clientMsg.format = 32;

+-            clientMsg.message_type = wm_ChangeState;

+-            clientMsg.data.l[0] = IconicState;

+-

+-            XSendEvent (display, root, false,

+-                        SubstructureRedirectMask | SubstructureNotifyMask,

+-                        (XEvent*) &clientMsg);

+-        }

+-        else

+-        {

+-            setVisible (true);

+-        }

+-    }

+-

+-    bool isMinimised() const

+-    {

+-        bool minimised = false;

+-

+-        CARD32* stateProp;

+-        unsigned long nitems, bytesLeft;

+-        Atom actualType;

+-        int actualFormat;

+-

+-        if (XGetWindowProperty (display, windowH, wm_State, 0, 64, False,

+-                                wm_State, &actualType, &actualFormat, &nitems, &bytesLeft,

+-                                (unsigned char**) &stateProp) == Success

+-            && actualType == wm_State

+-            && actualFormat == 32

+-            && nitems > 0)

+-        {

+-            if (stateProp[0] == IconicState)

+-                minimised = true;

+-

+-            XFree (stateProp);

+-        }

+-

+-        return minimised;

+-    }

+-

+-    void setFullScreen (bool shouldBeFullScreen)

+-    {

+-        setMinimised (false);

+-

+-        if (fullScreen != shouldBeFullScreen)

+-        {

+-            Rectangle r (lastNonFullscreenBounds);

+-

+-            if (shouldBeFullScreen)

+-                r = Desktop::getInstance().getMainMonitorArea();

+-

+-            if (! r.isEmpty())

+-                setBounds (r.getX(), r.getY(), r.getWidth(), r.getHeight(), shouldBeFullScreen);

+-

+-            getComponent()->repaint();

+-        }

+-    }

+-

+-    bool isFullScreen() const

+-    {

+-        return fullScreen;

+-    }

+-

+-    bool isChildWindowOf (Window possibleParent) const

+-    {

+-        Window* windowList = 0;

+-        uint32 windowListSize = 0;

+-        Window parent, root;

+-

+-        if (XQueryTree (display, windowH, &root, &parent, &windowList, &windowListSize) != 0)

+-        {

+-            if (windowList != 0)

+-                XFree (windowList);

+-

+-            return parent == possibleParent;

+-        }

+-

+-        return false;

+-    }

+-

+-    bool contains (int x, int y, bool trueIfInAChildWindow) const

+-    {

+-        jassert (x >= 0 && y >= 0 && x < ww && y < wh); // should only be called for points that are actually inside the bounds

+-

+-        x += wx;

+-        y += wy;

+-

+-        // the XQueryTree stuff later on is VERY slow, so if this call's just to check the mouse pos, it's

+-        // much more efficient to cheat..

+-        if (x == lastMousePosX && y == lastMousePosY)

+-        {

+-            Window root, child;

+-            int winx, winy;

+-            unsigned int mask;

+-

+-            if (XQueryPointer (display,

+-                               RootWindow (display, DefaultScreen (display)),

+-                               &root, &child,

+-                               &x, &y, &winx, &winy, &mask) != False)

+-            {

+-                return child == windowH

+-                        || (((styleFlags & windowHasTitleBar) != 0) && isChildWindowOf (child));

+-            }

+-        }

+-

+-        bool result = false;

+-

+-        Window* windowList = 0;

+-        uint32 windowListSize = 0;

+-

+-        Window parent, root = RootWindow (display, DefaultScreen (display));

+-

+-        if (XQueryTree (display, root, &root, &parent, &windowList, &windowListSize) != 0)

+-        {

+-            for (int i = windowListSize; --i >= 0;)

+-            {

+-                XWindowAttributes atts;

+-

+-                if (windowList[i] == windowH

+-                     || (((styleFlags & windowHasTitleBar) != 0) && isChildWindowOf (windowList[i])))

+-                {

+-                    result = true;

+-

+-                    if (! trueIfInAChildWindow)

+-                    {

+-                        Window child;

+-                        int tempX, tempY;

+-

+-                        result = XTranslateCoordinates (display, windowH, windowH,

+-                                                        x - wx - windowBorder.getLeft(),

+-                                                        y - wy - windowBorder.getTop(),

+-                                                        &tempX, &tempY,

+-                                                        &child)

+-                                    && (child == None);

+-                    }

+-

+-                    break;

+-                }

+-                else if (XGetWindowAttributes (display, windowList[i], &atts)

+-                          && atts.map_state == IsViewable

+-                          && x >= atts.x && y >= atts.y

+-                          && x < atts.x + atts.width

+-                          && y < atts.y + atts.height)

+-                {

+-                    break;

+-                }

+-            }

+-        }

+-

+-        if (windowList != 0)

+-            XFree (windowList);

+-

+-        return result;

+-    }

+-

+-    const BorderSize getFrameSize() const

+-    {

+-        return BorderSize();

+-    }

+-

+-    bool setAlwaysOnTop (bool alwaysOnTop)

+-    {

+-        if (windowH != 0)

+-        {

+-            XSetWindowAttributes swa;

+-            swa.override_redirect = getComponent()->isAlwaysOnTop() ? True : False;

+-

+-            XChangeWindowAttributes (display, windowH, CWOverrideRedirect, &swa);

+-        }

+-

+-        return true;

+-    }

+-

+-    void toFront (bool makeActive)

+-    {

+-        if (makeActive)

+-        {

+-            setVisible (true);

+-            grabFocus();

+-        }

+-

+-        XEvent ev;

+-        ev.xclient.type = ClientMessage;

+-        ev.xclient.serial = 0;

+-        ev.xclient.send_event = True;

+-        ev.xclient.message_type = wm_ActiveWin;

+-        ev.xclient.window = windowH;

+-        ev.xclient.format = 32;

+-        ev.xclient.data.l[0] = 2;

+-        ev.xclient.data.l[1] = CurrentTime;

+-        ev.xclient.data.l[2] = 0;

+-        ev.xclient.data.l[3] = 0;

+-        ev.xclient.data.l[4] = 0;

+-

+-        XSendEvent (display, RootWindow (display, DefaultScreen (display)),

+-                    False,

+-                    SubstructureRedirectMask | SubstructureNotifyMask,

+-                    &ev);

+-

+-        XSync (display, False);

+-    }

+-

+-    void toBehind (ComponentPeer* other)

+-    {

+-        LinuxComponentPeer* const otherPeer = dynamic_cast <LinuxComponentPeer*> (other);

+-        jassert (otherPeer != 0); // wrong type of window?

+-

+-        if (otherPeer != 0)

+-        {

+-            setMinimised (false);

+-

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

+-

+-            XRestackWindows (display, newStack, 2);

+-        }

+-    }

+-

+-    bool isFocused() const

+-    {

+-        int revert;

+-        Window focus = 0;

+-        XGetInputFocus (display, &focus, &revert);

+-

+-        if (focus == 0 || focus == None || focus == PointerRoot)

+-            return 0;

+-

+-        ComponentPeer* focusedPeer = 0;

+-        if (XFindContext (display, (XID) focus, improbableNumber, (XPointer*) &focusedPeer) != 0)

+-            focusedPeer = 0;

+-

+-        return this == focusedPeer;

+-    }

+-

+-    void grabFocus()

+-    {

+-        XWindowAttributes atts;

+-

+-        if (windowH != 0

+-            && XGetWindowAttributes (display, windowH, &atts)

+-            && atts.map_state == IsViewable)

+-        {

+-            XSetInputFocus (display, windowH, RevertToParent, CurrentTime);

+-

+-            if (! isActiveApplication)

+-            {

+-                isActiveApplication = true;

+-                handleFocusGain();

+-            }

+-        }

+-    }

+-

+-    void repaint (int x, int y, int w, int h)

+-    {

+-        repainter->invalidateCache (x, y, w, h);

+-        repainter->repaint (x, y, w, h);

+-    }

+-

+-    void performPendingRepaints()

+-    {

+-        repainter->performPendingRepaints();

+-    }

+-

+-    //==============================================================================

+-    void handleWindowMessage (XEvent* event)

+-    {

+-        switch (event->xany.type)

+-        {

+-            case 2: // 'KeyPress'

+-            {

+-                XKeyEvent* keyEvent = (XKeyEvent*) &event->xkey;

+-                updateKeyStates (keyEvent->keycode, true);

+-

+-                int index = currentModifiers & ModifierKeys::shiftModifier ? 1 : 0;

+-                KeySym sym = XKeycodeToKeysym (display, keyEvent->keycode, index);

+-

+-                const int oldMods = currentModifiers;

+-                bool keyPressed = false;

+-

+-                const bool keyDownChange = (sym != NoSymbol) && ! updateKeyModifiersFromSym (sym, false);

+-

+-                if ((sym & 0xff00) == 0xff00)

+-                {

+-                    // Translate keypad

+-                    if (sym == XK_KP_Divide)

+-                        sym = XK_slash;

+-                    else if (sym == XK_KP_Multiply)

+-                        sym = XK_asterisk;

+-                    else if (sym == XK_KP_Subtract)

+-                        sym = XK_hyphen;

+-                    else if (sym == XK_KP_Add)

+-                        sym = XK_plus;

+-                    else if (sym == XK_KP_Enter)

+-                        sym = XK_Return;

+-                    else if (sym == XK_KP_Decimal)

+-                        sym = numLock ? XK_period : XK_Delete;

+-                    else if (sym == XK_KP_0)

+-                        sym = numLock ? XK_0 : XK_Insert;

+-                    else if (sym == XK_KP_1)

+-                        sym = numLock ? XK_1 : XK_End;

+-                    else if (sym == XK_KP_2)

+-                        sym = numLock ? XK_2 : XK_Down;

+-                    else if (sym == XK_KP_3)

+-                        sym = numLock ? XK_3 : XK_Page_Down;

+-                    else if (sym == XK_KP_4)

+-                        sym = numLock ? XK_4 : XK_Left;

+-                    else if (sym == XK_KP_5)

+-                        sym = XK_5;

+-                    else if (sym == XK_KP_6)

+-                        sym = numLock ? XK_6 : XK_Right;

+-                    else if (sym == XK_KP_7)

+-                        sym = numLock ? XK_7 : XK_Home;

+-                    else if (sym == XK_KP_8)

+-                        sym = numLock ? XK_8 : XK_Up;

+-                    else if (sym == XK_KP_9)

+-                        sym = numLock ? XK_9 : XK_Page_Up;

+-

+-                    switch (sym)

+-                    {

+-                        case XK_Left:

+-                        case XK_Right:

+-                        case XK_Up:

+-                        case XK_Down:

+-                        case XK_Page_Up:

+-                        case XK_Page_Down:

+-                        case XK_End:

+-                        case XK_Home:

+-                        case XK_Delete:

+-                        case XK_Insert:

+-                            keyPressed = true;

+-                            sym = (sym & 0xff) | nonAsciiModifier;

+-                            break;

+-                        case XK_Tab:

+-                        case XK_Return:

+-                        case XK_Escape:

+-                        case XK_BackSpace:

+-                            keyPressed = true;

+-                            sym &= 0xff;

+-                            break;

+-                        default:

+-                        {

+-                            if (sym >= XK_F1 && sym <= XK_F12)

+-                            {

+-                                keyPressed = true;

+-                                sym = (sym & 0xff) | nonAsciiModifier;

+-                            }

+-                            break;

+-                        }

+-                    }

+-                }

+-

+-                if ((sym & 0xff00) == 0 && sym >= 8)

+-                    keyPressed = true;

+-

+-                if (capsLock && ((sym >= XK_A && sym <= XK_Z) || (sym >= XK_a && sym <= XK_z)))

+-                {

+-                    index ^= 1;

+-                    sym = XKeycodeToKeysym (display, keyEvent->keycode, index);

+-                }

+-

+-                if (oldMods != currentModifiers)

+-                    handleModifierKeysChange();

+-

+-                if (keyDownChange)

+-                    handleKeyUpOrDown();

+-

+-                if (keyPressed)

+-                    handleKeyPress (sym);

+-

+-                break;

+-            }

+-

+-            case KeyRelease:

+-            {

+-                XKeyEvent* keyEvent = (XKeyEvent*) &event->xkey;

+-                updateKeyStates (keyEvent->keycode, false);

+-

+-                KeySym sym = XKeycodeToKeysym (display, keyEvent->keycode, 0);

+-

+-                const int oldMods = currentModifiers;

+-                const bool keyDownChange = (sym != NoSymbol) && ! updateKeyModifiersFromSym (sym, false);

+-

+-                if (oldMods != currentModifiers)

+-                    handleModifierKeysChange();

+-

+-                if (keyDownChange)

+-                    handleKeyUpOrDown();

+-

+-                break;

+-            }

+-

+-            case ButtonPress:

+-            {

+-                XButtonPressedEvent* buttonPressEvent = (XButtonPressedEvent*) &event->xbutton;

+-

+-                bool buttonMsg = false;

+-                bool wheelUpMsg = false;

+-                bool wheelDownMsg = false;

+-

+-                const int map = pointerMap [buttonPressEvent->button - Button1];

+-

+-                if (map == LeftButton)

+-                {

+-                    currentModifiers |= ModifierKeys::leftButtonModifier;

+-                    buttonMsg = true;

+-                }

+-                else if (map == RightButton)

+-                {

+-                    currentModifiers |= ModifierKeys::rightButtonModifier;

+-                    buttonMsg = true;

+-                }

+-                else if (map == MiddleButton)

+-                {

+-                    currentModifiers |= ModifierKeys::middleButtonModifier;

+-                    buttonMsg = true;

+-                }

+-                else if (map == WheelUp)

+-                {

+-                    wheelUpMsg = true;

+-                }

+-                else if (map == WheelDown)

+-                {

+-                    wheelDownMsg = true;

+-                }

+-

+-                updateKeyModifiers (buttonPressEvent->state);

+-

+-                if (buttonMsg)

+-                {

+-                    toFront (true);

+-                    handleMouseDown (buttonPressEvent->x, buttonPressEvent->y,

+-                                     getEventTime (buttonPressEvent->time));

+-                }

+-                else if (wheelUpMsg || wheelDownMsg)

+-                {

+-                    handleMouseWheel (wheelDownMsg ? -84 : 84,

+-                                      getEventTime (buttonPressEvent->time));

+-                }

+-

+-                lastMousePosX = lastMousePosY = 0x100000;

+-                break;

+-            }

+-

+-            case ButtonRelease:

+-            {

+-                XButtonReleasedEvent* buttonRelEvent = (XButtonReleasedEvent*) &event->xbutton;

+-

+-                const int oldModifiers = currentModifiers;

+-                const int map = pointerMap [buttonRelEvent->button - Button1];

+-

+-                if (map == LeftButton)

+-                    currentModifiers &= ~ModifierKeys::leftButtonModifier;

+-                else if (map == RightButton)

+-                    currentModifiers &= ~ModifierKeys::rightButtonModifier;

+-                else if (map == MiddleButton)

+-                    currentModifiers &= ~ModifierKeys::middleButtonModifier;

+-

+-                updateKeyModifiers (buttonRelEvent->state);

+-

+-                handleMouseUp (oldModifiers,

+-                               buttonRelEvent->x, buttonRelEvent->y,

+-                               getEventTime (buttonRelEvent->time));

+-

+-                lastMousePosX = lastMousePosY = 0x100000;

+-                break;

+-            }

+-

+-            case MotionNotify:

+-            {

+-                XPointerMovedEvent* movedEvent = (XPointerMovedEvent*) &event->xmotion;

+-

+-                updateKeyModifiers (movedEvent->state);

+-

+-                int x, y, mouseMods;

+-                getMousePos (x, y, mouseMods);

+-

+-                if (lastMousePosX != x || lastMousePosY != y)

+-                {

+-                    lastMousePosX = x;

+-                    lastMousePosY = y;

+-

+-                    x -= getScreenX();

+-                    y -= getScreenY();

+-

+-                    if ((currentModifiers & ModifierKeys::allMouseButtonModifiers) == 0)

+-                        handleMouseMove (x, y, getEventTime (movedEvent->time));

+-                    else

+-                        handleMouseDrag (x, y, getEventTime (movedEvent->time));

+-                }

+-

+-                break;

+-            }

+-

+-            case EnterNotify:

+-            {

+-                lastMousePosX = lastMousePosY = 0x100000;

+-                XEnterWindowEvent* enterEvent = (XEnterWindowEvent*) &event->xcrossing;

+-

+-                if ((currentModifiers & ModifierKeys::allMouseButtonModifiers) == 0

+-                     && ! entered)

+-                {

+-                    updateKeyModifiers (enterEvent->state);

+-

+-                    handleMouseEnter (enterEvent->x, enterEvent->y, getEventTime (enterEvent->time));

+-

+-                    entered = true;

+-                }

+-

+-                break;

+-            }

+-

+-            case LeaveNotify:

+-            {

+-                XLeaveWindowEvent* leaveEvent = (XLeaveWindowEvent*) &event->xcrossing;

+-

+-                // Suppress the normal leave if we've got a pointer grab, or if

+-                // it's a bogus one caused by clicking a mouse button when running

+-                // in a Window manager

+-                if (((currentModifiers & ModifierKeys::allMouseButtonModifiers) == 0

+-                     && leaveEvent->mode == NotifyNormal)

+-                    || leaveEvent->mode == NotifyUngrab)

+-                {

+-                    updateKeyModifiers (leaveEvent->state);

+-

+-                    handleMouseExit (leaveEvent->x, leaveEvent->y, getEventTime (leaveEvent->time));

+-

+-                    entered = false;

+-                }

+-

+-                break;

+-            }

+-

+-            case FocusIn:

+-            {

+-                isActiveApplication = true;

+-                handleFocusGain();

+-                break;

+-            }

+-

+-            case FocusOut:

+-            {

+-                isActiveApplication = false;

+-                handleFocusLoss();

+-                break;

+-            }

+-

+-            case Expose:

+-            {

+-                // Batch together all pending expose events

+-                XExposeEvent* exposeEvent = (XExposeEvent*) &event->xexpose;

+-                XEvent nextEvent;

+-

+-                repaint (exposeEvent->x, exposeEvent->y,

+-                         exposeEvent->width, exposeEvent->height);

+-

+-                while (XEventsQueued (display, QueuedAfterFlush) > 0)

+-                {

+-                    XPeekEvent (display, (XEvent*) &nextEvent);

+-                    if (nextEvent.type != Expose || nextEvent.xany.window != event->xany.window)

+-                        break;

+-

+-                    XNextEvent (display, (XEvent*)&nextEvent);

+-                    XExposeEvent* nextExposeEvent = (XExposeEvent*)(&nextEvent.xexpose);

+-                    repaint (nextExposeEvent->x, nextExposeEvent->y,

+-                             nextExposeEvent->width, nextExposeEvent->height);

+-                }

+-

+-                break;

+-            }

+-

+-            case CreateNotify:

+-            case DestroyNotify:

+-                // Think we can ignore these

+-                break;

+-

+-            case CirculateNotify:

+-                break;

+-

+-            case ConfigureNotify:

+-            case ReparentNotify:

+-            case GravityNotify:

+-                updateBounds();

+-                break;

+-

+-            case MapNotify:

+-                mapped = true;

+-                handleBroughtToFront();

+-                break;

+-

+-            case UnmapNotify:

+-                mapped = false;

+-                break;

+-

+-            case MappingNotify:

+-            {

+-                XMappingEvent* mappingEvent = (XMappingEvent*) &event->xmapping;

+-

+-                if (mappingEvent->request != MappingPointer)

+-                {

+-                    // Deal with modifier/keyboard mapping

+-                    XRefreshKeyboardMapping (mappingEvent);

+-                    getModifierMapping();

+-                }

+-

+-                break;

+-            }

+-

+-            case ClientMessage:

+-            {

+-                XClientMessageEvent* clientMsg = (XClientMessageEvent*) &event->xclient;

+-

+-                if (clientMsg->message_type == wm_Protocols && clientMsg->format == 32)

+-                {

+-                    const Atom atom = (Atom) clientMsg->data.l[0];

+-

+-                    if (atom == wm_ProtocolList [TAKE_FOCUS])

+-                    {

+-                        XWindowAttributes atts;

+-

+-                        if (clientMsg->window != 0

+-                             && XGetWindowAttributes (display, clientMsg->window, &atts))

+-                        {

+-                            if (atts.map_state == IsViewable)

+-                                XSetInputFocus (display, clientMsg->window, RevertToParent, clientMsg->data.l[1]);

+-                        }

+-                    }

+-                    else if (atom == wm_ProtocolList [DELETE_WINDOW])

+-                    {

+-                        handleUserClosingWindow();

+-                    }

+-                }

+-                else if (clientMsg->message_type == repaintId)

+-                {

+-                    // Get rid of all pending repaint events

+-                    XEvent nextEvent;

+-

+-                    while (XEventsQueued (display, QueuedAfterFlush) > 0)

+-                    {

+-                        XPeekEvent (display, &nextEvent);

+-                        if (nextEvent.xany.type != ClientMessage ||

+-                            nextEvent.xany.window != event->xany.window)

+-                            break;

+-

+-                        XClientMessageEvent* nextClientMsg = (XClientMessageEvent*) (&nextEvent.xclient);

+-                        if (nextClientMsg->message_type != repaintId)

+-                            break;

+-

+-                        XNextEvent (display, &nextEvent);

+-                    }

+-

+-                    static bool reentrancyCheck = false;

+-                    if (! reentrancyCheck)

+-                    {

+-                        reentrancyCheck = true;

+-

+-                        int ox, oy, ow, oh;

+-                        getBounds (ox, oy, ow, oh);

+-                        repaint (0, 0, ow, oh);

+-                        performPendingRepaints();

+-

+-                        reentrancyCheck = false;

+-                    }

+-                }

+-

+-                break;

+-            }

+-

+-            case SelectionClear:

+-            case SelectionNotify:

+-            case SelectionRequest:

+-                // We shouldn't get these on normal windows

+-                break;

+-

+-            default:

+-                break;

+-        }

+-    }

+-

+-    void showMouseCursor (Cursor cursor)

+-    {

+-        XDefineCursor (display, windowH, cursor);

+-    }

+-

+-    //==============================================================================

+-    juce_UseDebuggingNewOperator

+-

+-    bool dontRepaint;

+-

+-private:

+-    //==============================================================================

+-    class LinuxRepaintManager : public RepaintManager

+-    {

+-    public:

+-        LinuxRepaintManager (LinuxComponentPeer* const peer_,

+-                             Component* const component,

+-                             const int timeBeforeReleasingImage)

+-            : RepaintManager (component, timeBeforeReleasingImage),

+-              peer (peer_)

+-        {

+-        }

+-

+-        Image* createNewImage (int w, int h)

+-        {

+-            return new XBitmapImage (Image::RGB, w, h, false);

+-        }

+-

+-        void repaintNow (const RectangleList& areasToPaint)

+-        {

+-            peer->clearMaskedRegion();

+-

+-            renderCacheAreasNeedingRepaint();

+-

+-            int x, y;

+-            XBitmapImage* const paintingBuffer = (XBitmapImage*) getImage (x, y);

+-

+-            if (paintingBuffer != 0)

+-            {

+-                const RectangleList* repaintRegion = &areasToPaint;

+-                RectangleList temp;

+-

+-                if (! peer->maskedRegion.isEmpty())

+-                {

+-                    temp = areasToPaint;

+-                    temp.subtract (peer->maskedRegion);

+-                    repaintRegion = &temp;

+-                }

+-

+-                for (RectangleList::Iterator i (*repaintRegion); i.next();)

+-                {

+-                    const Rectangle& r = i.getRectangle();

+-

+-                    paintingBuffer->blitToWindow (peer->windowH,

+-                                                  r.getX(), r.getY(), r.getWidth(), r.getHeight(),

+-                                                  r.getX() - x, r.getY() - y);

+-                }

+-            }

+-        }

+-

+-    private:

+-        LinuxComponentPeer* const peer;

+-

+-        LinuxRepaintManager (const LinuxRepaintManager&);

+-        const LinuxRepaintManager& operator= (const LinuxRepaintManager&);

+-    };

+-

+-    LinuxRepaintManager* repainter;

+-

+-    friend class LinuxRepaintManager;

+-    Window windowH;

+-    int wx, wy, ww, wh;

+-    bool fullScreen, entered, mapped;

+-    BorderSize windowBorder;

+-

+-    //==============================================================================

+-    void removeWindowDecorations (Window wndH)

+-    {

+-        Atom hints = XInternAtom (display, "_MOTIF_WM_HINTS", True);

+-

+-        if (hints != None)

+-        {

+-            typedef struct

+-            {

+-                CARD32 flags;

+-                CARD32 functions;

+-                CARD32 decorations;

+-                INT32 input_mode;

+-                CARD32 status;

+-            } MotifWmHints;

+-

+-            MotifWmHints motifHints;

+-            motifHints.flags = 2; /* MWM_HINTS_DECORATIONS */

+-            motifHints.decorations = 0;

+-

+-            XChangeProperty (display, wndH, hints, hints, 32, PropModeReplace,

+-                             (unsigned char*) &motifHints, 4);

+-        }

+-

+-        hints = XInternAtom (display, "_WIN_HINTS", True);

+-

+-        if (hints != None)

+-        {

+-            long gnomeHints = 0;

+-

+-            XChangeProperty (display, wndH, hints, hints, 32, PropModeReplace,

+-                             (unsigned char*) &gnomeHints, 1);

+-        }

+-

+-        hints = XInternAtom (display, "KWM_WIN_DECORATION", True);

+-

+-        if (hints != None)

+-        {

+-            long kwmHints = 2; /*KDE_tinyDecoration*/

+-

+-            XChangeProperty (display, wndH, hints, hints, 32, PropModeReplace,

+-                             (unsigned char*) &kwmHints, 1);

+-        }

+-

+-        hints = XInternAtom (display, "_NET_WM_WINDOW_TYPE", True);

+-

+-        if (hints != None)

+-        {

+-            Atom netHints [2];

+-            netHints[0] = XInternAtom (display, "_KDE_NET_WM_WINDOW_TYPE_OVERRIDE", True);

+-

+-            if ((styleFlags & windowIsTemporary) != 0)

+-                netHints[1] = XInternAtom (display, "_NET_WM_WINDOW_TYPE_MENU", True);

+-            else

+-                netHints[1] = XInternAtom (display, "_NET_WM_WINDOW_TYPE_NORMAL", True);

+-

+-            XChangeProperty (display, wndH, hints, XA_ATOM, 32, PropModeReplace,

+-                             (unsigned char*) &netHints, 2);

+-        }

+-    }

+-

+-    void addWindowButtons (Window wndH)

+-    {

+-        Atom hints = XInternAtom (display, "_MOTIF_WM_HINTS", True);

+-

+-        if (hints != None)

+-        {

+-            typedef struct

+-            {

+-                CARD32 flags;

+-                CARD32 functions;

+-                CARD32 decorations;

+-                INT32 input_mode;

+-                CARD32 status;

+-            } MotifWmHints;

+-

+-            MotifWmHints motifHints;

+-

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

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

+-

+-            motifHints.functions = 4 /* MWM_FUNC_MOVE */;

+-

+-            if ((styleFlags & windowHasCloseButton) != 0)

+-                motifHints.functions |= 32; /* MWM_FUNC_CLOSE */

+-

+-            if ((styleFlags & windowHasMinimiseButton) != 0)

+-            {

+-                motifHints.functions |= 8; /* MWM_FUNC_MINIMIZE */

+-                motifHints.decorations |= 0x20; /* MWM_DECOR_MINIMIZE */

+-            }

+-

+-            if ((styleFlags & windowHasMaximiseButton) != 0)

+-            {

+-                motifHints.functions |= 0x10; /* MWM_FUNC_MAXIMIZE */

+-                motifHints.decorations |= 0x40; /* MWM_DECOR_MAXIMIZE */

+-            }

+-

+-            if ((styleFlags & windowIsResizable) != 0)

+-            {

+-                motifHints.functions |= 2; /* MWM_FUNC_RESIZE */

+-                motifHints.decorations |= 0x4; /* MWM_DECOR_RESIZEH */

+-            }

+-

+-            XChangeProperty (display, wndH, hints, hints, 32, PropModeReplace,

+-                             (unsigned char*) &motifHints, 4);

+-        }

+-

+-        hints = XInternAtom (display, "_NET_WM_ALLOWED_ACTIONS", True);

+-

+-        if (hints != None)

+-        {

+-            Atom netHints [6];

+-            int num = 0;

+-

+-            netHints [num++] = XInternAtom (display, "_NET_WM_ACTION_RESIZE", (styleFlags & windowIsResizable) ? True : False);

+-            netHints [num++] = XInternAtom (display, "_NET_WM_ACTION_FULLSCREEN", (styleFlags & windowHasMaximiseButton) ? True : False);

+-            netHints [num++] = XInternAtom (display, "_NET_WM_ACTION_MINIMIZE", (styleFlags & windowHasMinimiseButton) ? True : False);

+-            netHints [num++] = XInternAtom (display, "_NET_WM_ACTION_CLOSE", (styleFlags & windowHasCloseButton) ? True : False);

+-

+-            XChangeProperty (display, wndH, hints, XA_ATOM, 32, PropModeReplace,

+-                             (unsigned char*) &netHints, num);

+-        }

+-    }

+-

+-    static void* createWindowCallback (void* userData)

+-    {

+-        ((LinuxComponentPeer*) userData)->createWindow();

+-        return 0;

+-    }

+-

+-    void createWindow()

+-    {

+-        static bool atomsInitialised = false;

+-

+-        if (! atomsInitialised)

+-        {

+-            atomsInitialised = true;

+-

+-            wm_Protocols                      = XInternAtom (display, "WM_PROTOCOLS", 1);

+-            wm_ProtocolList [TAKE_FOCUS]      = XInternAtom (display, "WM_TAKE_FOCUS", 1);

+-            wm_ProtocolList [DELETE_WINDOW]   = XInternAtom (display, "WM_DELETE_WINDOW", 1);

+-            wm_ChangeState                    = XInternAtom (display, "WM_CHANGE_STATE", 1);

+-            wm_State                          = XInternAtom (display, "WM_STATE", 1);

+-            wm_ActiveWin                      = XInternAtom (display, "_NET_ACTIVE_WINDOW", False);

+-            repaintId                         = XInternAtom (display, "JUCERepaintAtom", 1);

+-        }

+-

+-        // Get defaults for various properties

+-        const int screen = DefaultScreen (display);

+-        Window root = RootWindow (display, screen);

+-

+-        // Attempt to create a 24-bit window on the default screen.  If this is not

+-        // possible then exit

+-        XVisualInfo desiredVisual;

+-        desiredVisual.screen = screen;

+-        desiredVisual.depth = 24;

+-

+-        int numVisuals;

+-        XVisualInfo* visuals = XGetVisualInfo (display, VisualScreenMask | VisualDepthMask,

+-                                               &desiredVisual, &numVisuals);

+-

+-        if (numVisuals < 1 || visuals == 0)

+-        {

+-            Logger::outputDebugString ("ERROR: System doesn't support 24-bit RGB display.\n");

+-            Process::terminate();

+-        }

+-

+-        // Just choose the first one

+-        Visual* visual = visuals[0].visual;

+-        const int depth = visuals[0].depth;

+-        XFree (visuals);

+-

+-        // Set up the window attributes

+-        XSetWindowAttributes swa;

+-        swa.border_pixel = 0;

+-        swa.colormap = DefaultColormap (display, screen);

+-        swa.override_redirect = getComponent()->isAlwaysOnTop() ? True : False;

+-        swa.event_mask = eventMask;

+-

+-        Window wndH = XCreateWindow (display, root,

+-                                     0, 0, 1, 1, 0,

+-                                     depth, InputOutput, visual,

+-                                     CWBorderPixel | CWColormap | CWEventMask | CWOverrideRedirect,

+-                                     &swa);

+-

+-        XGrabButton (display, AnyButton, AnyModifier, wndH, False,

+-                     ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask,

+-                     GrabModeAsync, GrabModeAsync, None, None);

+-

+-        // Set the window context to identify the window handle object

+-        if (XSaveContext (display, (XID) wndH, improbableNumber, (XPointer) this))

+-        {

+-            // Failed

+-            jassertfalse

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

+-            XDestroyWindow (display, wndH);

+-            wndH = 0;

+-        }

+-

+-        // Set window manager hints

+-        XWMHints* wmHints = XAllocWMHints();

+-        wmHints->flags = InputHint | StateHint;

+-        wmHints->input = True;      // Locally active input model

+-        wmHints->initial_state = NormalState;

+-        XSetWMHints (display, wndH, wmHints);

+-        XFree (wmHints);

+-

+-        if ((styleFlags & juce_windowIsSemiTransparentFlag) != 0)

+-        {

+-            //xxx

+-            jassertfalse

+-        }

+-

+-        if ((styleFlags & windowAppearsOnTaskbar) != 0)

+-        {

+-            //xxx

+-        }

+-

+-        if ((styleFlags & windowHasTitleBar) == 0)

+-            removeWindowDecorations (wndH);

+-        else

+-            addWindowButtons (wndH);

+-

+-        XSetTransientForHint (display, wndH, RootWindow (display, DefaultScreen (display)));

+-

+-        // Set window manager protocols

+-        XChangeProperty (display, wndH, wm_Protocols, XA_ATOM, 32, PropModeReplace,

+-                         (unsigned char*) wm_ProtocolList, 2);

+-

+-        // Set window name

+-        setWindowTitle (wndH, getComponent()->getName());

+-

+-        // Initialise the pointer and keyboard mapping

+-        // This is not the same as the logical pointer mapping the X server uses:

+-        // we don't mess with this.

+-        static bool mappingInitialised = false;

+-

+-        if (! mappingInitialised)

+-        {

+-            mappingInitialised = true;

+-

+-            const int numButtons = XGetPointerMapping (display, 0, 0);

+-

+-            if (numButtons == 2)

+-            {

+-                pointerMap[0] = LeftButton;

+-                pointerMap[1] = RightButton;

+-                pointerMap[2] = pointerMap[3] = pointerMap[4] = NoButton;

+-            }

+-            else if (numButtons >= 3)

+-            {

+-                pointerMap[0] = LeftButton;

+-                pointerMap[1] = MiddleButton;

+-                pointerMap[2] = RightButton;

+-

+-                if (numButtons >= 5)

+-                {

+-                    pointerMap[3] = WheelUp;

+-                    pointerMap[4] = WheelDown;

+-                }

+-            }

+-

+-            getModifierMapping();

+-        }

+-

+-        windowH = wndH;

+-    }

+-

+-    static void* destroyWindowCallback (void* userData)

+-    {

+-        Window windowH = (Window) userData;

+-

+-        XPointer handlePointer;

+-        if (! XFindContext (display, (XID) windowH, improbableNumber, &handlePointer))

+-            XDeleteContext (display, (XID) windowH, improbableNumber);

+-

+-        XDestroyWindow (display, windowH);

+-

+-        // Wait for it to complete and then remove any events for this

+-        // window from the event queue.

+-        XSync (display, false);

+-

+-        XEvent event;

+-        while (XCheckWindowEvent (display, windowH, eventMask, &event) == True)

+-        {}

+-

+-        return 0;

+-    }

+-

+-    static int64 getEventTime (::Time t)

+-    {

+-        static int64 eventTimeOffset = 0x12345678;

+-        const int64 thisMessageTime = t;

+-

+-        if (eventTimeOffset == 0x12345678)

+-            eventTimeOffset = Time::currentTimeMillis() - thisMessageTime;

+-

+-        return eventTimeOffset + thisMessageTime;

+-    }

+-

+-    static void setWindowTitle (Window xwin, const char* const title)

+-    {

+-        XTextProperty nameProperty;

+-        char* strings[] = { (char*) title };

+-

+-        if (XStringListToTextProperty (strings, 1, &nameProperty))

+-        {

+-            XSetWMName (display, xwin, &nameProperty);

+-            XSetWMIconName (display, xwin, &nameProperty);

+-        }

+-    }

+-

+-    void updateBorderSize()

+-    {

+-        if ((styleFlags & windowHasTitleBar) == 0)

+-        {

+-            windowBorder = BorderSize (0);

+-        }

+-        else if (windowBorder.getTopAndBottom() == 0 && windowBorder.getLeftAndRight() == 0)

+-        {

+-            Atom hints = XInternAtom (display, "_NET_FRAME_EXTENTS", True);

+-

+-            if (hints != None)

+-            {

+-                CARD32* sizes = 0;

+-                unsigned long nitems, bytesLeft;

+-                Atom actualType;

+-                int actualFormat;

+-

+-                if (XGetWindowProperty (display, windowH, hints, 0, 4, False,

+-                                        XA_CARDINAL, &actualType, &actualFormat, &nitems, &bytesLeft,

+-                                        (unsigned char**) &sizes) == Success)

+-                {

+-                    if (actualFormat == 32)

+-                        windowBorder = BorderSize ((int) sizes[2], (int) sizes[0],

+-                                                   (int) sizes[3], (int) sizes[1]);

+-

+-                    XFree (sizes);

+-                }

+-            }

+-        }

+-    }

+-

+-    void updateBounds()

+-    {

+-        jassert (windowH != 0);

+-        if (windowH != 0)

+-        {

+-            Window root, child;

+-            unsigned int bw, depth;

+-

+-            if (! XGetGeometry (display, (Drawable) windowH, &root,

+-                                &wx, &wy, (unsigned int*) &ww, (unsigned int*) &wh,

+-                                &bw, &depth))

+-            {

+-                wx = wy = ww = wh = 0;

+-            }

+-            else if (! XTranslateCoordinates (display, windowH, root, 0, 0, &wx, &wy, &child))

+-            {

+-                wx = wy = 0;

+-            }

+-

+-            updateBorderSize();

+-            handleMovedOrResized();

+-        }

+-    }

+-};

+-

+-//==============================================================================

+-ComponentPeer* Component::createNewPeer (int styleFlags, void* /*nativeWindowToAttachTo*/)

+-{

+-    return new LinuxComponentPeer (this, styleFlags);

+-}

+-

+-

+-//==============================================================================

+-// (this callback is hooked up in the messaging code)

+-void juce_windowMessageReceive (XEvent* event)

+-{

+-    if (event->xany.window != None)

+-    {

+-        // Check if the event is for one of our windows

+-        LinuxComponentPeer* peer = 0;

+-

+-        if (! XFindContext (display, (XID) event->xany.window, improbableNumber, (XPointer*) &peer))

+-        {

+-            if (peer != 0 && peer->isValidMessageListener())

+-                peer->handleWindowMessage (event);

+-        }

+-    }

+-    else

+-    {

+-        switch (event->xany.type)

+-        {

+-            case KeymapNotify:

+-            {

+-                const XKeymapEvent* const keymapEvent = (const XKeymapEvent*) &event->xkeymap;

+-                memcpy (keyStates, keymapEvent->key_vector, 32);

+-                break;

+-            }

+-

+-            default:

+-                break;

+-        }

+-    }

+-}

+-

+-//==============================================================================

+-void juce_updateMultiMonitorInfo (Array <Rectangle>& monitorCoords, const bool clipToWorkArea)

+-{

+-#if JUCE_USE_XINERAMA

+-    int major_opcode, first_event, first_error;

+-

+-    if (XQueryExtension (display, "XINERAMA", &major_opcode, &first_event, &first_error)

+-         && XineramaIsActive (display))

+-    {

+-        int numMonitors = 0;

+-        XineramaScreenInfo* const screens = XineramaQueryScreens (display, &numMonitors);

+-

+-        if (screens != 0)

+-        {

+-            for (int i = numMonitors; --i >= 0;)

+-            {

+-                int index = screens[i].screen_number;

+-

+-                if (index >= 0)

+-                {

+-                    while (monitorCoords.size() < index)

+-                        monitorCoords.add (Rectangle (0, 0, 0, 0));

+-

+-                    monitorCoords.set (index, Rectangle (screens[i].x_org,

+-                                                         screens[i].y_org,

+-                                                         screens[i].width,

+-                                                         screens[i].height));

+-                }

+-            }

+-

+-            XFree (screens);

+-        }

+-    }

+-

+-    if (monitorCoords.size() == 0)

+-#endif

+-    {

+-        monitorCoords.add (Rectangle (0, 0,

+-                                      DisplayWidth (display, DefaultScreen (display)),

+-                                      DisplayHeight (display, DefaultScreen (display))));

+-    }

+-}

+-

+-//==============================================================================

+-bool Desktop::canUseSemiTransparentWindows()

+-{

+-    return false;

+-}

+-

+-void Desktop::getMousePosition (int& x, int& y)

+-{

+-    int mouseMods;

+-    getMousePos (x, y, mouseMods);

+-}

+-

+-void Desktop::setMousePosition (int x, int y)

+-{

+-    Window root = RootWindow (display, DefaultScreen (display));

+-    XWarpPointer (display, None, root, 0, 0, 0, 0, x, y);

+-}

+-

+-

+-//==============================================================================

+-void* juce_createMouseCursorFromImage (const Image& image, int hotspotX, int hotspotY)

+-{

+-    Window root = RootWindow (display, DefaultScreen (display));

+-    const unsigned int imageW = image.getWidth();

+-    const unsigned int imageH = image.getHeight();

+-    unsigned int cursorW, cursorH;

+-

+-    if (! XQueryBestCursor (display, root, imageW, imageH, &cursorW, &cursorH))

+-        return 0;

+-

+-    Image im (Image::ARGB, cursorW, cursorH, true);

+-    Graphics g (im);

+-

+-    if (imageW > cursorW || imageH > cursorH)

+-    {

+-        hotspotX = (hotspotX * cursorW) / imageW;

+-        hotspotY = (hotspotY * cursorH) / imageH;

+-

+-        g.drawImageWithin (&image, 0, 0, imageW, imageH,

+-                           Justification::topLeft,

+-                           false, false);

+-    }

+-    else

+-    {

+-        g.drawImageAt (&image, 0, 0);

+-    }

+-

+-    const int stride = (cursorW + 7) >> 3;

+-    unsigned char* const maskPlane = (unsigned char*)juce_calloc (stride*cursorH);

+-    unsigned char* const sourcePlane = (unsigned char*)juce_calloc (stride*cursorH);

+-

+-    bool msbfirst = (BitmapBitOrder (display) == MSBFirst);

+-

+-    for (int y = cursorH; --y >= 0;)

+-    {

+-        for (int x = cursorW; --x >= 0;)

+-        {

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

+-            const int offset = y * stride + (x >> 3);

+-

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

+-

+-            if (c.getAlpha() >= 128)

+-                maskPlane[offset] |= mask;

+-

+-            if (c.getBrightness() >= 0.5f)

+-                sourcePlane[offset] |= mask;

+-        }

+-    }

+-

+-    Pixmap sourcePixmap = XCreatePixmapFromBitmapData (display, root, (char*)sourcePlane, cursorW, cursorH, 0xffff, 0, 1);

+-    Pixmap maskPixmap = XCreatePixmapFromBitmapData (display, root, (char*)maskPlane, cursorW, cursorH, 0xffff, 0, 1);

+-

+-    juce_free (maskPlane);

+-    juce_free (sourcePlane);

+-

+-    XColor white, black;

+-    black.red = black.green = black.blue = 0;

+-    white.red = white.green = white.blue = 0xffff;

+-

+-    void* result = (void*) XCreatePixmapCursor (display, sourcePixmap, maskPixmap, &white, &black, hotspotX, hotspotY);

+-

+-    XFreePixmap (display, sourcePixmap);

+-    XFreePixmap (display, maskPixmap);

+-

+-    return result;

+-}

+-

+-void juce_deleteMouseCursor (void* cursorHandle, bool)

+-{

+-    if (cursorHandle != None)

+-        XFreeCursor (display, (Cursor)cursorHandle);

+-}

+-

+-void* juce_createStandardMouseCursor (MouseCursor::StandardCursorType type)

+-{

+-    unsigned int shape;

+-

+-    switch (type)

+-    {

+-        case MouseCursor::NoCursor:

+-        {

+-            void* invisibleCursor;

+-

+-            Image im (Image::ARGB, 16, 16, true);

+-            invisibleCursor = juce_createMouseCursorFromImage (im, 0, 0);

+-

+-            return invisibleCursor;

+-        }

+-

+-        case MouseCursor::NormalCursor:

+-            return (void*) None; // Use parent cursor

+-

+-        case MouseCursor::DraggingHandCursor:

+-        {

+-            void* dragHandCursor;

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

+-              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,

+-              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 };

+-            const int dragHandDataSize = 99;

+-

+-            Image* im = ImageFileFormat::loadFrom ((const char*) dragHandData, dragHandDataSize);

+-            dragHandCursor = juce_createMouseCursorFromImage (*im, 8, 7);

+-            delete im;

+-

+-            return dragHandCursor;

+-        }

+-

+-        case MouseCursor::CopyingCursor:

+-        {

+-            void* copyCursor;

+-

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

+-              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,

+-              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,

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

+-            const int copyCursorSize = 119;

+-

+-            Image* im = ImageFileFormat::loadFrom ((const char*)copyCursorData, copyCursorSize);

+-            copyCursor = juce_createMouseCursorFromImage (*im, 1, 3);

+-            delete im;

+-

+-            return copyCursor;

+-        }

+-

+-        case MouseCursor::WaitCursor:

+-            shape = XC_watch;

+-            break;

+-

+-        case MouseCursor::IBeamCursor:

+-            shape = XC_xterm;

+-            break;

+-

+-        case MouseCursor::PointingHandCursor:

+-            shape = XC_hand2;

+-            break;

+-

+-        case MouseCursor::LeftRightResizeCursor:

+-            shape = XC_sb_h_double_arrow;

+-            break;

+-

+-        case MouseCursor::UpDownResizeCursor:

+-            shape = XC_sb_v_double_arrow;

+-            break;

+-

+-        case MouseCursor::UpDownLeftRightResizeCursor:

+-            shape = XC_fleur;

+-            break;

+-

+-        case MouseCursor::TopEdgeResizeCursor:

+-            shape = XC_top_side;

+-            break;

+-

+-        case MouseCursor::BottomEdgeResizeCursor:

+-            shape = XC_bottom_side;

+-            break;

+-

+-        case MouseCursor::LeftEdgeResizeCursor:

+-            shape = XC_left_side;

+-            break;

+-

+-        case MouseCursor::RightEdgeResizeCursor:

+-            shape = XC_right_side;

+-            break;

+-

+-        case MouseCursor::TopLeftCornerResizeCursor:

+-            shape = XC_top_left_corner;

+-            break;

+-

+-        case MouseCursor::TopRightCornerResizeCursor:

+-            shape = XC_top_right_corner;

+-            break;

+-

+-        case MouseCursor::BottomLeftCornerResizeCursor:

+-            shape = XC_bottom_left_corner;

+-            break;

+-

+-        case MouseCursor::BottomRightCornerResizeCursor:

+-            shape = XC_bottom_right_corner;

+-            break;

+-

+-        case MouseCursor::CrosshairCursor:

+-            shape = XC_crosshair;

+-            break;

+-

+-        default:

+-            return (void*) None; // Use parent cursor

+-    }

+-

+-    return (void*) XCreateFontCursor (display, shape);

+-}

+-

+-void MouseCursor::showInWindow (ComponentPeer* peer) const

+-{

+-    LinuxComponentPeer* const lp = dynamic_cast <LinuxComponentPeer*> (peer);

+-

+-    if (lp != 0)

+-        lp->showMouseCursor ((Cursor) getHandle());

+-}

+-

+-void MouseCursor::showInAllWindows() const

+-{

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

+-        showInWindow (ComponentPeer::getPeer (i));

+-}

+-

+-//==============================================================================

+-Image* juce_createIconForFile (const File& file)

+-{

+-    return 0;

+-}

+-

+-

+-//==============================================================================

+-#if JUCE_OPENGL

+-

+-struct OpenGLContextInfo

+-{

+-    Window embeddedWindow;

+-    GLXContext renderContext;

+-};

+-

+-void* juce_createOpenGLContext (OpenGLComponent* component, void* sharedContext)

+-{

+-    XSync (display, False);

+-    jassert (component != 0);

+-

+-    if (component == 0)

+-        return 0;

+-

+-    LinuxComponentPeer* const peer

+-        = dynamic_cast <LinuxComponentPeer*> (component->getTopLevelComponent()->getPeer());

+-

+-    if (peer == 0)

+-        return 0;

+-

+-    GLint attribList[] =

+-    {

+-        GLX_RGBA,

+-        GLX_DOUBLEBUFFER,

+-        GLX_RED_SIZE, 8,

+-        GLX_GREEN_SIZE, 8,

+-        GLX_BLUE_SIZE, 8,

+-        GLX_ALPHA_SIZE, 8,

+-        GLX_DEPTH_SIZE, 8,

+-        None

+-    };

+-

+-    XVisualInfo* const bestVisual = glXChooseVisual (display, DefaultScreen (display), attribList);

+-

+-    if (bestVisual == 0)

+-        return 0;

+-

+-    OpenGLContextInfo* const oc = new OpenGLContextInfo();

+-

+-    oc->renderContext = glXCreateContext (display, bestVisual,

+-                                          (sharedContext != 0) ? ((OpenGLContextInfo*) sharedContext)->renderContext

+-                                                               : 0,

+-                                          GL_TRUE);

+-

+-    Window windowH = (Window) peer->getNativeHandle();

+-

+-    Colormap colourMap = XCreateColormap (display, windowH, bestVisual->visual, AllocNone);

+-    XSetWindowAttributes swa;

+-    swa.colormap = colourMap;

+-    swa.border_pixel = 0;

+-    swa.event_mask = StructureNotifyMask;

+-

+-    oc->embeddedWindow = XCreateWindow (display, windowH,

+-                                        0, 0, 1, 1, 0,

+-                                        bestVisual->depth,

+-                                        InputOutput,

+-                                        bestVisual->visual,

+-                                        CWBorderPixel | CWColormap | CWEventMask,

+-                                        &swa);

+-

+-    XMapWindow (display, oc->embeddedWindow);

+-    XFreeColormap (display, colourMap);

+-

+-    XFree (bestVisual);

+-    XSync (display, False);

+-

+-    return oc;

+-}

+-

+-void juce_updateOpenGLWindowPos (void* context, Component* owner, Component* topComp)

+-{

+-    jassert (context != 0);

+-    OpenGLContextInfo* const oc = (OpenGLContextInfo*) context;

+-

+-    XMoveResizeWindow (display, oc->embeddedWindow,

+-                       owner->getScreenX() - topComp->getScreenX(),

+-                       owner->getScreenY() - topComp->getScreenY(),

+-                       jmax (1, owner->getWidth()),

+-                       jmax (1, owner->getHeight()));

+-}

+-

+-void juce_deleteOpenGLContext (void* context)

+-{

+-    OpenGLContextInfo* const oc = (OpenGLContextInfo*) context;

+-

+-    if (oc != 0)

+-    {

+-        glXDestroyContext (display, oc->renderContext);

+-

+-        XUnmapWindow (display, oc->embeddedWindow);

+-        XDestroyWindow (display, oc->embeddedWindow);

+-

+-        delete oc;

+-    }

+-}

+-

+-bool juce_makeOpenGLContextCurrent (void* context)

+-{

+-    OpenGLContextInfo* const oc = (OpenGLContextInfo*) context;

+-

+-    if (oc != 0)

+-        return glXMakeCurrent (display, oc->embeddedWindow, oc->renderContext)

+-                && XSync (display, False);

+-    else

+-        return glXMakeCurrent (display, None, 0);

+-}

+-

+-void juce_swapOpenGLBuffers (void* context)

+-{

+-    OpenGLContextInfo* const oc = (OpenGLContextInfo*) context;

+-

+-    if (oc != 0)

+-        glXSwapBuffers (display, oc->embeddedWindow);

+-}

+-

+-void juce_repaintOpenGLWindow (void* context)

+-{

+-}

+-

+-#endif

+-

+-

+-//==============================================================================

+-static void initClipboard (Window root, Atom* cutBuffers)

+-{

+-    static bool init = false;

+-

+-    if (! init)

+-    {

+-        init = true;

+-

+-        // Make sure all cut buffers exist before use

+-        for (int i = 0; i < 8; i++)

+-        {

+-            XChangeProperty (display, root, cutBuffers[i],

+-                             XA_STRING, 8, PropModeAppend, NULL, 0);

+-        }

+-    }

+-}

+-

+-// Clipboard implemented currently using cut buffers

+-// rather than the more powerful selection method

+-void SystemClipboard::copyTextToClipboard (const String& clipText)

+-{

+-    Window root = RootWindow (display, DefaultScreen (display));

+-    Atom cutBuffers[8] = { XA_CUT_BUFFER0, XA_CUT_BUFFER1, XA_CUT_BUFFER2, XA_CUT_BUFFER3,

+-                           XA_CUT_BUFFER4, XA_CUT_BUFFER5, XA_CUT_BUFFER6, XA_CUT_BUFFER7 };

+-

+-    initClipboard (root, cutBuffers);

+-

+-    XRotateWindowProperties (display, root, cutBuffers, 8, 1);

+-    XChangeProperty (display, root, cutBuffers[0],

+-                     XA_STRING, 8, PropModeReplace, (const unsigned char*)((const char*)clipText),

+-                     clipText.length());

+-}

+-

+-const String SystemClipboard::getTextFromClipboard()

+-{

+-    char* clipData;

+-    const int bufSize = 64;  // in words

+-    int actualFormat;

+-    int byteOffset = 0;

+-    unsigned long bytesLeft, nitems;

+-    Atom actualType;

+-    String returnData;

+-

+-    Window root = RootWindow (display, DefaultScreen (display));

+-

+-    Atom cutBuffers[8] = { XA_CUT_BUFFER0, XA_CUT_BUFFER1, XA_CUT_BUFFER2, XA_CUT_BUFFER3,

+-                           XA_CUT_BUFFER4, XA_CUT_BUFFER5, XA_CUT_BUFFER6, XA_CUT_BUFFER7 };

+-

+-    initClipboard (root, cutBuffers);

+-

+-    do

+-    {

+-        if (XGetWindowProperty (display, root, cutBuffers[0], byteOffset >> 2, bufSize,

+-                                False, XA_STRING, &actualType, &actualFormat, &nitems, &bytesLeft,

+-                                (unsigned char**) &clipData) != Success

+-            || actualType != XA_STRING

+-            || actualFormat != 8)

+-            return String();

+-

+-        byteOffset += nitems;

+-        returnData += String(clipData, nitems);

+-        XFree (clipData);

+-    }

+-    while (bytesLeft);

+-

+-    return returnData;

+-}

+-

+-//==============================================================================

+-bool DragAndDropContainer::performExternalDragDropOfFiles (const StringArray& files, const bool canMoveFiles)

+-{

+-    jassertfalse    // not implemented!

+-    return false;

+-}

+-

+-bool DragAndDropContainer::performExternalDragDropOfText (const String& text)

+-{

+-    jassertfalse    // not implemented!

+-    return false;

+-}

+-

+-

+-//==============================================================================

+-void PlatformUtilities::beep()

+-{

+-    //xxx

+-}

+-

+-

+-//==============================================================================

+-bool AlertWindow::showNativeDialogBox (const String& title,

+-                                       const String& bodyText,

+-                                       bool isOkCancel)

+-{

+-    // xxx this is supposed to pop up an alert!

+-    Logger::outputDebugString (title + ": " + bodyText);

+-    return true;

+-}

+-

+-//==============================================================================

+-const int KeyPress::spaceKey            = XK_space & 0xff;

+-const int KeyPress::returnKey           = XK_Return & 0xff;

+-const int KeyPress::escapeKey           = XK_Escape & 0xff;

+-const int KeyPress::backspaceKey        = XK_BackSpace & 0xff;

+-const int KeyPress::leftKey             = (XK_Left & 0xff) | nonAsciiModifier;

+-const int KeyPress::rightKey            = (XK_Right & 0xff) | nonAsciiModifier;

+-const int KeyPress::upKey               = (XK_Up & 0xff) | nonAsciiModifier;

+-const int KeyPress::downKey             = (XK_Down & 0xff) | nonAsciiModifier;

+-const int KeyPress::pageUpKey           = (XK_Page_Up & 0xff) | nonAsciiModifier;

+-const int KeyPress::pageDownKey         = (XK_Page_Down & 0xff) | nonAsciiModifier;

+-const int KeyPress::endKey              = (XK_End & 0xff) | nonAsciiModifier;

+-const int KeyPress::homeKey             = (XK_Home & 0xff) | nonAsciiModifier;

+-const int KeyPress::insertKey           = (XK_Insert & 0xff) | nonAsciiModifier;

+-const int KeyPress::deleteKey           = (XK_Delete & 0xff) | nonAsciiModifier;

+-const int KeyPress::tabKey              = XK_Tab & 0xff;

+-const int KeyPress::F1Key               = (XK_F1 & 0xff) | nonAsciiModifier;

+-const int KeyPress::F2Key               = (XK_F2 & 0xff) | nonAsciiModifier;

+-const int KeyPress::F3Key               = (XK_F3 & 0xff) | nonAsciiModifier;

+-const int KeyPress::F4Key               = (XK_F4 & 0xff) | nonAsciiModifier;

+-const int KeyPress::F5Key               = (XK_F5 & 0xff) | nonAsciiModifier;

+-const int KeyPress::F6Key               = (XK_F6 & 0xff) | nonAsciiModifier;

+-const int KeyPress::F7Key               = (XK_F7 & 0xff) | nonAsciiModifier;

+-const int KeyPress::F8Key               = (XK_F8 & 0xff) | nonAsciiModifier;

+-const int KeyPress::F9Key               = (XK_F9 & 0xff) | nonAsciiModifier;

+-const int KeyPress::F10Key              = (XK_F10 & 0xff) | nonAsciiModifier;

+-const int KeyPress::F11Key              = (XK_F11 & 0xff) | nonAsciiModifier;

+-const int KeyPress::F12Key              = (XK_F12 & 0xff) | nonAsciiModifier;

+-const int KeyPress::playKey             = (0xffeeff00) | nonAsciiModifier;

+-const int KeyPress::stopKey             = (0xffeeff01) | nonAsciiModifier;

+-const int KeyPress::fastForwardKey      = (0xffeeff02) | nonAsciiModifier;

+-const int KeyPress::rewindKey           = (0xffeeff03) | nonAsciiModifier;

+-

+-

+-END_JUCE_NAMESPACE

+-

+-#endif

++/*
++  ==============================================================================
++
++   This file is part of the JUCE library - "Jules' Utility Class Extensions"
++   Copyright 2004-6 by Raw Material Software ltd.
++
++  ------------------------------------------------------------------------------
++
++   JUCE can be redistributed and/or modified under the terms of the
++   GNU General Public License, as published by the Free Software Foundation;
++   either version 2 of the License, or (at your option) any later version.
++
++   JUCE is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++
++   You should have received a copy of the GNU General Public License
++   along with JUCE; if not, visit www.gnu.org/licenses or write to the
++   Free Software Foundation, Inc., 59 Temple Place, Suite 330, 
++   Boston, MA 02111-1307 USA
++
++  ------------------------------------------------------------------------------
++
++   If you'd like to release a closed-source product which uses JUCE, commercial
++   licenses are also available: visit www.rawmaterialsoftware.com/juce for
++   more information.
++
++  ==============================================================================
++*/
++
++#include "juce_Config.h"
++#if JUCE_BUILD_GUI_CLASSES
++
++#include "linuxincludes.h"
++#include <X11/Xlib.h>
++#include <X11/Xutil.h>
++#include <X11/Xatom.h>
++#include <X11/Xmd.h>
++#include <X11/keysym.h>
++#include <X11/cursorfont.h>
++
++#include "../../../juce_Config.h"
++#undef JUCE_USE_XINERAMA
++#undef JUCE_OPENGL
++#if JUCE_USE_XINERAMA
++#include <X11/extensions/Xinerama.h>
++#endif
++
++#if JUCE_OPENGL
++#include <X11/Xlib.h>
++#include <GL/glx.h>
++#endif
++
++#undef KeyPress
++
++#include "../../../src/juce_core/basics/juce_StandardHeader.h"
++
++BEGIN_JUCE_NAMESPACE
++
++#include "../../../src/juce_appframework/events/juce_Timer.h"
++#include "../../../src/juce_appframework/application/juce_DeletedAtShutdown.h"
++#include "../../../src/juce_appframework/gui/components/keyboard/juce_KeyPress.h"
++#include "../../../src/juce_appframework/application/juce_SystemClipboard.h"
++#include "../../../src/juce_appframework/gui/components/windows/juce_AlertWindow.h"
++#include "../../../src/juce_appframework/gui/components/special/juce_OpenGLComponent.h"
++#include "../../../src/juce_appframework/gui/components/juce_Desktop.h"
++#include "../../../src/juce_appframework/events/juce_MessageManager.h"
++#include "../../../src/juce_appframework/gui/components/juce_RepaintManager.h"
++#include "../../../src/juce_appframework/gui/components/juce_ComponentDeletionWatcher.h"
++#include "../../../src/juce_appframework/gui/graphics/geometry/juce_RectangleList.h"
++#include "../../../src/juce_appframework/gui/graphics/imaging/juce_ImageFileFormat.h"
++#include "../../../src/juce_appframework/gui/components/mouse/juce_DragAndDropContainer.h"
++#include "../../../src/juce_core/basics/juce_Logger.h"
++#include "../../../src/juce_core/threads/juce_Process.h"
++#include "../../../src/juce_core/misc/juce_PlatformUtilities.h"
++
++
++//==============================================================================
++static Atom wm_ChangeState = None;
++static Atom wm_State = None;
++static Atom wm_Protocols = None;
++static Atom wm_ProtocolList [2] = { None, None };
++static Atom wm_ActiveWin = None;
++static Atom repaintId = None;
++
++#define TAKE_FOCUS 0
++#define DELETE_WINDOW 1
++
++//==============================================================================
++static bool isActiveApplication = false;
++
++bool Process::isForegroundProcess()
++{
++    return isActiveApplication;
++}
++
++//==============================================================================
++// These are defined in juce_linux_Messages.cpp
++extern Display* display;
++extern XContext improbableNumber;
++
++const int juce_windowIsSemiTransparentFlag = (1 << 31); // also in component.cpp
++
++static const int eventMask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask
++                             | EnterWindowMask | LeaveWindowMask | PointerMotionMask | KeymapStateMask
++                             | ExposureMask | StructureNotifyMask | FocusChangeMask;
++
++//==============================================================================
++static int pointerMap[5];
++static int lastMousePosX = 0, lastMousePosY = 0;
++
++enum MouseButtons
++{
++    NoButton = 0,
++    LeftButton = 1,
++    MiddleButton = 2,
++    RightButton = 3,
++    WheelUp = 4,
++    WheelDown = 5
++};
++
++static void getMousePos (int& x, int& y, int& mouseMods)
++{
++    Window root, child;
++    int winx, winy;
++    unsigned int mask;
++
++    mouseMods = 0;
++
++    if (XQueryPointer (display,
++                       RootWindow (display, DefaultScreen (display)),
++                       &root, &child,
++                       &x, &y, &winx, &winy, &mask) == False)
++    {
++        // Pointer not on the default screen
++        x = y = -1;
++    }
++    else
++    {
++        if ((mask & Button1Mask) != 0)
++            mouseMods |= ModifierKeys::leftButtonModifier;
++
++        if ((mask & Button2Mask) != 0)
++            mouseMods |= ModifierKeys::middleButtonModifier;
++
++        if ((mask & Button3Mask) != 0)
++            mouseMods |= ModifierKeys::rightButtonModifier;
++    }
++}
++
++//==============================================================================
++static int AltMask = 0;
++static int NumLockMask = 0;
++static bool numLock = 0;
++static bool capsLock = 0;
++static char keyStates [32];
++
++static void updateKeyStates (const int keycode, const bool press)
++{
++    const int keybyte = keycode >> 3;
++    const int keybit = (1 << (keycode & 7));
++
++    if (press)
++        keyStates [keybyte] |= keybit;
++    else
++        keyStates [keybyte] &= ~keybit;
++}
++
++static bool keyDown (const int keycode)
++{
++    const int keybyte = keycode >> 3;
++    const int keybit = (1 << (keycode & 7));
++
++    return (keyStates [keybyte] & keybit) != 0;
++}
++
++static const int nonAsciiModifier = 0x10000;
++
++bool KeyPress::isKeyCurrentlyDown (int keyCode)
++{
++    int keysym;
++
++    if (keyCode & nonAsciiModifier)
++    {
++        keysym = 0xff00 | (keyCode & 0xff);
++    }
++    else
++    {
++        keysym = keyCode;
++
++        if (keysym == (XK_Tab & 0xff)
++            || keysym == (XK_Return & 0xff)
++            || keysym == (XK_Escape & 0xff)
++            || keysym == (XK_BackSpace & 0xff))
++        {
++            keysym |= 0xff00;
++        }
++    }
++
++    return keyDown (XKeysymToKeycode (display, keysym));
++}
++
++//==============================================================================
++// Alt and Num lock are not defined by standard X
++// modifier constants: check what they're mapped to
++static void getModifierMapping()
++{
++    const int altLeftCode = XKeysymToKeycode (display, XK_Alt_L);
++    const int numLockCode = XKeysymToKeycode (display, XK_Num_Lock);
++
++    AltMask = 0;
++    NumLockMask = 0;
++
++    XModifierKeymap* mapping = XGetModifierMapping (display);
++
++    if (mapping)
++    {
++        for (int i = 0; i < 8; i++)
++        {
++            if (mapping->modifiermap [i << 1] == altLeftCode)
++                AltMask = 1 << i;
++            else if (mapping->modifiermap [i << 1] == numLockCode)
++                NumLockMask = 1 << i;
++        }
++
++        XFreeModifiermap (mapping);
++    }
++}
++
++static int currentModifiers = 0;
++
++void ModifierKeys::updateCurrentModifiers()
++{
++    currentModifierFlags = currentModifiers;
++}
++
++const ModifierKeys ModifierKeys::getCurrentModifiersRealtime()
++{
++    int x, y, mouseMods;
++    getMousePos (x, y, mouseMods);
++
++    currentModifiers &= ~ModifierKeys::allMouseButtonModifiers;
++    currentModifiers |= mouseMods;
++
++    return ModifierKeys (currentModifiers);
++}
++
++static void updateKeyModifiers (const int status)
++{
++    currentModifiers &= ~(ModifierKeys::shiftModifier
++                           | ModifierKeys::ctrlModifier
++                           | ModifierKeys::altModifier);
++
++    if (status & ShiftMask)
++        currentModifiers |= ModifierKeys::shiftModifier;
++
++    if (status & ControlMask)
++        currentModifiers |= ModifierKeys::ctrlModifier;
++
++    if (status & AltMask)
++        currentModifiers |= ModifierKeys::altModifier;
++
++    numLock  = ((status & NumLockMask) != 0);
++    capsLock = ((status & LockMask) != 0);
++}
++
++static bool updateKeyModifiersFromSym (KeySym sym, const bool press)
++{
++    int modifier = 0;
++    bool isModifier = true;
++
++    switch (sym)
++    {
++        case XK_Shift_L:
++        case XK_Shift_R:
++            modifier = ModifierKeys::shiftModifier;
++            break;
++
++        case XK_Control_L:
++        case XK_Control_R:
++            modifier = ModifierKeys::ctrlModifier;
++            break;
++
++        case XK_Alt_L:
++        case XK_Alt_R:
++            modifier = ModifierKeys::altModifier;
++            break;
++
++        case XK_Num_Lock:
++            if (press)
++                numLock = ! numLock;
++
++            break;
++
++        case XK_Caps_Lock:
++            if (press)
++                capsLock = ! capsLock;
++
++            break;
++
++        case XK_Scroll_Lock:
++            break;
++
++        default:
++            isModifier = false;
++            break;
++    }
++
++    if (modifier != 0)
++    {
++        if (press)
++            currentModifiers |= modifier;
++        else
++            currentModifiers &= ~modifier;
++    }
++
++    return isModifier;
++}
++
++
++//==============================================================================
++class XBitmapImage  : public Image
++{
++public:
++    //==============================================================================
++    XBitmapImage (const PixelFormat format_, const int w, const int h, const bool clearImage)
++        : Image (format_, w, h)
++    {
++        jassert (format_ == RGB || format_ == ARGB);
++
++        pixelStride = (format_ == RGB) ? 3 : 4;
++        lineStride = ((w * pixelStride + 3) & ~3);
++        imageData = (uint8*) juce_malloc (lineStride * h);
++
++        if (format_ == ARGB && clearImage)
++            zeromem (xImage->data, h * lineStride);
++
++        xImage = new XImage();
++        xImage->width = w;
++        xImage->height = h;
++        xImage->xoffset = 0;
++        xImage->format = ZPixmap;
++        xImage->data = (char*) imageData;
++        xImage->byte_order = ImageByteOrder (display);
++        xImage->bitmap_unit = BitmapUnit (display);
++        xImage->bitmap_bit_order = BitmapBitOrder (display);
++        xImage->bitmap_pad = 32;
++        xImage->depth = pixelStride * 8;
++        xImage->bytes_per_line = lineStride;
++        xImage->bits_per_pixel = pixelStride * 8;
++        xImage->red_mask   = 0x00FF0000;
++        xImage->green_mask = 0x0000FF00;
++        xImage->blue_mask  = 0x000000FF;
++
++        if (! XInitImage (xImage))
++        {
++            jassertfalse
++        }
++    }
++
++    ~XBitmapImage()
++    {
++        juce_free (xImage->data);
++        xImage->data = 0;
++        XDestroyImage (xImage);
++        imageData = 0; // to stop the base class freeing this
++    }
++
++    void blitToWindow (Window window, int dx, int dy, int dw, int dh, int sx, int sy)
++    {
++        static GC gc = 0;
++
++        if (gc == 0)
++            gc = DefaultGC (display, DefaultScreen (display));
++
++        // blit results to screen.
++        XPutImage (display, (Drawable) window, gc, xImage, sx, sy, dx, dy, dw, dh);
++    }
++
++    //==============================================================================
++    juce_UseDebuggingNewOperator
++
++private:
++    XImage* xImage;
++};
++
++
++//==============================================================================
++class LinuxComponentPeer  : public ComponentPeer
++{
++public:
++    //==============================================================================
++    LinuxComponentPeer (Component* const component, const int windowStyleFlags)
++        : ComponentPeer (component, windowStyleFlags),
++          windowH (0),
++          wx (0),
++          wy (0),
++          ww (0),
++          wh (0),
++          fullScreen (false),
++          entered (false),
++          mapped (false)
++    {
++        repainter = new LinuxRepaintManager (this, component, 3000);
++
++        MessageManager::getInstance()
++           ->callFunctionOnMessageThread (&createWindowCallback, (void*) this);
++
++        setTitle (component->getName());
++    }
++
++    ~LinuxComponentPeer()
++    {
++        MessageManager::getInstance()
++            ->callFunctionOnMessageThread (&destroyWindowCallback, (void*) windowH);
++
++        windowH = 0;
++        delete repainter;
++    }
++
++    //==============================================================================
++    void* getNativeHandle() const
++    {
++        return (void*) windowH;
++    }
++
++    void setVisible (bool shouldBeVisible)
++    {
++        if (shouldBeVisible)
++            XMapWindow (display, windowH);
++        else
++            XUnmapWindow (display, windowH);
++    }
++
++    void setTitle (const String& title)
++    {
++        setWindowTitle (windowH, title);
++    }
++
++    void setPosition (int x, int y)
++    {
++        setBounds (x, y, ww, wh, false);
++    }
++
++    void setSize (int w, int h)
++    {
++        setBounds (wx, wy, w, h, false);
++    }
++
++    void setBounds (int x, int y, int w, int h, const bool isNowFullScreen)
++    {
++        fullScreen = isNowFullScreen;
++
++        if (windowH != 0)
++        {
++            const ComponentDeletionWatcher deletionChecker (component);
++
++            wx = x;
++            wy = y;
++            ww = jmax (1, w);
++            wh = jmax (1, h);
++
++            if (! mapped)
++            {
++                // Make sure the Window manager does what we want
++                XSizeHints* hints = XAllocSizeHints();
++                hints->flags = USSize | USPosition;
++                hints->width = ww + windowBorder.getLeftAndRight();
++                hints->height = wh + windowBorder.getTopAndBottom();
++                hints->x = wx - windowBorder.getLeft();
++                hints->y = wy - windowBorder.getTop();
++                XSetWMNormalHints (display, windowH, hints);
++                XFree (hints);
++            }
++
++            XMoveResizeWindow (display, windowH,
++                               wx - windowBorder.getLeft(),
++                               wy - windowBorder.getTop(),
++                               ww + windowBorder.getLeftAndRight(),
++                               wh + windowBorder.getTopAndBottom());
++
++            if (! deletionChecker.hasBeenDeleted())
++            {
++                updateBorderSize();
++                handleMovedOrResized();
++            }
++        }
++    }
++
++    void getBounds (int& x, int& y, int& w, int& h) const
++    {
++        x = wx;
++        y = wy;
++        w = ww;
++        h = wh;
++    }
++
++    int getScreenX() const
++    {
++        return wx;
++    }
++
++    int getScreenY() const
++    {
++        return wy;
++    }
++
++    void setMinimised (bool shouldBeMinimised)
++    {
++        if (shouldBeMinimised)
++        {
++            Window root = RootWindow (display, DefaultScreen (display));
++
++            XClientMessageEvent clientMsg;
++            clientMsg.display = display;
++            clientMsg.window = windowH;
++            clientMsg.type = ClientMessage;
++            clientMsg.format = 32;
++            clientMsg.message_type = wm_ChangeState;
++            clientMsg.data.l[0] = IconicState;
++
++            XSendEvent (display, root, false,
++                        SubstructureRedirectMask | SubstructureNotifyMask,
++                        (XEvent*) &clientMsg);
++        }
++        else
++        {
++            setVisible (true);
++        }
++    }
++
++    bool isMinimised() const
++    {
++        bool minimised = false;
++
++        CARD32* stateProp;
++        unsigned long nitems, bytesLeft;
++        Atom actualType;
++        int actualFormat;
++
++        if (XGetWindowProperty (display, windowH, wm_State, 0, 64, False,
++                                wm_State, &actualType, &actualFormat, &nitems, &bytesLeft,
++                                (unsigned char**) &stateProp) == Success
++            && actualType == wm_State
++            && actualFormat == 32
++            && nitems > 0)
++        {
++            if (stateProp[0] == IconicState)
++                minimised = true;
++
++            XFree (stateProp);
++        }
++
++        return minimised;
++    }
++
++    void setFullScreen (bool shouldBeFullScreen)
++    {
++        setMinimised (false);
++
++        if (fullScreen != shouldBeFullScreen)
++        {
++            Rectangle r (lastNonFullscreenBounds);
++
++            if (shouldBeFullScreen)
++                r = Desktop::getInstance().getMainMonitorArea();
++
++            if (! r.isEmpty())
++                setBounds (r.getX(), r.getY(), r.getWidth(), r.getHeight(), shouldBeFullScreen);
++
++            getComponent()->repaint();
++        }
++    }
++
++    bool isFullScreen() const
++    {
++        return fullScreen;
++    }
++
++    bool isChildWindowOf (Window possibleParent) const
++    {
++        Window* windowList = 0;
++        uint32 windowListSize = 0;
++        Window parent, root;
++
++        if (XQueryTree (display, windowH, &root, &parent, &windowList, &windowListSize) != 0)
++        {
++            if (windowList != 0)
++                XFree (windowList);
++
++            return parent == possibleParent;
++        }
++
++        return false;
++    }
++
++    bool contains (int x, int y, bool trueIfInAChildWindow) const
++    {
++        jassert (x >= 0 && y >= 0 && x < ww && y < wh); // should only be called for points that are actually inside the bounds
++
++        x += wx;
++        y += wy;
++
++        // the XQueryTree stuff later on is VERY slow, so if this call's just to check the mouse pos, it's
++        // much more efficient to cheat..
++        if (x == lastMousePosX && y == lastMousePosY)
++        {
++            Window root, child;
++            int winx, winy;
++            unsigned int mask;
++
++            if (XQueryPointer (display,
++                               RootWindow (display, DefaultScreen (display)),
++                               &root, &child,
++                               &x, &y, &winx, &winy, &mask) != False)
++            {
++                return child == windowH
++                        || (((styleFlags & windowHasTitleBar) != 0) && isChildWindowOf (child));
++            }
++        }
++
++        bool result = false;
++
++        Window* windowList = 0;
++        uint32 windowListSize = 0;
++
++        Window parent, root = RootWindow (display, DefaultScreen (display));
++
++        if (XQueryTree (display, root, &root, &parent, &windowList, &windowListSize) != 0)
++        {
++            for (int i = windowListSize; --i >= 0;)
++            {
++                XWindowAttributes atts;
++
++                if (windowList[i] == windowH
++                     || (((styleFlags & windowHasTitleBar) != 0) && isChildWindowOf (windowList[i])))
++                {
++                    result = true;
++
++                    if (! trueIfInAChildWindow)
++                    {
++                        Window child;
++                        int tempX, tempY;
++
++                        result = XTranslateCoordinates (display, windowH, windowH,
++                                                        x - wx - windowBorder.getLeft(),
++                                                        y - wy - windowBorder.getTop(),
++                                                        &tempX, &tempY,
++                                                        &child)
++                                    && (child == None);
++                    }
++
++                    break;
++                }
++                else if (XGetWindowAttributes (display, windowList[i], &atts)
++                          && atts.map_state == IsViewable
++                          && x >= atts.x && y >= atts.y
++                          && x < atts.x + atts.width
++                          && y < atts.y + atts.height)
++                {
++                    break;
++                }
++            }
++        }
++
++        if (windowList != 0)
++            XFree (windowList);
++
++        return result;
++    }
++
++    const BorderSize getFrameSize() const
++    {
++        return BorderSize();
++    }
++
++    bool setAlwaysOnTop (bool alwaysOnTop)
++    {
++        if (windowH != 0)
++        {
++            XSetWindowAttributes swa;
++            swa.override_redirect = getComponent()->isAlwaysOnTop() ? True : False;
++
++            XChangeWindowAttributes (display, windowH, CWOverrideRedirect, &swa);
++        }
++
++        return true;
++    }
++
++    void toFront (bool makeActive)
++    {
++        if (makeActive)
++        {
++            setVisible (true);
++            grabFocus();
++        }
++
++        XEvent ev;
++        ev.xclient.type = ClientMessage;
++        ev.xclient.serial = 0;
++        ev.xclient.send_event = True;
++        ev.xclient.message_type = wm_ActiveWin;
++        ev.xclient.window = windowH;
++        ev.xclient.format = 32;
++        ev.xclient.data.l[0] = 2;
++        ev.xclient.data.l[1] = CurrentTime;
++        ev.xclient.data.l[2] = 0;
++        ev.xclient.data.l[3] = 0;
++        ev.xclient.data.l[4] = 0;
++
++        XSendEvent (display, RootWindow (display, DefaultScreen (display)),
++                    False,
++                    SubstructureRedirectMask | SubstructureNotifyMask,
++                    &ev);
++
++        XSync (display, False);
++    }
++
++    void toBehind (ComponentPeer* other)
++    {
++        LinuxComponentPeer* const otherPeer = dynamic_cast <LinuxComponentPeer*> (other);
++        jassert (otherPeer != 0); // wrong type of window?
++
++        if (otherPeer != 0)
++        {
++            setMinimised (false);
++
++            Window newStack[] = { otherPeer->windowH, windowH };
++
++            XRestackWindows (display, newStack, 2);
++        }
++    }
++
++    bool isFocused() const
++    {
++        int revert;
++        Window focus = 0;
++        XGetInputFocus (display, &focus, &revert);
++
++        if (focus == 0 || focus == None || focus == PointerRoot)
++            return 0;
++
++        ComponentPeer* focusedPeer = 0;
++        if (XFindContext (display, (XID) focus, improbableNumber, (XPointer*) &focusedPeer) != 0)
++            focusedPeer = 0;
++
++        return this == focusedPeer;
++    }
++
++    void grabFocus()
++    {
++        XWindowAttributes atts;
++
++        if (windowH != 0
++            && XGetWindowAttributes (display, windowH, &atts)
++            && atts.map_state == IsViewable)
++        {
++            XSetInputFocus (display, windowH, RevertToParent, CurrentTime);
++
++            if (! isActiveApplication)
++            {
++                isActiveApplication = true;
++                handleFocusGain();
++            }
++        }
++    }
++
++    void repaint (int x, int y, int w, int h)
++    {
++        repainter->invalidateCache (x, y, w, h);
++        repainter->repaint (x, y, w, h);
++    }
++
++    void performPendingRepaints()
++    {
++        repainter->performPendingRepaints();
++    }
++
++    //==============================================================================
++    void handleWindowMessage (XEvent* event)
++    {
++        switch (event->xany.type)
++        {
++            case 2: // 'KeyPress'
++            {
++                XKeyEvent* keyEvent = (XKeyEvent*) &event->xkey;
++                updateKeyStates (keyEvent->keycode, true);
++
++                int index = currentModifiers & ModifierKeys::shiftModifier ? 1 : 0;
++                KeySym sym = XKeycodeToKeysym (display, keyEvent->keycode, index);
++
++                const int oldMods = currentModifiers;
++                bool keyPressed = false;
++
++                const bool keyDownChange = (sym != NoSymbol) && ! updateKeyModifiersFromSym (sym, false);
++
++                if ((sym & 0xff00) == 0xff00)
++                {
++                    // Translate keypad
++                    if (sym == XK_KP_Divide)
++                        sym = XK_slash;
++                    else if (sym == XK_KP_Multiply)
++                        sym = XK_asterisk;
++                    else if (sym == XK_KP_Subtract)
++                        sym = XK_hyphen;
++                    else if (sym == XK_KP_Add)
++                        sym = XK_plus;
++                    else if (sym == XK_KP_Enter)
++                        sym = XK_Return;
++                    else if (sym == XK_KP_Decimal)
++                        sym = numLock ? XK_period : XK_Delete;
++                    else if (sym == XK_KP_0)
++                        sym = numLock ? XK_0 : XK_Insert;
++                    else if (sym == XK_KP_1)
++                        sym = numLock ? XK_1 : XK_End;
++                    else if (sym == XK_KP_2)
++                        sym = numLock ? XK_2 : XK_Down;
++                    else if (sym == XK_KP_3)
++                        sym = numLock ? XK_3 : XK_Page_Down;
++                    else if (sym == XK_KP_4)
++                        sym = numLock ? XK_4 : XK_Left;
++                    else if (sym == XK_KP_5)
++                        sym = XK_5;
++                    else if (sym == XK_KP_6)
++                        sym = numLock ? XK_6 : XK_Right;
++                    else if (sym == XK_KP_7)
++                        sym = numLock ? XK_7 : XK_Home;
++                    else if (sym == XK_KP_8)
++                        sym = numLock ? XK_8 : XK_Up;
++                    else if (sym == XK_KP_9)
++                        sym = numLock ? XK_9 : XK_Page_Up;
++
++                    switch (sym)
++                    {
++                        case XK_Left:
++                        case XK_Right:
++                        case XK_Up:
++                        case XK_Down:
++                        case XK_Page_Up:
++                        case XK_Page_Down:
++                        case XK_End:
++                        case XK_Home:
++                        case XK_Delete:
++                        case XK_Insert:
++                            keyPressed = true;
++                            sym = (sym & 0xff) | nonAsciiModifier;
++                            break;
++                        case XK_Tab:
++                        case XK_Return:
++                        case XK_Escape:
++                        case XK_BackSpace:
++                            keyPressed = true;
++                            sym &= 0xff;
++                            break;
++                        default:
++                        {
++                            if (sym >= XK_F1 && sym <= XK_F12)
++                            {
++                                keyPressed = true;
++                                sym = (sym & 0xff) | nonAsciiModifier;
++                            }
++                            break;
++                        }
++                    }
++                }
++
++                if ((sym & 0xff00) == 0 && sym >= 8)
++                    keyPressed = true;
++
++                if (capsLock && ((sym >= XK_A && sym <= XK_Z) || (sym >= XK_a && sym <= XK_z)))
++                {
++                    index ^= 1;
++                    sym = XKeycodeToKeysym (display, keyEvent->keycode, index);
++                }
++
++                if (oldMods != currentModifiers)
++                    handleModifierKeysChange();
++
++                if (keyDownChange)
++                    handleKeyUpOrDown();
++
++                if (keyPressed)
++                    handleKeyPress (sym);
++
++                break;
++            }
++
++            case KeyRelease:
++            {
++                XKeyEvent* keyEvent = (XKeyEvent*) &event->xkey;
++                updateKeyStates (keyEvent->keycode, false);
++
++                KeySym sym = XKeycodeToKeysym (display, keyEvent->keycode, 0);
++
++                const int oldMods = currentModifiers;
++                const bool keyDownChange = (sym != NoSymbol) && ! updateKeyModifiersFromSym (sym, false);
++
++                if (oldMods != currentModifiers)
++                    handleModifierKeysChange();
++
++                if (keyDownChange)
++                    handleKeyUpOrDown();
++
++                break;
++            }
++
++            case ButtonPress:
++            {
++                XButtonPressedEvent* buttonPressEvent = (XButtonPressedEvent*) &event->xbutton;
++
++                bool buttonMsg = false;
++                bool wheelUpMsg = false;
++                bool wheelDownMsg = false;
++
++                const int map = pointerMap [buttonPressEvent->button - Button1];
++
++                if (map == LeftButton)
++                {
++                    currentModifiers |= ModifierKeys::leftButtonModifier;
++                    buttonMsg = true;
++                }
++                else if (map == RightButton)
++                {
++                    currentModifiers |= ModifierKeys::rightButtonModifier;
++                    buttonMsg = true;
++                }
++                else if (map == MiddleButton)
++                {
++                    currentModifiers |= ModifierKeys::middleButtonModifier;
++                    buttonMsg = true;
++                }
++                else if (map == WheelUp)
++                {
++                    wheelUpMsg = true;
++                }
++                else if (map == WheelDown)
++                {
++                    wheelDownMsg = true;
++                }
++
++                updateKeyModifiers (buttonPressEvent->state);
++
++                if (buttonMsg)
++                {
++                    toFront (true);
++                    handleMouseDown (buttonPressEvent->x, buttonPressEvent->y,
++                                     getEventTime (buttonPressEvent->time));
++                }
++                else if (wheelUpMsg || wheelDownMsg)
++                {
++                    handleMouseWheel (wheelDownMsg ? -84 : 84,
++                                      getEventTime (buttonPressEvent->time));
++                }
++
++                lastMousePosX = lastMousePosY = 0x100000;
++                break;
++            }
++
++            case ButtonRelease:
++            {
++                XButtonReleasedEvent* buttonRelEvent = (XButtonReleasedEvent*) &event->xbutton;
++
++                const int oldModifiers = currentModifiers;
++                const int map = pointerMap [buttonRelEvent->button - Button1];
++
++                if (map == LeftButton)
++                    currentModifiers &= ~ModifierKeys::leftButtonModifier;
++                else if (map == RightButton)
++                    currentModifiers &= ~ModifierKeys::rightButtonModifier;
++                else if (map == MiddleButton)
++                    currentModifiers &= ~ModifierKeys::middleButtonModifier;
++
++                updateKeyModifiers (buttonRelEvent->state);
++
++                handleMouseUp (oldModifiers,
++                               buttonRelEvent->x, buttonRelEvent->y,
++                               getEventTime (buttonRelEvent->time));
++
++                lastMousePosX = lastMousePosY = 0x100000;
++                break;
++            }
++
++            case MotionNotify:
++            {
++                XPointerMovedEvent* movedEvent = (XPointerMovedEvent*) &event->xmotion;
++
++                updateKeyModifiers (movedEvent->state);
++
++                int x, y, mouseMods;
++                getMousePos (x, y, mouseMods);
++
++                if (lastMousePosX != x || lastMousePosY != y)
++                {
++                    lastMousePosX = x;
++                    lastMousePosY = y;
++
++                    x -= getScreenX();
++                    y -= getScreenY();
++
++                    if ((currentModifiers & ModifierKeys::allMouseButtonModifiers) == 0)
++                        handleMouseMove (x, y, getEventTime (movedEvent->time));
++                    else
++                        handleMouseDrag (x, y, getEventTime (movedEvent->time));
++                }
++
++                break;
++            }
++
++            case EnterNotify:
++            {
++                lastMousePosX = lastMousePosY = 0x100000;
++                XEnterWindowEvent* enterEvent = (XEnterWindowEvent*) &event->xcrossing;
++
++                if ((currentModifiers & ModifierKeys::allMouseButtonModifiers) == 0
++                     && ! entered)
++                {
++                    updateKeyModifiers (enterEvent->state);
++
++                    handleMouseEnter (enterEvent->x, enterEvent->y, getEventTime (enterEvent->time));
++
++                    entered = true;
++                }
++
++                break;
++            }
++
++            case LeaveNotify:
++            {
++                XLeaveWindowEvent* leaveEvent = (XLeaveWindowEvent*) &event->xcrossing;
++
++                // Suppress the normal leave if we've got a pointer grab, or if
++                // it's a bogus one caused by clicking a mouse button when running
++                // in a Window manager
++                if (((currentModifiers & ModifierKeys::allMouseButtonModifiers) == 0
++                     && leaveEvent->mode == NotifyNormal)
++                    || leaveEvent->mode == NotifyUngrab)
++                {
++                    updateKeyModifiers (leaveEvent->state);
++
++                    handleMouseExit (leaveEvent->x, leaveEvent->y, getEventTime (leaveEvent->time));
++
++                    entered = false;
++                }
++
++                break;
++            }
++
++            case FocusIn:
++            {
++                isActiveApplication = true;
++                handleFocusGain();
++                break;
++            }
++
++            case FocusOut:
++            {
++                isActiveApplication = false;
++                handleFocusLoss();
++                break;
++            }
++
++            case Expose:
++            {
++                // Batch together all pending expose events
++                XExposeEvent* exposeEvent = (XExposeEvent*) &event->xexpose;
++                XEvent nextEvent;
++
++                repaint (exposeEvent->x, exposeEvent->y,
++                         exposeEvent->width, exposeEvent->height);
++
++                while (XEventsQueued (display, QueuedAfterFlush) > 0)
++                {
++                    XPeekEvent (display, (XEvent*) &nextEvent);
++                    if (nextEvent.type != Expose || nextEvent.xany.window != event->xany.window)
++                        break;
++
++                    XNextEvent (display, (XEvent*)&nextEvent);
++                    XExposeEvent* nextExposeEvent = (XExposeEvent*)(&nextEvent.xexpose);
++                    repaint (nextExposeEvent->x, nextExposeEvent->y,
++                             nextExposeEvent->width, nextExposeEvent->height);
++                }
++
++                break;
++            }
++
++            case CreateNotify:
++            case DestroyNotify:
++                // Think we can ignore these
++                break;
++
++            case CirculateNotify:
++                break;
++
++            case ConfigureNotify:
++            case ReparentNotify:
++            case GravityNotify:
++                updateBounds();
++                break;
++
++            case MapNotify:
++                mapped = true;
++                handleBroughtToFront();
++                break;
++
++            case UnmapNotify:
++                mapped = false;
++                break;
++
++            case MappingNotify:
++            {
++                XMappingEvent* mappingEvent = (XMappingEvent*) &event->xmapping;
++
++                if (mappingEvent->request != MappingPointer)
++                {
++                    // Deal with modifier/keyboard mapping
++                    XRefreshKeyboardMapping (mappingEvent);
++                    getModifierMapping();
++                }
++
++                break;
++            }
++
++            case ClientMessage:
++            {
++                XClientMessageEvent* clientMsg = (XClientMessageEvent*) &event->xclient;
++
++                if (clientMsg->message_type == wm_Protocols && clientMsg->format == 32)
++                {
++                    const Atom atom = (Atom) clientMsg->data.l[0];
++
++                    if (atom == wm_ProtocolList [TAKE_FOCUS])
++                    {
++                        XWindowAttributes atts;
++
++                        if (clientMsg->window != 0
++                             && XGetWindowAttributes (display, clientMsg->window, &atts))
++                        {
++                            if (atts.map_state == IsViewable)
++                                XSetInputFocus (display, clientMsg->window, RevertToParent, clientMsg->data.l[1]);
++                        }
++                    }
++                    else if (atom == wm_ProtocolList [DELETE_WINDOW])
++                    {
++                        handleUserClosingWindow();
++                    }
++                }
++                else if (clientMsg->message_type == repaintId)
++                {
++                    // Get rid of all pending repaint events
++                    XEvent nextEvent;
++
++                    while (XEventsQueued (display, QueuedAfterFlush) > 0)
++                    {
++                        XPeekEvent (display, &nextEvent);
++                        if (nextEvent.xany.type != ClientMessage ||
++                            nextEvent.xany.window != event->xany.window)
++                            break;
++
++                        XClientMessageEvent* nextClientMsg = (XClientMessageEvent*) (&nextEvent.xclient);
++                        if (nextClientMsg->message_type != repaintId)
++                            break;
++
++                        XNextEvent (display, &nextEvent);
++                    }
++
++                    static bool reentrancyCheck = false;
++                    if (! reentrancyCheck)
++                    {
++                        reentrancyCheck = true;
++
++                        int ox, oy, ow, oh;
++                        getBounds (ox, oy, ow, oh);
++                        repaint (0, 0, ow, oh);
++                        performPendingRepaints();
++
++                        reentrancyCheck = false;
++                    }
++                }
++
++                break;
++            }
++
++            case SelectionClear:
++            case SelectionNotify:
++            case SelectionRequest:
++                // We shouldn't get these on normal windows
++                break;
++
++            default:
++                break;
++        }
++    }
++
++    void showMouseCursor (Cursor cursor)
++    {
++        XDefineCursor (display, windowH, cursor);
++    }
++
++    //==============================================================================
++    juce_UseDebuggingNewOperator
++
++    bool dontRepaint;
++
++private:
++    //==============================================================================
++    class LinuxRepaintManager : public RepaintManager
++    {
++    public:
++        LinuxRepaintManager (LinuxComponentPeer* const peer_,
++                             Component* const component,
++                             const int timeBeforeReleasingImage)
++            : RepaintManager (component, timeBeforeReleasingImage),
++              peer (peer_)
++        {
++        }
++
++        Image* createNewImage (int w, int h)
++        {
++            return new XBitmapImage (Image::RGB, w, h, false);
++        }
++
++        void repaintNow (const RectangleList& areasToPaint)
++        {
++            peer->clearMaskedRegion();
++
++            renderCacheAreasNeedingRepaint();
++
++            int x, y;
++            XBitmapImage* const paintingBuffer = (XBitmapImage*) getImage (x, y);
++
++            if (paintingBuffer != 0)
++            {
++                const RectangleList* repaintRegion = &areasToPaint;
++                RectangleList temp;
++
++                if (! peer->maskedRegion.isEmpty())
++                {
++                    temp = areasToPaint;
++                    temp.subtract (peer->maskedRegion);
++                    repaintRegion = &temp;
++                }
++
++                for (RectangleList::Iterator i (*repaintRegion); i.next();)
++                {
++                    const Rectangle& r = i.getRectangle();
++
++                    paintingBuffer->blitToWindow (peer->windowH,
++                                                  r.getX(), r.getY(), r.getWidth(), r.getHeight(),
++                                                  r.getX() - x, r.getY() - y);
++                }
++            }
++        }
++
++    private:
++        LinuxComponentPeer* const peer;
++
++        LinuxRepaintManager (const LinuxRepaintManager&);
++        const LinuxRepaintManager& operator= (const LinuxRepaintManager&);
++    };
++
++    LinuxRepaintManager* repainter;
++
++    friend class LinuxRepaintManager;
++    Window windowH;
++    int wx, wy, ww, wh;
++    bool fullScreen, entered, mapped;
++    BorderSize windowBorder;
++
++    //==============================================================================
++    void removeWindowDecorations (Window wndH)
++    {
++        Atom hints = XInternAtom (display, "_MOTIF_WM_HINTS", True);
++
++        if (hints != None)
++        {
++            typedef struct
++            {
++                CARD32 flags;
++                CARD32 functions;
++                CARD32 decorations;
++                INT32 input_mode;
++                CARD32 status;
++            } MotifWmHints;
++
++            MotifWmHints motifHints;
++            motifHints.flags = 2; /* MWM_HINTS_DECORATIONS */
++            motifHints.decorations = 0;
++
++            XChangeProperty (display, wndH, hints, hints, 32, PropModeReplace,
++                             (unsigned char*) &motifHints, 4);
++        }
++
++        hints = XInternAtom (display, "_WIN_HINTS", True);
++
++        if (hints != None)
++        {
++            long gnomeHints = 0;
++
++            XChangeProperty (display, wndH, hints, hints, 32, PropModeReplace,
++                             (unsigned char*) &gnomeHints, 1);
++        }
++
++        hints = XInternAtom (display, "KWM_WIN_DECORATION", True);
++
++        if (hints != None)
++        {
++            long kwmHints = 2; /*KDE_tinyDecoration*/
++
++            XChangeProperty (display, wndH, hints, hints, 32, PropModeReplace,
++                             (unsigned char*) &kwmHints, 1);
++        }
++
++        hints = XInternAtom (display, "_NET_WM_WINDOW_TYPE", True);
++
++        if (hints != None)
++        {
++            Atom netHints [2];
++            netHints[0] = XInternAtom (display, "_KDE_NET_WM_WINDOW_TYPE_OVERRIDE", True);
++
++            if ((styleFlags & windowIsTemporary) != 0)
++                netHints[1] = XInternAtom (display, "_NET_WM_WINDOW_TYPE_MENU", True);
++            else
++                netHints[1] = XInternAtom (display, "_NET_WM_WINDOW_TYPE_NORMAL", True);
++
++            XChangeProperty (display, wndH, hints, XA_ATOM, 32, PropModeReplace,
++                             (unsigned char*) &netHints, 2);
++        }
++    }
++
++    void addWindowButtons (Window wndH)
++    {
++        Atom hints = XInternAtom (display, "_MOTIF_WM_HINTS", True);
++
++        if (hints != None)
++        {
++            typedef struct
++            {
++                CARD32 flags;
++                CARD32 functions;
++                CARD32 decorations;
++                INT32 input_mode;
++                CARD32 status;
++            } MotifWmHints;
++
++            MotifWmHints motifHints;
++
++            motifHints.flags = 1 | 2; /* MWM_HINTS_FUNCTIONS | MWM_HINTS_DECORATIONS */
++            motifHints.decorations = 2 /* MWM_DECOR_BORDER */ | 8 /* MWM_DECOR_TITLE */ | 16; /* MWM_DECOR_MENU */
++
++            motifHints.functions = 4 /* MWM_FUNC_MOVE */;
++
++            if ((styleFlags & windowHasCloseButton) != 0)
++                motifHints.functions |= 32; /* MWM_FUNC_CLOSE */
++
++            if ((styleFlags & windowHasMinimiseButton) != 0)
++            {
++                motifHints.functions |= 8; /* MWM_FUNC_MINIMIZE */
++                motifHints.decorations |= 0x20; /* MWM_DECOR_MINIMIZE */
++            }
++
++            if ((styleFlags & windowHasMaximiseButton) != 0)
++            {
++                motifHints.functions |= 0x10; /* MWM_FUNC_MAXIMIZE */
++                motifHints.decorations |= 0x40; /* MWM_DECOR_MAXIMIZE */
++            }
++
++            if ((styleFlags & windowIsResizable) != 0)
++            {
++                motifHints.functions |= 2; /* MWM_FUNC_RESIZE */
++                motifHints.decorations |= 0x4; /* MWM_DECOR_RESIZEH */
++            }
++
++            XChangeProperty (display, wndH, hints, hints, 32, PropModeReplace,
++                             (unsigned char*) &motifHints, 4);
++        }
++
++        hints = XInternAtom (display, "_NET_WM_ALLOWED_ACTIONS", True);
++
++        if (hints != None)
++        {
++            Atom netHints [6];
++            int num = 0;
++
++            netHints [num++] = XInternAtom (display, "_NET_WM_ACTION_RESIZE", (styleFlags & windowIsResizable) ? True : False);
++            netHints [num++] = XInternAtom (display, "_NET_WM_ACTION_FULLSCREEN", (styleFlags & windowHasMaximiseButton) ? True : False);
++            netHints [num++] = XInternAtom (display, "_NET_WM_ACTION_MINIMIZE", (styleFlags & windowHasMinimiseButton) ? True : False);
++            netHints [num++] = XInternAtom (display, "_NET_WM_ACTION_CLOSE", (styleFlags & windowHasCloseButton) ? True : False);
++
++            XChangeProperty (display, wndH, hints, XA_ATOM, 32, PropModeReplace,
++                             (unsigned char*) &netHints, num);
++        }
++    }
++
++    static void* createWindowCallback (void* userData)
++    {
++        ((LinuxComponentPeer*) userData)->createWindow();
++        return 0;
++    }
++
++    void createWindow()
++    {
++        static bool atomsInitialised = false;
++
++        if (! atomsInitialised)
++        {
++            atomsInitialised = true;
++
++            wm_Protocols                      = XInternAtom (display, "WM_PROTOCOLS", 1);
++            wm_ProtocolList [TAKE_FOCUS]      = XInternAtom (display, "WM_TAKE_FOCUS", 1);
++            wm_ProtocolList [DELETE_WINDOW]   = XInternAtom (display, "WM_DELETE_WINDOW", 1);
++            wm_ChangeState                    = XInternAtom (display, "WM_CHANGE_STATE", 1);
++            wm_State                          = XInternAtom (display, "WM_STATE", 1);
++            wm_ActiveWin                      = XInternAtom (display, "_NET_ACTIVE_WINDOW", False);
++            repaintId                         = XInternAtom (display, "JUCERepaintAtom", 1);
++        }
++
++        // Get defaults for various properties
++        const int screen = DefaultScreen (display);
++        Window root = RootWindow (display, screen);
++
++        // Attempt to create a 24-bit window on the default screen.  If this is not
++        // possible then exit
++        XVisualInfo desiredVisual;
++        desiredVisual.screen = screen;
++        desiredVisual.depth = 24;
++
++        int numVisuals;
++        XVisualInfo* visuals = XGetVisualInfo (display, VisualScreenMask | VisualDepthMask,
++                                               &desiredVisual, &numVisuals);
++
++        if (numVisuals < 1 || visuals == 0)
++        {
++            Logger::outputDebugString ("ERROR: System doesn't support 24-bit RGB display.\n");
++            Process::terminate();
++        }
++
++        // Just choose the first one
++        Visual* visual = visuals[0].visual;
++        const int depth = visuals[0].depth;
++        XFree (visuals);
++
++        // Set up the window attributes
++        XSetWindowAttributes swa;
++        swa.border_pixel = 0;
++        swa.colormap = DefaultColormap (display, screen);
++        swa.override_redirect = getComponent()->isAlwaysOnTop() ? True : False;
++        swa.event_mask = eventMask;
++
++        Window wndH = XCreateWindow (display, root,
++                                     0, 0, 1, 1, 0,
++                                     depth, InputOutput, visual,
++                                     CWBorderPixel | CWColormap | CWEventMask | CWOverrideRedirect,
++                                     &swa);
++
++        XGrabButton (display, AnyButton, AnyModifier, wndH, False,
++                     ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask,
++                     GrabModeAsync, GrabModeAsync, None, None);
++
++        // Set the window context to identify the window handle object
++        if (XSaveContext (display, (XID) wndH, improbableNumber, (XPointer) this))
++        {
++            // Failed
++            jassertfalse
++            Logger::outputDebugString ("Failed to create context information for window.\n");
++            XDestroyWindow (display, wndH);
++            wndH = 0;
++        }
++
++        // Set window manager hints
++        XWMHints* wmHints = XAllocWMHints();
++        wmHints->flags = InputHint | StateHint;
++        wmHints->input = True;      // Locally active input model
++        wmHints->initial_state = NormalState;
++        XSetWMHints (display, wndH, wmHints);
++        XFree (wmHints);
++
++        if ((styleFlags & juce_windowIsSemiTransparentFlag) != 0)
++        {
++            //xxx
++            jassertfalse
++        }
++
++        if ((styleFlags & windowAppearsOnTaskbar) != 0)
++        {
++            //xxx
++        }
++
++        if ((styleFlags & windowHasTitleBar) == 0)
++            removeWindowDecorations (wndH);
++        else
++            addWindowButtons (wndH);
++
++        XSetTransientForHint (display, wndH, RootWindow (display, DefaultScreen (display)));
++
++        // Set window manager protocols
++        XChangeProperty (display, wndH, wm_Protocols, XA_ATOM, 32, PropModeReplace,
++                         (unsigned char*) wm_ProtocolList, 2);
++
++        // Set window name
++        setWindowTitle (wndH, getComponent()->getName());
++
++        // Initialise the pointer and keyboard mapping
++        // This is not the same as the logical pointer mapping the X server uses:
++        // we don't mess with this.
++        static bool mappingInitialised = false;
++
++        if (! mappingInitialised)
++        {
++            mappingInitialised = true;
++
++            const int numButtons = XGetPointerMapping (display, 0, 0);
++
++            if (numButtons == 2)
++            {
++                pointerMap[0] = LeftButton;
++                pointerMap[1] = RightButton;
++                pointerMap[2] = pointerMap[3] = pointerMap[4] = NoButton;
++            }
++            else if (numButtons >= 3)
++            {
++                pointerMap[0] = LeftButton;
++                pointerMap[1] = MiddleButton;
++                pointerMap[2] = RightButton;
++
++                if (numButtons >= 5)
++                {
++                    pointerMap[3] = WheelUp;
++                    pointerMap[4] = WheelDown;
++                }
++            }
++
++            getModifierMapping();
++        }
++
++        windowH = wndH;
++    }
++
++    static void* destroyWindowCallback (void* userData)
++    {
++        Window windowH = (Window) userData;
++
++        XPointer handlePointer;
++        if (! XFindContext (display, (XID) windowH, improbableNumber, &handlePointer))
++            XDeleteContext (display, (XID) windowH, improbableNumber);
++
++        XDestroyWindow (display, windowH);
++
++        // Wait for it to complete and then remove any events for this
++        // window from the event queue.
++        XSync (display, false);
++
++        XEvent event;
++        while (XCheckWindowEvent (display, windowH, eventMask, &event) == True)
++        {}
++
++        return 0;
++    }
++
++    static int64 getEventTime (::Time t)
++    {
++        static int64 eventTimeOffset = 0x12345678;
++        const int64 thisMessageTime = t;
++
++        if (eventTimeOffset == 0x12345678)
++            eventTimeOffset = Time::currentTimeMillis() - thisMessageTime;
++
++        return eventTimeOffset + thisMessageTime;
++    }
++
++    static void setWindowTitle (Window xwin, const char* const title)
++    {
++        XTextProperty nameProperty;
++        char* strings[] = { (char*) title };
++
++        if (XStringListToTextProperty (strings, 1, &nameProperty))
++        {
++            XSetWMName (display, xwin, &nameProperty);
++            XSetWMIconName (display, xwin, &nameProperty);
++        }
++    }
++
++    void updateBorderSize()
++    {
++        if ((styleFlags & windowHasTitleBar) == 0)
++        {
++            windowBorder = BorderSize (0);
++        }
++        else if (windowBorder.getTopAndBottom() == 0 && windowBorder.getLeftAndRight() == 0)
++        {
++            Atom hints = XInternAtom (display, "_NET_FRAME_EXTENTS", True);
++
++            if (hints != None)
++            {
++                CARD32* sizes = 0;
++                unsigned long nitems, bytesLeft;
++                Atom actualType;
++                int actualFormat;
++
++                if (XGetWindowProperty (display, windowH, hints, 0, 4, False,
++                                        XA_CARDINAL, &actualType, &actualFormat, &nitems, &bytesLeft,
++                                        (unsigned char**) &sizes) == Success)
++                {
++                    if (actualFormat == 32)
++                        windowBorder = BorderSize ((int) sizes[2], (int) sizes[0],
++                                                   (int) sizes[3], (int) sizes[1]);
++
++                    XFree (sizes);
++                }
++            }
++        }
++    }
++
++    void updateBounds()
++    {
++        jassert (windowH != 0);
++        if (windowH != 0)
++        {
++            Window root, child;
++            unsigned int bw, depth;
++
++            if (! XGetGeometry (display, (Drawable) windowH, &root,
++                                &wx, &wy, (unsigned int*) &ww, (unsigned int*) &wh,
++                                &bw, &depth))
++            {
++                wx = wy = ww = wh = 0;
++            }
++            else if (! XTranslateCoordinates (display, windowH, root, 0, 0, &wx, &wy, &child))
++            {
++                wx = wy = 0;
++            }
++
++            updateBorderSize();
++            handleMovedOrResized();
++        }
++    }
++};
++
++//==============================================================================
++ComponentPeer* Component::createNewPeer (int styleFlags, void* /*nativeWindowToAttachTo*/)
++{
++    return new LinuxComponentPeer (this, styleFlags);
++}
++
++
++//==============================================================================
++// (this callback is hooked up in the messaging code)
++void juce_windowMessageReceive (XEvent* event)
++{
++    if (event->xany.window != None)
++    {
++        // Check if the event is for one of our windows
++        LinuxComponentPeer* peer = 0;
++
++        if (! XFindContext (display, (XID) event->xany.window, improbableNumber, (XPointer*) &peer))
++        {
++            if (peer != 0 && peer->isValidMessageListener())
++                peer->handleWindowMessage (event);
++        }
++    }
++    else
++    {
++        switch (event->xany.type)
++        {
++            case KeymapNotify:
++            {
++                const XKeymapEvent* const keymapEvent = (const XKeymapEvent*) &event->xkeymap;
++                memcpy (keyStates, keymapEvent->key_vector, 32);
++                break;
++            }
++
++            default:
++                break;
++        }
++    }
++}
++
++//==============================================================================
++void juce_updateMultiMonitorInfo (Array <Rectangle>& monitorCoords, const bool clipToWorkArea)
++{
++#if JUCE_USE_XINERAMA
++    int major_opcode, first_event, first_error;
++
++    if (XQueryExtension (display, "XINERAMA", &major_opcode, &first_event, &first_error)
++         && XineramaIsActive (display))
++    {
++        int numMonitors = 0;
++        XineramaScreenInfo* const screens = XineramaQueryScreens (display, &numMonitors);
++
++        if (screens != 0)
++        {
++            for (int i = numMonitors; --i >= 0;)
++            {
++                int index = screens[i].screen_number;
++
++                if (index >= 0)
++                {
++                    while (monitorCoords.size() < index)
++                        monitorCoords.add (Rectangle (0, 0, 0, 0));
++
++                    monitorCoords.set (index, Rectangle (screens[i].x_org,
++                                                         screens[i].y_org,
++                                                         screens[i].width,
++                                                         screens[i].height));
++                }
++            }
++
++            XFree (screens);
++        }
++    }
++
++    if (monitorCoords.size() == 0)
++#endif
++    {
++        monitorCoords.add (Rectangle (0, 0,
++                                      DisplayWidth (display, DefaultScreen (display)),
++                                      DisplayHeight (display, DefaultScreen (display))));
++    }
++}
++
++//==============================================================================
++bool Desktop::canUseSemiTransparentWindows()
++{
++    return false;
++}
++
++void Desktop::getMousePosition (int& x, int& y)
++{
++    int mouseMods;
++    getMousePos (x, y, mouseMods);
++}
++
++void Desktop::setMousePosition (int x, int y)
++{
++    Window root = RootWindow (display, DefaultScreen (display));
++    XWarpPointer (display, None, root, 0, 0, 0, 0, x, y);
++}
++
++
++//==============================================================================
++void* juce_createMouseCursorFromImage (const Image& image, int hotspotX, int hotspotY)
++{
++    Window root = RootWindow (display, DefaultScreen (display));
++    const unsigned int imageW = image.getWidth();
++    const unsigned int imageH = image.getHeight();
++    unsigned int cursorW, cursorH;
++
++    if (! XQueryBestCursor (display, root, imageW, imageH, &cursorW, &cursorH))
++        return 0;
++
++    Image im (Image::ARGB, cursorW, cursorH, true);
++    Graphics g (im);
++
++    if (imageW > cursorW || imageH > cursorH)
++    {
++        hotspotX = (hotspotX * cursorW) / imageW;
++        hotspotY = (hotspotY * cursorH) / imageH;
++
++        g.drawImageWithin (&image, 0, 0, imageW, imageH,
++                           Justification::topLeft,
++                           false, false);
++    }
++    else
++    {
++        g.drawImageAt (&image, 0, 0);
++    }
++
++    const int stride = (cursorW + 7) >> 3;
++    unsigned char* const maskPlane = (unsigned char*)juce_calloc (stride*cursorH);
++    unsigned char* const sourcePlane = (unsigned char*)juce_calloc (stride*cursorH);
++
++    bool msbfirst = (BitmapBitOrder (display) == MSBFirst);
++
++    for (int y = cursorH; --y >= 0;)
++    {
++        for (int x = cursorW; --x >= 0;)
++        {
++            const unsigned char mask = (unsigned char)(1 << (msbfirst ? (7 - (x & 7)) : (x & 7)));
++            const int offset = y * stride + (x >> 3);
++
++            const Colour c (im.getPixelAt (x, y));
++
++            if (c.getAlpha() >= 128)
++                maskPlane[offset] |= mask;
++
++            if (c.getBrightness() >= 0.5f)
++                sourcePlane[offset] |= mask;
++        }
++    }
++
++    Pixmap sourcePixmap = XCreatePixmapFromBitmapData (display, root, (char*)sourcePlane, cursorW, cursorH, 0xffff, 0, 1);
++    Pixmap maskPixmap = XCreatePixmapFromBitmapData (display, root, (char*)maskPlane, cursorW, cursorH, 0xffff, 0, 1);
++
++    juce_free (maskPlane);
++    juce_free (sourcePlane);
++
++    XColor white, black;
++    black.red = black.green = black.blue = 0;
++    white.red = white.green = white.blue = 0xffff;
++
++    void* result = (void*) XCreatePixmapCursor (display, sourcePixmap, maskPixmap, &white, &black, hotspotX, hotspotY);
++
++    XFreePixmap (display, sourcePixmap);
++    XFreePixmap (display, maskPixmap);
++
++    return result;
++}
++
++void juce_deleteMouseCursor (void* cursorHandle, bool)
++{
++    if (cursorHandle != None)
++        XFreeCursor (display, (Cursor)cursorHandle);
++}
++
++void* juce_createStandardMouseCursor (MouseCursor::StandardCursorType type)
++{
++    unsigned int shape;
++
++    switch (type)
++    {
++        case MouseCursor::NoCursor:
++        {
++            void* invisibleCursor;
++
++            Image im (Image::ARGB, 16, 16, true);
++            invisibleCursor = juce_createMouseCursorFromImage (im, 0, 0);
++
++            return invisibleCursor;
++        }
++
++        case MouseCursor::NormalCursor:
++            return (void*) None; // Use parent cursor
++
++        case MouseCursor::DraggingHandCursor:
++        {
++            void* dragHandCursor;
++            static unsigned char dragHandData[] = {71,73,70,56,57,97,16,0,16,0,145,2,0,0,0,0,255,255,255,0,
++              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,
++              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 };
++            const int dragHandDataSize = 99;
++
++            Image* im = ImageFileFormat::loadFrom ((const char*) dragHandData, dragHandDataSize);
++            dragHandCursor = juce_createMouseCursorFromImage (*im, 8, 7);
++            delete im;
++
++            return dragHandCursor;
++        }
++
++        case MouseCursor::CopyingCursor:
++        {
++            void* copyCursor;
++
++            static unsigned char copyCursorData[] = {71,73,70,56,57,97,21,0,21,0,145,0,0,0,0,0,255,255,255,0,
++              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,
++              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,
++              252,114,147,74,83,5,50,68,147,208,217,16,71,149,252,124,5,0,59,0,0 };
++            const int copyCursorSize = 119;
++
++            Image* im = ImageFileFormat::loadFrom ((const char*)copyCursorData, copyCursorSize);
++            copyCursor = juce_createMouseCursorFromImage (*im, 1, 3);
++            delete im;
++
++            return copyCursor;
++        }
++
++        case MouseCursor::WaitCursor:
++            shape = XC_watch;
++            break;
++
++        case MouseCursor::IBeamCursor:
++            shape = XC_xterm;
++            break;
++
++        case MouseCursor::PointingHandCursor:
++            shape = XC_hand2;
++            break;
++
++        case MouseCursor::LeftRightResizeCursor:
++            shape = XC_sb_h_double_arrow;
++            break;
++
++        case MouseCursor::UpDownResizeCursor:
++            shape = XC_sb_v_double_arrow;
++            break;
++
++        case MouseCursor::UpDownLeftRightResizeCursor:
++            shape = XC_fleur;
++            break;
++
++        case MouseCursor::TopEdgeResizeCursor:
++            shape = XC_top_side;
++            break;
++
++        case MouseCursor::BottomEdgeResizeCursor:
++            shape = XC_bottom_side;
++            break;
++
++        case MouseCursor::LeftEdgeResizeCursor:
++            shape = XC_left_side;
++            break;
++
++        case MouseCursor::RightEdgeResizeCursor:
++            shape = XC_right_side;
++            break;
++
++        case MouseCursor::TopLeftCornerResizeCursor:
++            shape = XC_top_left_corner;
++            break;
++
++        case MouseCursor::TopRightCornerResizeCursor:
++            shape = XC_top_right_corner;
++            break;
++
++        case MouseCursor::BottomLeftCornerResizeCursor:
++            shape = XC_bottom_left_corner;
++            break;
++
++        case MouseCursor::BottomRightCornerResizeCursor:
++            shape = XC_bottom_right_corner;
++            break;
++
++        case MouseCursor::CrosshairCursor:
++            shape = XC_crosshair;
++            break;
++
++        default:
++            return (void*) None; // Use parent cursor
++    }
++
++    return (void*) XCreateFontCursor (display, shape);
++}
++
++void MouseCursor::showInWindow (ComponentPeer* peer) const
++{
++    LinuxComponentPeer* const lp = dynamic_cast <LinuxComponentPeer*> (peer);
++
++    if (lp != 0)
++        lp->showMouseCursor ((Cursor) getHandle());
++}
++
++void MouseCursor::showInAllWindows() const
++{
++    for (int i = ComponentPeer::getNumPeers(); --i >= 0;)
++        showInWindow (ComponentPeer::getPeer (i));
++}
++
++//==============================================================================
++Image* juce_createIconForFile (const File& file)
++{
++    return 0;
++}
++
++
++//==============================================================================
++#if JUCE_OPENGL
++
++struct OpenGLContextInfo
++{
++    Window embeddedWindow;
++    GLXContext renderContext;
++};
++
++void* juce_createOpenGLContext (OpenGLComponent* component, void* sharedContext)
++{
++    XSync (display, False);
++    jassert (component != 0);
++
++    if (component == 0)
++        return 0;
++
++    LinuxComponentPeer* const peer
++        = dynamic_cast <LinuxComponentPeer*> (component->getTopLevelComponent()->getPeer());
++
++    if (peer == 0)
++        return 0;
++
++    GLint attribList[] =
++    {
++        GLX_RGBA,
++        GLX_DOUBLEBUFFER,
++        GLX_RED_SIZE, 8,
++        GLX_GREEN_SIZE, 8,
++        GLX_BLUE_SIZE, 8,
++        GLX_ALPHA_SIZE, 8,
++        GLX_DEPTH_SIZE, 8,
++        None
++    };
++
++    XVisualInfo* const bestVisual = glXChooseVisual (display, DefaultScreen (display), attribList);
++
++    if (bestVisual == 0)
++        return 0;
++
++    OpenGLContextInfo* const oc = new OpenGLContextInfo();
++
++    oc->renderContext = glXCreateContext (display, bestVisual,
++                                          (sharedContext != 0) ? ((OpenGLContextInfo*) sharedContext)->renderContext
++                                                               : 0,
++                                          GL_TRUE);
++
++    Window windowH = (Window) peer->getNativeHandle();
++
++    Colormap colourMap = XCreateColormap (display, windowH, bestVisual->visual, AllocNone);
++    XSetWindowAttributes swa;
++    swa.colormap = colourMap;
++    swa.border_pixel = 0;
++    swa.event_mask = StructureNotifyMask;
++
++    oc->embeddedWindow = XCreateWindow (display, windowH,
++                                        0, 0, 1, 1, 0,
++                                        bestVisual->depth,
++                                        InputOutput,
++                                        bestVisual->visual,
++                                        CWBorderPixel | CWColormap | CWEventMask,
++                                        &swa);
++
++    XMapWindow (display, oc->embeddedWindow);
++    XFreeColormap (display, colourMap);
++
++    XFree (bestVisual);
++    XSync (display, False);
++
++    return oc;
++}
++
++void juce_updateOpenGLWindowPos (void* context, Component* owner, Component* topComp)
++{
++    jassert (context != 0);
++    OpenGLContextInfo* const oc = (OpenGLContextInfo*) context;
++
++    XMoveResizeWindow (display, oc->embeddedWindow,
++                       owner->getScreenX() - topComp->getScreenX(),
++                       owner->getScreenY() - topComp->getScreenY(),
++                       jmax (1, owner->getWidth()),
++                       jmax (1, owner->getHeight()));
++}
++
++void juce_deleteOpenGLContext (void* context)
++{
++    OpenGLContextInfo* const oc = (OpenGLContextInfo*) context;
++
++    if (oc != 0)
++    {
++        glXDestroyContext (display, oc->renderContext);
++
++        XUnmapWindow (display, oc->embeddedWindow);
++        XDestroyWindow (display, oc->embeddedWindow);
++
++        delete oc;
++    }
++}
++
++bool juce_makeOpenGLContextCurrent (void* context)
++{
++    OpenGLContextInfo* const oc = (OpenGLContextInfo*) context;
++
++    if (oc != 0)
++        return glXMakeCurrent (display, oc->embeddedWindow, oc->renderContext)
++                && XSync (display, False);
++    else
++        return glXMakeCurrent (display, None, 0);
++}
++
++void juce_swapOpenGLBuffers (void* context)
++{
++    OpenGLContextInfo* const oc = (OpenGLContextInfo*) context;
++
++    if (oc != 0)
++        glXSwapBuffers (display, oc->embeddedWindow);
++}
++
++void juce_repaintOpenGLWindow (void* context)
++{
++}
++
++#endif
++
++
++//==============================================================================
++static void initClipboard (Window root, Atom* cutBuffers)
++{
++    static bool init = false;
++
++    if (! init)
++    {
++        init = true;
++
++        // Make sure all cut buffers exist before use
++        for (int i = 0; i < 8; i++)
++        {
++            XChangeProperty (display, root, cutBuffers[i],
++                             XA_STRING, 8, PropModeAppend, NULL, 0);
++        }
++    }
++}
++
++// Clipboard implemented currently using cut buffers
++// rather than the more powerful selection method
++void SystemClipboard::copyTextToClipboard (const String& clipText)
++{
++    Window root = RootWindow (display, DefaultScreen (display));
++    Atom cutBuffers[8] = { XA_CUT_BUFFER0, XA_CUT_BUFFER1, XA_CUT_BUFFER2, XA_CUT_BUFFER3,
++                           XA_CUT_BUFFER4, XA_CUT_BUFFER5, XA_CUT_BUFFER6, XA_CUT_BUFFER7 };
++
++    initClipboard (root, cutBuffers);
++
++    XRotateWindowProperties (display, root, cutBuffers, 8, 1);
++    XChangeProperty (display, root, cutBuffers[0],
++                     XA_STRING, 8, PropModeReplace, (const unsigned char*)((const char*)clipText),
++                     clipText.length());
++}
++
++const String SystemClipboard::getTextFromClipboard()
++{
++    char* clipData;
++    const int bufSize = 64;  // in words
++    int actualFormat;
++    int byteOffset = 0;
++    unsigned long bytesLeft, nitems;
++    Atom actualType;
++    String returnData;
++
++    Window root = RootWindow (display, DefaultScreen (display));
++
++    Atom cutBuffers[8] = { XA_CUT_BUFFER0, XA_CUT_BUFFER1, XA_CUT_BUFFER2, XA_CUT_BUFFER3,
++                           XA_CUT_BUFFER4, XA_CUT_BUFFER5, XA_CUT_BUFFER6, XA_CUT_BUFFER7 };
++
++    initClipboard (root, cutBuffers);
++
++    do
++    {
++        if (XGetWindowProperty (display, root, cutBuffers[0], byteOffset >> 2, bufSize,
++                                False, XA_STRING, &actualType, &actualFormat, &nitems, &bytesLeft,
++                                (unsigned char**) &clipData) != Success
++            || actualType != XA_STRING
++            || actualFormat != 8)
++            return String();
++
++        byteOffset += nitems;
++        returnData += String(clipData, nitems);
++        XFree (clipData);
++    }
++    while (bytesLeft);
++
++    return returnData;
++}
++
++//==============================================================================
++bool DragAndDropContainer::performExternalDragDropOfFiles (const StringArray& files, const bool canMoveFiles)
++{
++    jassertfalse    // not implemented!
++    return false;
++}
++
++bool DragAndDropContainer::performExternalDragDropOfText (const String& text)
++{
++    jassertfalse    // not implemented!
++    return false;
++}
++
++
++//==============================================================================
++void PlatformUtilities::beep()
++{
++    //xxx
++}
++
++
++//==============================================================================
++bool AlertWindow::showNativeDialogBox (const String& title,
++                                       const String& bodyText,
++                                       bool isOkCancel)
++{
++    // xxx this is supposed to pop up an alert!
++    Logger::outputDebugString (title + ": " + bodyText);
++    return true;
++}
++
++//==============================================================================
++const int KeyPress::spaceKey            = XK_space & 0xff;
++const int KeyPress::returnKey           = XK_Return & 0xff;
++const int KeyPress::escapeKey           = XK_Escape & 0xff;
++const int KeyPress::backspaceKey        = XK_BackSpace & 0xff;
++const int KeyPress::leftKey             = (XK_Left & 0xff) | nonAsciiModifier;
++const int KeyPress::rightKey            = (XK_Right & 0xff) | nonAsciiModifier;
++const int KeyPress::upKey               = (XK_Up & 0xff) | nonAsciiModifier;
++const int KeyPress::downKey             = (XK_Down & 0xff) | nonAsciiModifier;
++const int KeyPress::pageUpKey           = (XK_Page_Up & 0xff) | nonAsciiModifier;
++const int KeyPress::pageDownKey         = (XK_Page_Down & 0xff) | nonAsciiModifier;
++const int KeyPress::endKey              = (XK_End & 0xff) | nonAsciiModifier;
++const int KeyPress::homeKey             = (XK_Home & 0xff) | nonAsciiModifier;
++const int KeyPress::insertKey           = (XK_Insert & 0xff) | nonAsciiModifier;
++const int KeyPress::deleteKey           = (XK_Delete & 0xff) | nonAsciiModifier;
++const int KeyPress::tabKey              = XK_Tab & 0xff;
++const int KeyPress::F1Key               = (XK_F1 & 0xff) | nonAsciiModifier;
++const int KeyPress::F2Key               = (XK_F2 & 0xff) | nonAsciiModifier;
++const int KeyPress::F3Key               = (XK_F3 & 0xff) | nonAsciiModifier;
++const int KeyPress::F4Key               = (XK_F4 & 0xff) | nonAsciiModifier;
++const int KeyPress::F5Key               = (XK_F5 & 0xff) | nonAsciiModifier;
++const int KeyPress::F6Key               = (XK_F6 & 0xff) | nonAsciiModifier;
++const int KeyPress::F7Key               = (XK_F7 & 0xff) | nonAsciiModifier;
++const int KeyPress::F8Key               = (XK_F8 & 0xff) | nonAsciiModifier;
++const int KeyPress::F9Key               = (XK_F9 & 0xff) | nonAsciiModifier;
++const int KeyPress::F10Key              = (XK_F10 & 0xff) | nonAsciiModifier;
++const int KeyPress::F11Key              = (XK_F11 & 0xff) | nonAsciiModifier;
++const int KeyPress::F12Key              = (XK_F12 & 0xff) | nonAsciiModifier;
++const int KeyPress::playKey             = (0xffeeff00) | nonAsciiModifier;
++const int KeyPress::stopKey             = (0xffeeff01) | nonAsciiModifier;
++const int KeyPress::fastForwardKey      = (0xffeeff02) | nonAsciiModifier;
++const int KeyPress::rewindKey           = (0xffeeff03) | nonAsciiModifier;
++
++
++END_JUCE_NAMESPACE
++
++#endif
diff --git a/packages/juce/files/remove-x86isms.patch b/packages/juce/files/remove-x86isms.patch
new file mode 100644
index 0000000000..83016f733a
--- /dev/null
+++ b/packages/juce/files/remove-x86isms.patch
@@ -0,0 +1,2353 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- juce/src/juce_core/basics/juce_Atomic.h~remove-x86isms.patch
++++ juce/src/juce_core/basics/juce_Atomic.h
+@@ -1,188 +1,200 @@
+-/*

+-  ==============================================================================

+-

+-   This file is part of the JUCE library - "Jules' Utility Class Extensions"

+-   Copyright 2004-6 by Raw Material Software ltd.

+-

+-  ------------------------------------------------------------------------------

+-

+-   JUCE can be redistributed and/or modified under the terms of the

+-   GNU General Public License, as published by the Free Software Foundation;

+-   either version 2 of the License, or (at your option) any later version.

+-

+-   JUCE is distributed in the hope that it will be useful,

+-   but WITHOUT ANY WARRANTY; without even the implied warranty of

+-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+-   GNU General Public License for more details.

+-

+-   You should have received a copy of the GNU General Public License

+-   along with JUCE; if not, visit www.gnu.org/licenses or write to the

+-   Free Software Foundation, Inc., 59 Temple Place, Suite 330, 

+-   Boston, MA 02111-1307 USA

+-

+-  ------------------------------------------------------------------------------

+-

+-   If you'd like to release a closed-source product which uses JUCE, commercial

+-   licenses are also available: visit www.rawmaterialsoftware.com/juce for

+-   more information.

+-

+-  ==============================================================================

+-*/

+-

+-#ifndef __JUCE_ATOMIC_JUCEHEADER__

+-#define __JUCE_ATOMIC_JUCEHEADER__

+-

+-// Atomic increment/decrement operations..

+-

+-//==============================================================================

+-#if JUCE_MAC && ! DOXYGEN

+-  #if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)

+-    #include <libkern/OSAtomic.h>

+-

+-    forcedinline void atomicIncrement (int& variable) throw()

+-    {

+-        OSAtomicIncrement32 ((int32_t*) &variable);

+-    }

+-

+-    forcedinline int atomicIncrementAndReturn (int& variable) throw()

+-    {

+-        return OSAtomicIncrement32 ((int32_t*) &variable);

+-    }

+-

+-    forcedinline void atomicDecrement (int& variable) throw()

+-    {

+-        OSAtomicDecrement32 ((int32_t*) &variable);

+-    }

+-

+-    forcedinline int atomicDecrementAndReturn (int& variable) throw()

+-    {

+-       return OSAtomicDecrement32 ((int32_t*) &variable);

+-    }

+-

+-  #else

+-    forcedinline void atomicIncrement (int& variable) throw()

+-    {

+-       OTAtomicAdd32 (1, (SInt32*) &variable);

+-    }

+-

+-    forcedinline int atomicIncrementAndReturn (int& variable) throw()

+-    {

+-       return OTAtomicAdd32 (1, (SInt32*) &variable);

+-    }

+-

+-    forcedinline void atomicDecrement (int& variable) throw()

+-    {

+-       OTAtomicAdd32 (-1, (SInt32*) &variable);

+-    }

+-

+-    forcedinline int atomicDecrementAndReturn (int& variable) throw()

+-    {

+-       return OTAtomicAdd32 (-1, (SInt32*) &variable);

+-    }

+-  #endif

+-#else

+-#ifdef __GNUC__

+-

+-    /** Increments an integer in a thread-safe way. */

+-    forcedinline void atomicIncrement (int& variable) throw()

+-    {

+-        __asm__ __volatile (

+-            "lock incl (%%ecx)"

+-            :

+-            : "c" (&variable));

+-    }

+-

+-    /** Increments an integer in a thread-safe way and returns the incremented value. */

+-    forcedinline int atomicIncrementAndReturn (int& variable) throw()

+-    {

+-        int result;

+-

+-        __asm__ __volatile (

+-            "lock xaddl %%eax, (%%ebx)  \n\

+-             incl %%eax"

+-            : "=a" (result)

+-            : "b" (&variable), "a" (1)

+-            : "cc", "memory");

+-

+-        return result;

+-    }

+-

+-    /** Decrememts an integer in a thread-safe way. */

+-    forcedinline void atomicDecrement (int& variable) throw()

+-    {

+-        __asm__ __volatile (

+-            "lock decl (%%ecx)"

+-            :

+-            : "c" (&variable));

+-    }

+-

+-    /** Decrememts an integer in a thread-safe way and returns the incremented value. */

+-    forcedinline int atomicDecrementAndReturn (int& variable) throw()

+-    {

+-        int result;

+-

+-        __asm__ __volatile (

+-            "lock xaddl %%eax, (%%ebx)  \n\

+-             decl %%eax"

+-            : "=a" (result)

+-            : "b" (&variable), "a" (-1)

+-            : "cc", "memory");

+-

+-        return result;

+-    }

+-

+-#else

+-

+-    /** Increments an integer in a thread-safe way. */

+-    inline_assembly void __fastcall atomicIncrement (int& variable) throw()

+-    {

+-        __asm {

+-            mov ecx, dword ptr [variable]

+-            lock inc dword ptr [ecx]

+-        }

+-    }

+-

+-    /** Increments an integer in a thread-safe way and returns the incremented value. */

+-    inline_assembly int __fastcall atomicIncrementAndReturn (int& variable) throw()

+-    {

+-        int result;

+-

+-        __asm {

+-            mov ecx, dword ptr [variable]

+-            mov eax, 1

+-            lock xadd dword ptr [ecx], eax

+-            inc eax

+-            mov result, eax

+-        }

+-

+-        return result;

+-    }

+-

+-    /** Decrememts an integer in a thread-safe way. */

+-    inline_assembly void __fastcall atomicDecrement (int& variable) throw()

+-    {

+-        __asm {

+-            mov ecx, dword ptr [variable]

+-            lock dec dword ptr [ecx]

+-        }

+-    }

+-

+-    /** Decrememts an integer in a thread-safe way and returns the incremented value. */

+-    inline_assembly int __fastcall atomicDecrementAndReturn (int& variable) throw()

+-    {

+-        int result;

+-

+-        __asm {

+-            mov ecx, dword ptr [variable]

+-            mov eax, -1

+-            lock xadd dword ptr [ecx], eax

+-            dec eax

+-            mov result, eax

+-        }

+-

+-        return result;

+-    }

+-#endif

+-#endif

+-

+-#endif   // __JUCE_ATOMIC_JUCEHEADER__

++/*
++  ==============================================================================
++
++   This file is part of the JUCE library - "Jules' Utility Class Extensions"
++   Copyright 2004-6 by Raw Material Software ltd.
++
++  ------------------------------------------------------------------------------
++
++   JUCE can be redistributed and/or modified under the terms of the
++   GNU General Public License, as published by the Free Software Foundation;
++   either version 2 of the License, or (at your option) any later version.
++
++   JUCE is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++
++   You should have received a copy of the GNU General Public License
++   along with JUCE; if not, visit www.gnu.org/licenses or write to the
++   Free Software Foundation, Inc., 59 Temple Place, Suite 330, 
++   Boston, MA 02111-1307 USA
++
++  ------------------------------------------------------------------------------
++
++   If you'd like to release a closed-source product which uses JUCE, commercial
++   licenses are also available: visit www.rawmaterialsoftware.com/juce for
++   more information.
++
++  ==============================================================================
++*/
++
++#ifndef __JUCE_ATOMIC_JUCEHEADER__
++#define __JUCE_ATOMIC_JUCEHEADER__
++
++// Atomic increment/decrement operations..
++
++//==============================================================================
++#if JUCE_MAC && ! DOXYGEN
++  #if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)
++    #include <libkern/OSAtomic.h>
++
++    forcedinline void atomicIncrement (int& variable) throw()
++    {
++        OSAtomicIncrement32 ((int32_t*) &variable);
++    }
++
++    forcedinline int atomicIncrementAndReturn (int& variable) throw()
++    {
++        return OSAtomicIncrement32 ((int32_t*) &variable);
++    }
++
++    forcedinline void atomicDecrement (int& variable) throw()
++    {
++        OSAtomicDecrement32 ((int32_t*) &variable);
++    }
++
++    forcedinline int atomicDecrementAndReturn (int& variable) throw()
++    {
++       return OSAtomicDecrement32 ((int32_t*) &variable);
++    }
++
++  #else
++    forcedinline void atomicIncrement (int& variable) throw()
++    {
++       OTAtomicAdd32 (1, (SInt32*) &variable);
++    }
++
++    forcedinline int atomicIncrementAndReturn (int& variable) throw()
++    {
++       return OTAtomicAdd32 (1, (SInt32*) &variable);
++    }
++
++    forcedinline void atomicDecrement (int& variable) throw()
++    {
++       OTAtomicAdd32 (-1, (SInt32*) &variable);
++    }
++
++    forcedinline int atomicDecrementAndReturn (int& variable) throw()
++    {
++       return OTAtomicAdd32 (-1, (SInt32*) &variable);
++    }
++  #endif
++#else
++#ifdef __GNUC__
++
++    /** Increments an integer in a thread-safe way. */
++    forcedinline void atomicIncrement (int& variable) throw()
++    {
++#ifndef __x86__
++        variable++;
++#else
++        __asm__ __volatile (
++            "lock incl (%%ecx)"
++            :
++            : "c" (&variable));
++#endif
++    }
++
++    /** Increments an integer in a thread-safe way and returns the incremented value. */
++    forcedinline int atomicIncrementAndReturn (int& variable) throw()
++    {
++        int result;
++#ifndef __x86__
++        result = ++variable;
++#else
++        __asm__ __volatile (
++            "lock xaddl %%eax, (%%ebx)  \n\
++             incl %%eax"
++            : "=a" (result)
++            : "b" (&variable), "a" (1)
++            : "cc", "memory");
++#endif
++        return result;
++    }
++
++    /** Decrememts an integer in a thread-safe way. */
++    forcedinline void atomicDecrement (int& variable) throw()
++    {
++#ifndef __x86__
++        variable--;
++#else
++        __asm__ __volatile (
++            "lock decl (%%ecx)"
++            :
++            : "c" (&variable));
++#endif
++    }
++
++    /** Decrememts an integer in a thread-safe way and returns the incremented value. */
++    forcedinline int atomicDecrementAndReturn (int& variable) throw()
++    {
++        int result;
++#ifndef __x86__
++        result = --variable;
++#else
++        __asm__ __volatile (
++            "lock xaddl %%eax, (%%ebx)  \n\
++             decl %%eax"
++            : "=a" (result)
++            : "b" (&variable), "a" (-1)
++            : "cc", "memory");
++#endif
++        return result;
++    }
++
++#else
++
++    /** Increments an integer in a thread-safe way. */
++    inline_assembly void __fastcall atomicIncrement (int& variable) throw()
++    {
++        __asm {
++            mov ecx, dword ptr [variable]
++            lock inc dword ptr [ecx]
++        }
++    }
++
++    /** Increments an integer in a thread-safe way and returns the incremented value. */
++    inline_assembly int __fastcall atomicIncrementAndReturn (int& variable) throw()
++    {
++        int result;
++
++        __asm {
++            mov ecx, dword ptr [variable]
++            mov eax, 1
++            lock xadd dword ptr [ecx], eax
++            inc eax
++            mov result, eax
++        }
++
++        return result;
++    }
++
++    /** Decrememts an integer in a thread-safe way. */
++    inline_assembly void __fastcall atomicDecrement (int& variable) throw()
++    {
++        __asm {
++            mov ecx, dword ptr [variable]
++            lock dec dword ptr [ecx]
++        }
++    }
++
++    /** Decrememts an integer in a thread-safe way and returns the incremented value. */
++    inline_assembly int __fastcall atomicDecrementAndReturn (int& variable) throw()
++    {
++        int result;
++
++        __asm {
++            mov ecx, dword ptr [variable]
++            mov eax, -1
++            lock xadd dword ptr [ecx], eax
++            dec eax
++            mov result, eax
++        }
++
++        return result;
++    }
++#endif
++#endif
++
++#endif   // __JUCE_ATOMIC_JUCEHEADER__
+--- juce/src/juce_core/basics/juce_PlatformDefs.h~remove-x86isms.patch
++++ juce/src/juce_core/basics/juce_PlatformDefs.h
+@@ -1,326 +1,330 @@
+-/*

+-  ==============================================================================

+-

+-   This file is part of the JUCE library - "Jules' Utility Class Extensions"

+-   Copyright 2004-6 by Raw Material Software ltd.

+-

+-  ------------------------------------------------------------------------------

+-

+-   JUCE can be redistributed and/or modified under the terms of the

+-   GNU General Public License, as published by the Free Software Foundation;

+-   either version 2 of the License, or (at your option) any later version.

+-

+-   JUCE is distributed in the hope that it will be useful,

+-   but WITHOUT ANY WARRANTY; without even the implied warranty of

+-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+-   GNU General Public License for more details.

+-

+-   You should have received a copy of the GNU General Public License

+-   along with JUCE; if not, visit www.gnu.org/licenses or write to the

+-   Free Software Foundation, Inc., 59 Temple Place, Suite 330, 

+-   Boston, MA 02111-1307 USA

+-

+-  ------------------------------------------------------------------------------

+-

+-   If you'd like to release a closed-source product which uses JUCE, commercial

+-   licenses are also available: visit www.rawmaterialsoftware.com/juce for

+-   more information.

+-

+-  ==============================================================================

+-*/

+-

+-#ifndef __JUCE_PLATFORMDEFS_JUCEHEADER__

+-#define __JUCE_PLATFORMDEFS_JUCEHEADER__

+-

+-

+-//==============================================================================

+-// set up platform definitions..

+-#ifdef _WIN32

+-  #define       JUCE_WIN32 1

+-  #define       JUCE_WINDOWS 1

+-#else

+-  #ifdef LINUX

+-    #define     JUCE_LINUX 1

+-  #else

+-    #define     JUCE_MAC 1

+-  #endif

+-#endif

+-

+-//==============================================================================

+-#ifdef JUCE_WINDOWS

+-  #ifdef _MSC_VER

+-    #ifdef _WIN64

+-      #define JUCE_64BIT 1

+-    #else

+-      #define JUCE_32BIT 1

+-    #endif

+-  #endif

+-

+-  #ifdef _DEBUG

+-    #define JUCE_DEBUG 1

+-  #endif

+-

+-  /** If defined, this indicates that the processor is little-endian. */

+-  #define JUCE_LITTLE_ENDIAN 1

+-

+-  #define JUCE_INTEL 1

+-#endif

+-

+-//==============================================================================

+-#ifdef JUCE_MAC

+-

+-  #include <CoreServices/CoreServices.h>

+-  #include <wchar.h>

+-

+-  #ifndef NDEBUG

+-    #define JUCE_DEBUG 1

+-  #endif

+-

+-  #ifdef __LITTLE_ENDIAN__

+-    #define JUCE_LITTLE_ENDIAN 1

+-  #else

+-    #define JUCE_BIG_ENDIAN 1

+-  #endif

+-

+-  #if defined (__ppc__) || defined (__ppc64__)

+-    #define JUCE_PPC 1

+-  #else

+-    #define JUCE_INTEL 1

+-  #endif

+-

+-  #ifdef __LP64__

+-    #define JUCE_64BIT 1

+-  #else

+-    #define JUCE_32BIT 1

+-  #endif

+-#endif

+-

+-//==============================================================================

+-#ifdef JUCE_LINUX

+-

+-  #ifdef _DEBUG

+-    #define JUCE_DEBUG 1

+-  #endif

+-

+-  #include <wchar.h>

+-

+-  // Allow override for big-endian Linux platforms

+-  #ifndef JUCE_BIG_ENDIAN

+-    #define JUCE_LITTLE_ENDIAN 1

+-  #endif

+-

+-  #if defined (__LP64__) || defined (_LP64)

+-    #define JUCE_64BIT 1

+-  #else

+-    #define JUCE_32BIT 1

+-  #endif

+-

+-  #define JUCE_INTEL 1

+-#endif

+-

+-//==============================================================================

+-#if defined (__GNUC__) || defined (__MWERKS__)

+-    /** A platform-independent 64-bit integer type. */

+-    typedef long long           int64;

+-    /** A platform-independent 64-bit unsigned integer type. */

+-    typedef unsigned long long  uint64;

+-    /** A platform-independent unicode character type. */

+-    typedef wchar_t             juce_wchar;

+-

+-    /** A platform-independent way of forcing an inline function.

+-

+-      Use the syntax: @code

+-        forcedinline void myfunction (int x)

+-      @endcode

+-    */

+-    #ifndef JUCE_DEBUG

+-      #define forcedinline  inline __attribute__((always_inline))

+-    #else

+-      #define forcedinline  inline

+-    #endif

+-

+-    /** A platform-independent way of stopping the compiler inlining a function.

+-

+-      Use the syntax: @code

+-        juce_noinline void myfunction (int x)

+-      @endcode

+-    */

+-    #define juce_noinline __attribute__((noinline))

+-

+-#else

+-    //==============================================================================

+-    /** A platform-independent 64-bit integer type. */

+-    typedef __int64             int64;

+-    /** A platform-independent 64-bit unsigned integer type. */

+-    typedef unsigned __int64    uint64;

+-

+-    /** A platform-independent unicode character type. */

+-    typedef wchar_t             juce_wchar;

+-

+-    /** A platform-independent way of forcing an inline function.

+-

+-      Use the syntax: @code

+-        forcedinline void myfunction (int x)

+-      @endcode

+-    */

+-    #ifdef _MSC_VER

+-      #define forcedinline  __forceinline

+-    #else

+-      #define forcedinline  inline

+-    #endif

+-

+-    /** A platform-independent way of stopping the compiler inlining a function.

+-

+-      Use the syntax: @code

+-        juce_noinline void myfunction (int x)

+-      @endcode

+-    */

+-    #define juce_noinline

+-

+-#endif

+-

+-#if JUCE_64BIT

+-   typedef int64                   pointer_sized_int;

+-   typedef uint64                  pointer_sized_uint;

+-#else

+-  #if _MSC_VER >= 1300

+-     typedef _W64 int              pointer_sized_int;

+-     typedef _W64 unsigned int     pointer_sized_uint;

+-  #else

+-     typedef int                   pointer_sized_int;

+-     typedef unsigned int          pointer_sized_uint;

+-  #endif

+-#endif

+-

+-

+-// borland can't handle inline functions containing asm code, so define a

+-// special type of inline modifier for this kind of function. Sigh..

+-#ifdef __BORLANDC__

+-  #define inline_assembly

+-#else

+-  #define inline_assembly forcedinline

+-#endif

+-

+-//==============================================================================

+-typedef signed char     int8;

+-typedef unsigned char   uint8;

+-typedef signed short    int16;

+-typedef unsigned short  uint16;

+-typedef signed int      int32;

+-typedef unsigned int    uint32;

+-

+-

+-//==============================================================================

+-// Debugging macros

+-//

+-

+-#ifdef JUCE_DEBUG

+-  //==============================================================================

+-  // If debugging is enabled..

+-

+-  /** Writes a string to the standard error stream.

+-

+-    This is only compiled in a debug build.

+-

+-    @see Logger::outputDebugString

+-  */

+-  #define DBG(dbgtext)              Logger::outputDebugString (dbgtext);

+-

+-  /** Printf's a string to the standard error stream.

+-

+-    This is only compiled in a debug build.

+-

+-    @see Logger::outputDebugString

+-  */

+-  #define DBG_PRINTF(dbgprintf)     Logger::outputDebugPrintf dbgprintf;

+-

+-  // Assertions..

+-  #if defined (_MSC_VER) || DOXYGEN

+-    /** This will always cause an assertion failure.

+-

+-        This is only compiled in a debug build.

+-

+-        @see jassert()

+-    */

+-    #ifdef __BORLANDC__

+-      extern void juce_StopInDebugger();

+-      #define jassertfalse          { juce_StopInDebugger(); }

+-    #else

+-      #define jassertfalse          { __asm int 3 }

+-    #endif

+-  #elif defined (JUCE_MAC)

+-    #define jassertfalse            { Debugger(); }

+-  #elif defined (__GNUC__) || defined (JUCE_LINUX)

+-    #define jassertfalse            { asm("int $3"); }

+-  #endif

+-

+-  //==============================================================================

+-  /** Platform-independent assertion macro.

+-

+-    This gets optimised out when not being built with debugging turned on.

+-

+-    Be careful not to call any functions within its arguments that are vital to

+-    the behaviour of the program, because these won't get called in the release

+-    build.

+-

+-    @see jassertfalse

+-  */

+-  #define jassert(a)                { if (! (a)) jassertfalse }

+-

+-#else

+-  //==============================================================================

+-  // If debugging is disabled, disable all the assertions and debugging stuff..

+-

+-  #define DBG(dbgtext)

+-  #define DBG_PRINTF(dbgprintf)

+-

+-  #define jassert(a)        {}

+-  #define jassertfalse      {}

+-

+-#endif

+-

+-//==============================================================================

+-#ifndef DOXYGEN

+- template <bool b> struct JuceStaticAssert;

+- template <> struct JuceStaticAssert <true> { static void dummy() {} };

+-#endif

+-

+-/** A compile-time assertion macro.

+-

+-    If the expression parameter is false, the macro will cause a compile error.

+-*/

+-#define static_jassert(expression)      JuceStaticAssert<expression>::dummy();

+-

+-

+-//==============================================================================

+-#if JUCE_CATCH_UNHANDLED_EXCEPTIONS

+-

+-  #define JUCE_TRY try

+-

+-  /** Used in try-catch blocks, this macro will send exceptions to the JUCEApplication

+-      object so they can be logged by the application if it wants to.

+-  */

+-  #define JUCE_CATCH_EXCEPTION \

+-    catch (const std::exception& e)  \

+-    { \

+-        JUCEApplication::sendUnhandledException (&e, __FILE__, __LINE__); \

+-    } \

+-    catch (...) \

+-    { \

+-        JUCEApplication::sendUnhandledException (0, __FILE__, __LINE__); \

+-    }

+-

+-  #define JUCE_CATCH_ALL            catch (...) {}

+-  #define JUCE_CATCH_ALL_ASSERT     catch (...) { jassertfalse }

+-

+-#else

+-

+-  #define JUCE_TRY

+-  #define JUCE_CATCH_EXCEPTION

+-  #define JUCE_CATCH_ALL

+-  #define JUCE_CATCH_ALL_ASSERT

+-

+-#endif

+-

+-

+-#endif   // __JUCE_PLATFORMDEFS_JUCEHEADER__

++/*
++  ==============================================================================
++
++   This file is part of the JUCE library - "Jules' Utility Class Extensions"
++   Copyright 2004-6 by Raw Material Software ltd.
++
++  ------------------------------------------------------------------------------
++
++   JUCE can be redistributed and/or modified under the terms of the
++   GNU General Public License, as published by the Free Software Foundation;
++   either version 2 of the License, or (at your option) any later version.
++
++   JUCE is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++
++   You should have received a copy of the GNU General Public License
++   along with JUCE; if not, visit www.gnu.org/licenses or write to the
++   Free Software Foundation, Inc., 59 Temple Place, Suite 330, 
++   Boston, MA 02111-1307 USA
++
++  ------------------------------------------------------------------------------
++
++   If you'd like to release a closed-source product which uses JUCE, commercial
++   licenses are also available: visit www.rawmaterialsoftware.com/juce for
++   more information.
++
++  ==============================================================================
++*/
++
++#ifndef __JUCE_PLATFORMDEFS_JUCEHEADER__
++#define __JUCE_PLATFORMDEFS_JUCEHEADER__
++
++
++//==============================================================================
++// set up platform definitions..
++#ifdef _WIN32
++  #define       JUCE_WIN32 1
++  #define       JUCE_WINDOWS 1
++#else
++  #ifdef LINUX
++    #define     JUCE_LINUX 1
++  #else
++    #define     JUCE_MAC 1
++  #endif
++#endif
++
++//==============================================================================
++#ifdef JUCE_WINDOWS
++  #ifdef _MSC_VER
++    #ifdef _WIN64
++      #define JUCE_64BIT 1
++    #else
++      #define JUCE_32BIT 1
++    #endif
++  #endif
++
++  #ifdef _DEBUG
++    #define JUCE_DEBUG 1
++  #endif
++
++  /** If defined, this indicates that the processor is little-endian. */
++  #define JUCE_LITTLE_ENDIAN 1
++
++  #define JUCE_INTEL 1
++#endif
++
++//==============================================================================
++#ifdef JUCE_MAC
++
++  #include <CoreServices/CoreServices.h>
++  #include <wchar.h>
++
++  #ifndef NDEBUG
++    #define JUCE_DEBUG 1
++  #endif
++
++  #ifdef __LITTLE_ENDIAN__
++    #define JUCE_LITTLE_ENDIAN 1
++  #else
++    #define JUCE_BIG_ENDIAN 1
++  #endif
++
++  #if defined (__ppc__) || defined (__ppc64__)
++    #define JUCE_PPC 1
++  #else
++    #define JUCE_INTEL 1
++  #endif
++
++  #ifdef __LP64__
++    #define JUCE_64BIT 1
++  #else
++    #define JUCE_32BIT 1
++  #endif
++#endif
++
++//==============================================================================
++#ifdef JUCE_LINUX
++
++  #ifdef _DEBUG
++    #define JUCE_DEBUG 1
++  #endif
++
++  #include <wchar.h>
++
++  // Allow override for big-endian Linux platforms
++  #ifndef JUCE_BIG_ENDIAN
++    #define JUCE_LITTLE_ENDIAN 1
++  #endif
++
++  #if defined (__LP64__) || defined (_LP64)
++    #define JUCE_64BIT 1
++  #else
++    #define JUCE_32BIT 1
++  #endif
++
++  #define JUCE_INTEL 1
++#endif
++
++//==============================================================================
++#if defined (__GNUC__) || defined (__MWERKS__)
++    /** A platform-independent 64-bit integer type. */
++    typedef long long           int64;
++    /** A platform-independent 64-bit unsigned integer type. */
++    typedef unsigned long long  uint64;
++    /** A platform-independent unicode character type. */
++    typedef wchar_t             juce_wchar;
++
++    /** A platform-independent way of forcing an inline function.
++
++      Use the syntax: @code
++        forcedinline void myfunction (int x)
++      @endcode
++    */
++    #ifndef JUCE_DEBUG
++      #define forcedinline  inline __attribute__((always_inline))
++    #else
++      #define forcedinline  inline
++    #endif
++
++    /** A platform-independent way of stopping the compiler inlining a function.
++
++      Use the syntax: @code
++        juce_noinline void myfunction (int x)
++      @endcode
++    */
++    #define juce_noinline __attribute__((noinline))
++
++#else
++    //==============================================================================
++    /** A platform-independent 64-bit integer type. */
++    typedef __int64             int64;
++    /** A platform-independent 64-bit unsigned integer type. */
++    typedef unsigned __int64    uint64;
++
++    /** A platform-independent unicode character type. */
++    typedef wchar_t             juce_wchar;
++
++    /** A platform-independent way of forcing an inline function.
++
++      Use the syntax: @code
++        forcedinline void myfunction (int x)
++      @endcode
++    */
++    #ifdef _MSC_VER
++      #define forcedinline  __forceinline
++    #else
++      #define forcedinline  inline
++    #endif
++
++    /** A platform-independent way of stopping the compiler inlining a function.
++
++      Use the syntax: @code
++        juce_noinline void myfunction (int x)
++      @endcode
++    */
++    #define juce_noinline
++
++#endif
++
++#if JUCE_64BIT
++   typedef int64                   pointer_sized_int;
++   typedef uint64                  pointer_sized_uint;
++#else
++  #if _MSC_VER >= 1300
++     typedef _W64 int              pointer_sized_int;
++     typedef _W64 unsigned int     pointer_sized_uint;
++  #else
++     typedef int                   pointer_sized_int;
++     typedef unsigned int          pointer_sized_uint;
++  #endif
++#endif
++
++
++// borland can't handle inline functions containing asm code, so define a
++// special type of inline modifier for this kind of function. Sigh..
++#ifdef __BORLANDC__
++  #define inline_assembly
++#else
++  #define inline_assembly forcedinline
++#endif
++
++//==============================================================================
++typedef signed char     int8;
++typedef unsigned char   uint8;
++typedef signed short    int16;
++typedef unsigned short  uint16;
++typedef signed int      int32;
++typedef unsigned int    uint32;
++
++
++//==============================================================================
++// Debugging macros
++//
++
++#ifdef JUCE_DEBUG
++  //==============================================================================
++  // If debugging is enabled..
++
++  /** Writes a string to the standard error stream.
++
++    This is only compiled in a debug build.
++
++    @see Logger::outputDebugString
++  */
++  #define DBG(dbgtext)              Logger::outputDebugString (dbgtext);
++
++  /** Printf's a string to the standard error stream.
++
++    This is only compiled in a debug build.
++
++    @see Logger::outputDebugString
++  */
++  #define DBG_PRINTF(dbgprintf)     Logger::outputDebugPrintf dbgprintf;
++
++  // Assertions..
++  #if defined (_MSC_VER) || DOXYGEN
++    /** This will always cause an assertion failure.
++
++        This is only compiled in a debug build.
++
++        @see jassert()
++    */
++    #ifdef __BORLANDC__
++      extern void juce_StopInDebugger();
++      #define jassertfalse          { juce_StopInDebugger(); }
++    #else
++      #define jassertfalse          { __asm int 3 }
++    #endif
++  #elif defined (JUCE_MAC)
++    #define jassertfalse            { Debugger(); }
++  #elif defined (__GNUC__) || defined (JUCE_LINUX)
++    #ifndef __x86__
++      #define jassertfalse          { 1/0; }
++    #else
++      #define jassertfalse            { asm("int $3"); }
++    #endif
++  #endif
++
++  //==============================================================================
++  /** Platform-independent assertion macro.
++
++    This gets optimised out when not being built with debugging turned on.
++
++    Be careful not to call any functions within its arguments that are vital to
++    the behaviour of the program, because these won't get called in the release
++    build.
++
++    @see jassertfalse
++  */
++  #define jassert(a)                { if (! (a)) jassertfalse }
++
++#else
++  //==============================================================================
++  // If debugging is disabled, disable all the assertions and debugging stuff..
++
++  #define DBG(dbgtext)
++  #define DBG_PRINTF(dbgprintf)
++
++  #define jassert(a)        {}
++  #define jassertfalse      {}
++
++#endif
++
++//==============================================================================
++#ifndef DOXYGEN
++ template <bool b> struct JuceStaticAssert;
++ template <> struct JuceStaticAssert <true> { static void dummy() {} };
++#endif
++
++/** A compile-time assertion macro.
++
++    If the expression parameter is false, the macro will cause a compile error.
++*/
++#define static_jassert(expression)      JuceStaticAssert<expression>::dummy();
++
++
++//==============================================================================
++#if JUCE_CATCH_UNHANDLED_EXCEPTIONS
++
++  #define JUCE_TRY try
++
++  /** Used in try-catch blocks, this macro will send exceptions to the JUCEApplication
++      object so they can be logged by the application if it wants to.
++  */
++  #define JUCE_CATCH_EXCEPTION \
++    catch (const std::exception& e)  \
++    { \
++        JUCEApplication::sendUnhandledException (&e, __FILE__, __LINE__); \
++    } \
++    catch (...) \
++    { \
++        JUCEApplication::sendUnhandledException (0, __FILE__, __LINE__); \
++    }
++
++  #define JUCE_CATCH_ALL            catch (...) {}
++  #define JUCE_CATCH_ALL_ASSERT     catch (...) { jassertfalse }
++
++#else
++
++  #define JUCE_TRY
++  #define JUCE_CATCH_EXCEPTION
++  #define JUCE_CATCH_ALL
++  #define JUCE_CATCH_ALL_ASSERT
++
++#endif
++
++
++#endif   // __JUCE_PLATFORMDEFS_JUCEHEADER__
+--- juce/src/juce_core/basics/juce_DataConversions.h~remove-x86isms.patch
++++ juce/src/juce_core/basics/juce_DataConversions.h
+@@ -1,172 +1,176 @@
+-/*

+-  ==============================================================================

+-

+-   This file is part of the JUCE library - "Jules' Utility Class Extensions"

+-   Copyright 2004-6 by Raw Material Software ltd.

+-

+-  ------------------------------------------------------------------------------

+-

+-   JUCE can be redistributed and/or modified under the terms of the

+-   GNU General Public License, as published by the Free Software Foundation;

+-   either version 2 of the License, or (at your option) any later version.

+-

+-   JUCE is distributed in the hope that it will be useful,

+-   but WITHOUT ANY WARRANTY; without even the implied warranty of

+-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+-   GNU General Public License for more details.

+-

+-   You should have received a copy of the GNU General Public License

+-   along with JUCE; if not, visit www.gnu.org/licenses or write to the

+-   Free Software Foundation, Inc., 59 Temple Place, Suite 330, 

+-   Boston, MA 02111-1307 USA

+-

+-  ------------------------------------------------------------------------------

+-

+-   If you'd like to release a closed-source product which uses JUCE, commercial

+-   licenses are also available: visit www.rawmaterialsoftware.com/juce for

+-   more information.

+-

+-  ==============================================================================

+-*/

+-

+-#ifndef __JUCE_DATACONVERSIONS_JUCEHEADER__

+-#define __JUCE_DATACONVERSIONS_JUCEHEADER__

+-

+-#include "juce_PlatformDefs.h"

+-

+-//==============================================================================

+-// Endianness conversions..

+-

+-/** Swaps the byte-order in an integer from little to big-endianness or vice-versa. */

+-inline_assembly uint32 swapByteOrder (uint32 n) throw()

+-{

+-#ifdef JUCE_MAC

+-    return CFSwapInt32 (n);

+-#else

+-  #ifdef __GNUC__

+-    // Inpenetrable GCC version..

+-    asm("bswap %%eax" : "=a"(n) : "a"(n));

+-    return n;

+-  #else

+-    // Win32 version..

+-    __asm {

+-        mov eax, n

+-        bswap eax

+-        mov n, eax

+-    }

+-    return n;

+-  #endif

+-#endif

+-}

+-

+-/** Swaps the byte-order of a 16-bit short. */

+-inline uint16 swapByteOrder (const uint16 n) throw()

+-{

+-    return (uint16) ((n << 8) | (n >> 8));

+-}

+-

+-inline uint64 swapByteOrder (const uint64 value) throw()

+-{

+-#ifdef JUCE_MAC

+-    return CFSwapInt64 (value);

+-#else

+-    return (((int64) swapByteOrder ((uint32) value)) << 32)

+-            | swapByteOrder ((uint32) (value >> 32));

+-#endif

+-}

+-

+-#ifdef JUCE_LITTLE_ENDIAN

+-  /** Swaps the byte order of a 16-bit int if the CPU is big-endian */

+-  inline uint16     swapIfBigEndian (const uint16 v) throw()             { return v; }

+-  /** Swaps the byte order of a 32-bit int if the CPU is big-endian */

+-  inline uint32     swapIfBigEndian (const uint32 v) throw()             { return v; }

+-  /** Swaps the byte order of a 16-bit int if the CPU is little-endian */

+-  inline uint16     swapIfLittleEndian (const uint16 v) throw()          { return swapByteOrder (v); }

+-  /** Swaps the byte order of a 32-bit int if the CPU is little-endian */

+-  inline uint32     swapIfLittleEndian (const uint32 v) throw()          { return swapByteOrder (v); }

+-

+-  /** Turns 4 bytes into a little-endian integer. */

+-  inline uint32     littleEndianInt (const char* const bytes) throw()    { return *(uint32*) bytes; }

+-

+-  /** Turns 2 bytes into a little-endian integer. */

+-  inline uint16     littleEndianShort (const char* const bytes) throw()  { return *(uint16*) bytes; }

+-

+-  /** Turns 4 bytes into a big-endian integer. */

+-  inline uint32     bigEndianInt (const char* const bytes) throw()       { return swapByteOrder (*(uint32*) bytes); }

+-

+-  /** Turns 2 bytes into a big-endian integer. */

+-  inline uint16     bigEndianShort (const char* const bytes) throw()     { return swapByteOrder (*(uint16*) bytes); }

+-

+-#else

+-  /** Swaps the byte order of a 16-bit int if the CPU is big-endian */

+-  inline uint16     swapIfBigEndian (const uint16 v) throw()             { return swapByteOrder (v); }

+-  /** Swaps the byte order of a 32-bit int if the CPU is big-endian */

+-  inline uint32     swapIfBigEndian (const uint32 v) throw()             { return swapByteOrder (v); }

+-  /** Swaps the byte order of a 16-bit int if the CPU is little-endian */

+-  inline uint16     swapIfLittleEndian (const uint16 v) throw()          { return v; }

+-  /** Swaps the byte order of a 32-bit int if the CPU is little-endian */

+-  inline uint32     swapIfLittleEndian (const uint32 v) throw()          { return v; }

+-

+-  /** Turns 4 bytes into a little-endian integer. */

+-  inline uint32     littleEndianInt (const char* const bytes) throw()    { return swapByteOrder (*(uint32*) bytes); }

+-

+-  /** Turns 2 bytes into a little-endian integer. */

+-  inline uint16     littleEndianShort (const char* const bytes) throw()  { return swapByteOrder (*(uint16*) bytes); }

+-

+-  /** Turns 4 bytes into a big-endian integer. */

+-  inline uint32     bigEndianInt (const char* const bytes) throw()       { return *(uint32*) bytes; }

+-

+-  /** Turns 2 bytes into a big-endian integer. */

+-  inline uint16     bigEndianShort (const char* const bytes) throw()     { return *(uint16*) bytes; }

+-#endif

+-

+-/** Converts 3 little-endian bytes into a signed 24-bit value (which is sign-extended to 32 bits). */

+-inline int littleEndian24Bit (const char* const bytes) throw()                          { return (((int) bytes[2]) << 16) | (((uint32) (uint8) bytes[1]) << 8) | ((uint32) (uint8) bytes[0]); }

+-/** Converts 3 big-endian bytes into a signed 24-bit value (which is sign-extended to 32 bits). */

+-inline int bigEndian24Bit (const char* const bytes) throw()                             { return (((int) bytes[0]) << 16) | (((uint32) (uint8) bytes[1]) << 8) | ((uint32) (uint8) bytes[2]); }

+-

+-/** Copies a 24-bit number to 3 little-endian bytes. */

+-inline void littleEndian24BitToChars (const int value, char* const destBytes) throw()   { destBytes[0] = (char)(value & 0xff); destBytes[1] = (char)((value >> 8) & 0xff); destBytes[2] = (char)((value >> 16) & 0xff); }

+-/** Copies a 24-bit number to 3 big-endian bytes. */

+-inline void bigEndian24BitToChars (const int value, char* const destBytes) throw()      { destBytes[0] = (char)((value >> 16) & 0xff); destBytes[1] = (char)((value >> 8) & 0xff); destBytes[2] = (char)(value & 0xff); }

+-

+-

+-//==============================================================================

+-/** Fast floating-point-to-integer conversion.

+-

+-    This is faster than using the normal c++ cast to convert a double to an int, and

+-    it will round the value to the nearest integer, rather than rounding it down

+-    like the normal cast does.

+-*/

+-inline int roundDoubleToInt (const double value) throw()

+-{

+-    union { int asInt[2]; double asDouble; } n;

+-    n.asDouble = value + 6755399441055744.0;

+-

+-#if JUCE_BIG_ENDIAN

+-    return n.asInt [1];

+-#else

+-    return n.asInt [0];

+-#endif

+-}

+-

+-/** Fast floating-point-to-integer conversion.

+-

+-    This is faster than using the normal c++ cast to convert a float to an int, and

+-    it will round the value to the nearest integer, rather than rounding it down

+-    like the normal cast does.

+-*/

+-inline int roundFloatToInt (const float value) throw()

+-{

+-    union { int asInt[2]; double asDouble; } n;

+-    n.asDouble = value + 6755399441055744.0;

+-

+-#if JUCE_BIG_ENDIAN

+-    return n.asInt [1];

+-#else

+-    return n.asInt [0];

+-#endif

+-}

+-

+-

+-#endif   // __JUCE_DATACONVERSIONS_JUCEHEADER__

++/*
++  ==============================================================================
++
++   This file is part of the JUCE library - "Jules' Utility Class Extensions"
++   Copyright 2004-6 by Raw Material Software ltd.
++
++  ------------------------------------------------------------------------------
++
++   JUCE can be redistributed and/or modified under the terms of the
++   GNU General Public License, as published by the Free Software Foundation;
++   either version 2 of the License, or (at your option) any later version.
++
++   JUCE is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++
++   You should have received a copy of the GNU General Public License
++   along with JUCE; if not, visit www.gnu.org/licenses or write to the
++   Free Software Foundation, Inc., 59 Temple Place, Suite 330, 
++   Boston, MA 02111-1307 USA
++
++  ------------------------------------------------------------------------------
++
++   If you'd like to release a closed-source product which uses JUCE, commercial
++   licenses are also available: visit www.rawmaterialsoftware.com/juce for
++   more information.
++
++  ==============================================================================
++*/
++
++#ifndef __JUCE_DATACONVERSIONS_JUCEHEADER__
++#define __JUCE_DATACONVERSIONS_JUCEHEADER__
++
++#include "juce_PlatformDefs.h"
++
++//==============================================================================
++// Endianness conversions..
++
++/** Swaps the byte-order in an integer from little to big-endianness or vice-versa. */
++inline_assembly uint32 swapByteOrder (uint32 n) throw()
++{
++#ifdef JUCE_MAC
++    return CFSwapInt32 (n);
++#else
++  #ifdef __GNUC__
++    #ifndef __x86__
++    return ( ((n)&0xff)<<24) | (((n)&0xff00)<<8) | (((n)>>8)&0xff00) | (((n)>>24)&0xff);
++    #else
++      // Inpenetrable GCC version..
++      asm("bswap %%eax" : "=a"(n) : "a"(n));
++      return n;
++    #endif
++  #else
++    // Win32 version..
++    __asm {
++        mov eax, n
++        bswap eax
++        mov n, eax
++    }
++    return n;
++  #endif
++#endif
++}
++
++/** Swaps the byte-order of a 16-bit short. */
++inline uint16 swapByteOrder (const uint16 n) throw()
++{
++    return (uint16) ((n << 8) | (n >> 8));
++}
++
++inline uint64 swapByteOrder (const uint64 value) throw()
++{
++#ifdef JUCE_MAC
++    return CFSwapInt64 (value);
++#else
++    return (((int64) swapByteOrder ((uint32) value)) << 32)
++            | swapByteOrder ((uint32) (value >> 32));
++#endif
++}
++
++#ifdef JUCE_LITTLE_ENDIAN
++  /** Swaps the byte order of a 16-bit int if the CPU is big-endian */
++  inline uint16     swapIfBigEndian (const uint16 v) throw()             { return v; }
++  /** Swaps the byte order of a 32-bit int if the CPU is big-endian */
++  inline uint32     swapIfBigEndian (const uint32 v) throw()             { return v; }
++  /** Swaps the byte order of a 16-bit int if the CPU is little-endian */
++  inline uint16     swapIfLittleEndian (const uint16 v) throw()          { return swapByteOrder (v); }
++  /** Swaps the byte order of a 32-bit int if the CPU is little-endian */
++  inline uint32     swapIfLittleEndian (const uint32 v) throw()          { return swapByteOrder (v); }
++
++  /** Turns 4 bytes into a little-endian integer. */
++  inline uint32     littleEndianInt (const char* const bytes) throw()    { return *(uint32*) bytes; }
++
++  /** Turns 2 bytes into a little-endian integer. */
++  inline uint16     littleEndianShort (const char* const bytes) throw()  { return *(uint16*) bytes; }
++
++  /** Turns 4 bytes into a big-endian integer. */
++  inline uint32     bigEndianInt (const char* const bytes) throw()       { return swapByteOrder (*(uint32*) bytes); }
++
++  /** Turns 2 bytes into a big-endian integer. */
++  inline uint16     bigEndianShort (const char* const bytes) throw()     { return swapByteOrder (*(uint16*) bytes); }
++
++#else
++  /** Swaps the byte order of a 16-bit int if the CPU is big-endian */
++  inline uint16     swapIfBigEndian (const uint16 v) throw()             { return swapByteOrder (v); }
++  /** Swaps the byte order of a 32-bit int if the CPU is big-endian */
++  inline uint32     swapIfBigEndian (const uint32 v) throw()             { return swapByteOrder (v); }
++  /** Swaps the byte order of a 16-bit int if the CPU is little-endian */
++  inline uint16     swapIfLittleEndian (const uint16 v) throw()          { return v; }
++  /** Swaps the byte order of a 32-bit int if the CPU is little-endian */
++  inline uint32     swapIfLittleEndian (const uint32 v) throw()          { return v; }
++
++  /** Turns 4 bytes into a little-endian integer. */
++  inline uint32     littleEndianInt (const char* const bytes) throw()    { return swapByteOrder (*(uint32*) bytes); }
++
++  /** Turns 2 bytes into a little-endian integer. */
++  inline uint16     littleEndianShort (const char* const bytes) throw()  { return swapByteOrder (*(uint16*) bytes); }
++
++  /** Turns 4 bytes into a big-endian integer. */
++  inline uint32     bigEndianInt (const char* const bytes) throw()       { return *(uint32*) bytes; }
++
++  /** Turns 2 bytes into a big-endian integer. */
++  inline uint16     bigEndianShort (const char* const bytes) throw()     { return *(uint16*) bytes; }
++#endif
++
++/** Converts 3 little-endian bytes into a signed 24-bit value (which is sign-extended to 32 bits). */
++inline int littleEndian24Bit (const char* const bytes) throw()                          { return (((int) bytes[2]) << 16) | (((uint32) (uint8) bytes[1]) << 8) | ((uint32) (uint8) bytes[0]); }
++/** Converts 3 big-endian bytes into a signed 24-bit value (which is sign-extended to 32 bits). */
++inline int bigEndian24Bit (const char* const bytes) throw()                             { return (((int) bytes[0]) << 16) | (((uint32) (uint8) bytes[1]) << 8) | ((uint32) (uint8) bytes[2]); }
++
++/** Copies a 24-bit number to 3 little-endian bytes. */
++inline void littleEndian24BitToChars (const int value, char* const destBytes) throw()   { destBytes[0] = (char)(value & 0xff); destBytes[1] = (char)((value >> 8) & 0xff); destBytes[2] = (char)((value >> 16) & 0xff); }
++/** Copies a 24-bit number to 3 big-endian bytes. */
++inline void bigEndian24BitToChars (const int value, char* const destBytes) throw()      { destBytes[0] = (char)((value >> 16) & 0xff); destBytes[1] = (char)((value >> 8) & 0xff); destBytes[2] = (char)(value & 0xff); }
++
++
++//==============================================================================
++/** Fast floating-point-to-integer conversion.
++
++    This is faster than using the normal c++ cast to convert a double to an int, and
++    it will round the value to the nearest integer, rather than rounding it down
++    like the normal cast does.
++*/
++inline int roundDoubleToInt (const double value) throw()
++{
++    union { int asInt[2]; double asDouble; } n;
++    n.asDouble = value + 6755399441055744.0;
++
++#if JUCE_BIG_ENDIAN
++    return n.asInt [1];
++#else
++    return n.asInt [0];
++#endif
++}
++
++/** Fast floating-point-to-integer conversion.
++
++    This is faster than using the normal c++ cast to convert a float to an int, and
++    it will round the value to the nearest integer, rather than rounding it down
++    like the normal cast does.
++*/
++inline int roundFloatToInt (const float value) throw()
++{
++    union { int asInt[2]; double asDouble; } n;
++    n.asDouble = value + 6755399441055744.0;
++
++#if JUCE_BIG_ENDIAN
++    return n.asInt [1];
++#else
++    return n.asInt [0];
++#endif
++}
++
++
++#endif   // __JUCE_DATACONVERSIONS_JUCEHEADER__
+--- juce/build/linux/platform_specific_code/juce_linux_SystemStats.cpp~remove-x86isms.patch
++++ juce/build/linux/platform_specific_code/juce_linux_SystemStats.cpp
+@@ -1,472 +1,472 @@
+-/*

+-  ==============================================================================

+-

+-   This file is part of the JUCE library - "Jules' Utility Class Extensions"

+-   Copyright 2004-6 by Raw Material Software ltd.

+-

+-  ------------------------------------------------------------------------------

+-

+-   JUCE can be redistributed and/or modified under the terms of the

+-   GNU General Public License, as published by the Free Software Foundation;

+-   either version 2 of the License, or (at your option) any later version.

+-

+-   JUCE is distributed in the hope that it will be useful,

+-   but WITHOUT ANY WARRANTY; without even the implied warranty of

+-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+-   GNU General Public License for more details.

+-

+-   You should have received a copy of the GNU General Public License

+-   along with JUCE; if not, visit www.gnu.org/licenses or write to the

+-   Free Software Foundation, Inc., 59 Temple Place, Suite 330, 

+-   Boston, MA 02111-1307 USA

+-

+-  ------------------------------------------------------------------------------

+-

+-   If you'd like to release a closed-source product which uses JUCE, commercial

+-   licenses are also available: visit www.rawmaterialsoftware.com/juce for

+-   more information.

+-

+-  ==============================================================================

+-*/

+-

+-#include "linuxincludes.h"

+-#include "../../../src/juce_core/basics/juce_StandardHeader.h"

+-

+-#ifdef __CYGWIN__

+-  #include <apr_uuid.h>

+-  #include <malloc.h>

+-#else

+-  #include <sys/sysinfo.h>

+-  #include <dlfcn.h>

+-#endif

+-

+-#ifdef JUCE_UUID

+-  #include <uuid/uuid.h>

+-#endif

+-

+-#ifndef CPU_ISSET

+-  #undef SUPPORT_AFFINITIES

+-#endif

+-

+-BEGIN_JUCE_NAMESPACE

+-

+-#include "../../../src/juce_core/io/files/juce_File.h"

+-#include "../../../src/juce_core/basics/juce_SystemStats.h"

+-#include "../../../src/juce_core/basics/juce_Logger.h"

+-#include "../../../src/juce_core/misc/juce_Uuid.h"

+-#include "../../../src/juce_core/threads/juce_Process.h"

+-#include "../../../src/juce_appframework/events/juce_Timer.h"

+-#include "../../../src/juce_core/misc/juce_PlatformUtilities.h"

+-

+-static struct _LogicalCpuInfo

+-{

+-    bool htSupported;

+-    bool htAvailable;

+-    int numPackages;

+-    int numLogicalPerPackage;

+-    uint32 physicalAffinityMask;

+-} logicalCpuInfo;

+-

+-//==============================================================================

+-static unsigned int getCPUIDWord (int* familyModel = 0, int* extFeatures = 0) __attribute__ ((noinline));

+-

+-static unsigned int getCPUIDWord (int* familyModel, int* extFeatures)

+-{

+-    unsigned int cpu = 0;

+-    unsigned int ext = 0;

+-    unsigned int family = 0;

+-

+-    __asm__ __volatile__ (

+-"        pushf                            \n"

+-#if JUCE_64BIT

+-"        pop    %%rax                     \n"

+-#else

+-"        pop    %%eax                     \n"

+-#endif

+-"        movl   %%eax, %%ecx              \n"

+-"        xorl   $0x200000, %%eax          \n"

+-#if JUCE_64BIT

+-"        push   %%rax                     \n"

+-#else

+-"        push   %%eax                     \n"

+-#endif

+-"        popf                             \n"

+-"        pushf                            \n"

+-#if JUCE_64BIT

+-"        pop    %%rax                     \n"

+-#else

+-"        pop    %%eax                     \n"

+-#endif

+-"        andl   $0x200000, %%eax          \n"

+-"        andl   $0x200000, %%ecx          \n"

+-"        cmpl   %%eax, %%ecx              \n"

+-"        movl   $0, %%edx                 \n"

+-"        je     noCpuId                   \n"

+-"        movl   $1, %%eax                 \n"

+-"        cpuid                            \n"

+-"noCpuId:                                 \n"

+-       : "=a"(family),                                 /* Output in eax */

+-         "=d"(cpu),                                    /* Output in ebx */

+-         "=b"(ext)                                     /* Output in edx */

+-       :                                               /* No inputs */

+-       : "cc", "ecx"                                   /* Clobber list */

+-    );

+-

+-    if (familyModel)

+-        *familyModel = family;

+-    if (extFeatures)

+-        *extFeatures = ext;

+-

+-    return cpu;

+-}

+-

+-void juce_initLogicalCpuInfo()

+-{

+-    int familyModelWord, extFeaturesWord;

+-    int featuresWord = getCPUIDWord (&familyModelWord, &extFeaturesWord);

+-

+-    logicalCpuInfo.htSupported = false;

+-    logicalCpuInfo.htAvailable = false;

+-    logicalCpuInfo.numLogicalPerPackage = 1;

+-    logicalCpuInfo.numPackages = 0;

+-    logicalCpuInfo.physicalAffinityMask = 0;

+-

+-#if SUPPORT_AFFINITIES

+-    cpu_set_t processAffinity;

+-

+-    /*

+-       N.B. If this line causes a compile error, then you've probably not got the latest

+-       version of glibc installed.

+-

+-       If you don't want to update your copy of glibc and don't care about cpu affinities,

+-       then you can just disable all this stuff by removing the SUPPORT_AFFINITIES macro

+-       from the linuxincludes.h file.

+-    */

+-    if (sched_getaffinity (getpid(),

+-                           sizeof (cpu_set_t),

+-                           &processAffinity) != sizeof (cpu_set_t))

+-    {

+-        return;

+-    }

+-

+-    // Checks: CPUID supported, model >= Pentium 4, Hyperthreading bit set, logical CPUs per package > 1

+-    if (featuresWord == 0

+-        || ((familyModelWord >> 8) & 0xf) < 15

+-        || (featuresWord & (1 << 28)) == 0

+-        || ((extFeaturesWord >> 16) & 0xff) < 2)

+-    {

+-        for (int i = 0; i < 64; ++i)

+-            if (CPU_ISSET (i, &processAffinity))

+-                logicalCpuInfo.physicalAffinityMask |= (1 << i);

+-

+-        return;

+-    }

+-

+-    logicalCpuInfo.htSupported = true;

+-    logicalCpuInfo.numLogicalPerPackage = (extFeaturesWord >> 16) & 0xff;

+-

+-    cpu_set_t affinityMask;

+-    cpu_set_t physAff;

+-    CPU_ZERO (&physAff);

+-

+-    unsigned char i = 1;

+-    unsigned char physIdMask = 0xFF;

+-    unsigned char physIdShift = 0;

+-

+-    //unsigned char apicId, logId, physId;

+-

+-    while (i < logicalCpuInfo.numLogicalPerPackage)

+-    {

+-        i *= 2;

+-        physIdMask <<= 1;

+-        physIdShift++;

+-    }

+-

+-    CPU_SET (0, &affinityMask);

+-    logicalCpuInfo.numPackages = 0;

+-

+-//xxx revisit this at some point..

+-/*    while ((affinityMask != 0) && (affinityMask <= processAffinity))

+-    {

+-        int ret;

+-        if (! sched_setaffinity (getpid(), sizeof (cpu_set_t), &affinityMask))

+-        {

+-            sched_yield(); // schedule onto correct CPU

+-

+-            featuresWord = getCPUIDWord(&familyModelWord, &extFeaturesWord);

+-            apicId = (unsigned char)(extFeaturesWord >> 24);

+-            logId = (unsigned char)(apicId & ~physIdMask);

+-            physId = (unsigned char)(apicId >> physIdShift);

+-

+-            if (logId != 0)

+-                logicalCpuInfo.htAvailable = true;

+-

+-            if ((((int)logId) % logicalCpuInfo.numLogicalPerPackage) == 0)

+-            {

+-                // This is a physical CPU

+-                physAff |= affinityMask;

+-                logicalCpuInfo.numPackages++;

+-            }

+-        }

+-

+-        affinityMask = affinityMask << 1;

+-    }

+-

+-    sched_setaffinity (getpid(), sizeof(unsigned long), &processAffinity);

+-*/

+-

+-    logicalCpuInfo.physicalAffinityMask = 0;

+-

+-    for (int i = 0; i < 64; ++i)

+-        if (CPU_ISSET (i, &physAff))

+-            logicalCpuInfo.physicalAffinityMask |= (1 << i);

+-

+-#endif

+-}

+-

+-//==============================================================================

+-void Logger::outputDebugString (const String& text)

+-{

+-    fprintf (stdout, (const char*) (text + T("\n")));

+-}

+-

+-void Logger::outputDebugPrintf (const tchar* format, ...)

+-{

+-    String text;

+-    va_list args;

+-    va_start (args, format);

+-    text.vprintf(format, args);

+-    outputDebugString(text);

+-}

+-

+-const String SystemStats::getOSType()

+-{

+-    return SystemStats::Linux;

+-}

+-

+-static const String getCpuInfo (const char* key, bool lastOne = false)

+-{

+-    String info;

+-    char buf [256];

+-

+-    FILE* f = fopen ("/proc/cpuinfo", "r");

+-

+-    while (f != 0 && fgets (buf, sizeof(buf), f))

+-    {

+-        if (strncmp (buf, key, strlen (key)) == 0)

+-        {

+-            char* p = buf;

+-

+-            while (*p && *p != '\n')

+-                ++p;

+-

+-            if (*p != 0)

+-                *p = 0;

+-

+-            p = buf;

+-

+-            while (*p != 0 && *p != ':')

+-                ++p;

+-

+-            if (*p != 0 && *(p + 1) != 0)

+-                info = p + 2;

+-

+-            if (! lastOne)

+-                break;

+-        }

+-    }

+-

+-    fclose (f);

+-    return info;

+-}

+-

+-bool SystemStats::hasMMX()

+-{

+-    return getCpuInfo ("flags").contains (T("mmx"));

+-}

+-

+-bool SystemStats::hasSSE()

+-{

+-    return getCpuInfo ("flags").contains (T("sse"));

+-}

+-

+-bool SystemStats::hasSSE2()

+-{

+-    return getCpuInfo ("flags").contains (T("sse2"));

+-}

+-

+-bool SystemStats::has3DNow()

+-{

+-    return getCpuInfo ("flags").contains (T("3dnow"));

+-}

+-

+-const String SystemStats::getCpuVendor()

+-{

+-    return getCpuInfo ("vendor_id");

+-}

+-

+-int SystemStats::getCpuSpeedInMegaherz()

+-{

+-    const String speed (getCpuInfo ("cpu MHz"));

+-

+-    return (int) (speed.getFloatValue() + 0.5f);

+-}

+-

+-bool SystemStats::hasHyperThreading()

+-{

+-    return logicalCpuInfo.htAvailable;

+-}

+-

+-int SystemStats::getMemorySizeInMegabytes()

+-{

+-#ifndef __CYGWIN__

+-    struct sysinfo sysi;

+-

+-    if (sysinfo (&sysi) == 0)

+-        return (sysi.totalram * sysi.mem_unit / (1024 * 1024));

+-

+-    return 0;

+-

+-#else

+-    jassertfalse

+-    return 256;

+-#endif

+-}

+-

+-unsigned int juce_millisecondsSinceStartup()

+-{

+-    static unsigned int calibrate = 0;

+-    static bool calibrated = false;

+-    timeval t;

+-    unsigned int ret = 0;

+-

+-    if (! gettimeofday (&t, 0))

+-    {

+-        if (! calibrated)

+-        {

+-#ifndef __CYGWIN__

+-            struct sysinfo sysi;

+-

+-            if (sysinfo (&sysi) == 0)

+-                // Safe to assume system was not brought up earlier than 1970!

+-                calibrate = t.tv_sec - sysi.uptime;

+-#else

+-            // bit of a hack, but things should all still work, as we're not often

+-            // really interested in how long the machine's been turned on, and just

+-            // use this call for relative times..

+-            calibrate = t.tv_sec;

+-#endif

+-

+-            calibrated = true;

+-        }

+-

+-        ret = 1000 * (t.tv_sec - calibrate) + (t.tv_usec / 1000);

+-    }

+-

+-    return ret;

+-}

+-

+-double juce_millisecondsSinceStartupHiRes()

+-{

+-    return Time::getHighResolutionTicks() * (1.0 / 1000000.0);

+-}

+-

+-int64 Time::getHighResolutionTicks()

+-{

+-    timeval t;

+-    if (gettimeofday(&t,NULL))

+-        return 0;

+-

+-    return ((int64) t.tv_sec * (int64) 1000000) + (int64) t.tv_usec;

+-}

+-

+-int64 Time::getHighResolutionTicksPerSecond()

+-{

+-    // Microseconds

+-    return 1000000;

+-}

+-

+-bool Time::setSystemTimeToThisTime() const

+-{

+-    timeval t;

+-    t.tv_sec = millisSinceEpoch % 1000000;

+-    t.tv_usec = millisSinceEpoch - t.tv_sec;

+-

+-    return settimeofday (&t, NULL) ? false : true;

+-}

+-

+-const String Uuid::generateUuid()

+-{

+-#ifdef JUCE_UUID

+-    uuid_t uuid;

+-    char *s = new char[37];

+-    String uuidStr;

+-

+-    uuid_generate (uuid);

+-    uuid_unparse (uuid, s);

+-

+-    uuidStr = s;

+-    delete[] s;

+-

+-    return uuidStr;

+-#else

+-    jassertfalse

+-    return String::empty;

+-#endif

+-}

+-

+-int SystemStats::getPageSize()

+-{

+-    static int systemPageSize = 0;

+-

+-    if (systemPageSize == 0)

+-        systemPageSize = sysconf (_SC_PAGESIZE);

+-

+-    return systemPageSize;

+-}

+-

+-int SystemStats::getNumPhysicalCpus()

+-{

+-    if (logicalCpuInfo.numPackages)

+-        return logicalCpuInfo.numPackages;

+-

+-    return getNumLogicalCpus();

+-}

+-

+-int SystemStats::getNumLogicalCpus()

+-{

+-    const int lastCpu = getCpuInfo ("processor", true).getIntValue();

+-

+-    return lastCpu + 1;

+-}

+-

+-uint32 SystemStats::getPhysicalAffinityMask()

+-{

+-#if SUPPORT_AFFINITIES

+-    return logicalCpuInfo.physicalAffinityMask;

+-#else

+-    /* affinities aren't supported because either the appropriate header files weren't found,

+-       or the SUPPORT_AFFINITIES macro was turned off in linuxheaders.h

+-    */

+-    jassertfalse

+-    return 0;

+-#endif

+-

+-}

+-

+-//==============================================================================

+-void SystemStats::initialiseStats()

+-{

+-    // Process starts off as root when running suid

+-    Process::lowerPrivilege();

+-

+-    String s (SystemStats::getJUCEVersion());

+-

+-    juce_initLogicalCpuInfo();

+-}

+-

+-void PlatformUtilities::fpuReset()

+-{

+-}

+-

+-END_JUCE_NAMESPACE

++/*
++  ==============================================================================
++
++   This file is part of the JUCE library - "Jules' Utility Class Extensions"
++   Copyright 2004-6 by Raw Material Software ltd.
++
++  ------------------------------------------------------------------------------
++
++   JUCE can be redistributed and/or modified under the terms of the
++   GNU General Public License, as published by the Free Software Foundation;
++   either version 2 of the License, or (at your option) any later version.
++
++   JUCE is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++
++   You should have received a copy of the GNU General Public License
++   along with JUCE; if not, visit www.gnu.org/licenses or write to the
++   Free Software Foundation, Inc., 59 Temple Place, Suite 330, 
++   Boston, MA 02111-1307 USA
++
++  ------------------------------------------------------------------------------
++
++   If you'd like to release a closed-source product which uses JUCE, commercial
++   licenses are also available: visit www.rawmaterialsoftware.com/juce for
++   more information.
++
++  ==============================================================================
++*/
++
++#include "linuxincludes.h"
++#include "../../../src/juce_core/basics/juce_StandardHeader.h"
++
++#ifdef __CYGWIN__
++  #include <apr_uuid.h>
++  #include <malloc.h>
++#else
++  #include <sys/sysinfo.h>
++  #include <dlfcn.h>
++#endif
++
++#ifdef JUCE_UUID
++  #include <uuid/uuid.h>
++#endif
++
++#ifndef CPU_ISSET
++  #undef SUPPORT_AFFINITIES
++#endif
++
++BEGIN_JUCE_NAMESPACE
++
++#include "../../../src/juce_core/io/files/juce_File.h"
++#include "../../../src/juce_core/basics/juce_SystemStats.h"
++#include "../../../src/juce_core/basics/juce_Logger.h"
++#include "../../../src/juce_core/misc/juce_Uuid.h"
++#include "../../../src/juce_core/threads/juce_Process.h"
++#include "../../../src/juce_appframework/events/juce_Timer.h"
++#include "../../../src/juce_core/misc/juce_PlatformUtilities.h"
++
++static struct _LogicalCpuInfo
++{
++    bool htSupported;
++    bool htAvailable;
++    int numPackages;
++    int numLogicalPerPackage;
++    uint32 physicalAffinityMask;
++} logicalCpuInfo;
++
++//==============================================================================
++static unsigned int getCPUIDWord (int* familyModel = 0, int* extFeatures = 0) __attribute__ ((noinline));
++
++static unsigned int getCPUIDWord (int* familyModel, int* extFeatures)
++{
++    unsigned int cpu = 0;
++    unsigned int ext = 0;
++    unsigned int family = 0;
++#ifdef __x86__
++    __asm__ __volatile__ (
++"        pushf                            \n"
++#if JUCE_64BIT
++"        pop    %%rax                     \n"
++#else
++"        pop    %%eax                     \n"
++#endif
++"        movl   %%eax, %%ecx              \n"
++"        xorl   $0x200000, %%eax          \n"
++#if JUCE_64BIT
++"        push   %%rax                     \n"
++#else
++"        push   %%eax                     \n"
++#endif
++"        popf                             \n"
++"        pushf                            \n"
++#if JUCE_64BIT
++"        pop    %%rax                     \n"
++#else
++"        pop    %%eax                     \n"
++#endif
++"        andl   $0x200000, %%eax          \n"
++"        andl   $0x200000, %%ecx          \n"
++"        cmpl   %%eax, %%ecx              \n"
++"        movl   $0, %%edx                 \n"
++"        je     noCpuId                   \n"
++"        movl   $1, %%eax                 \n"
++"        cpuid                            \n"
++"noCpuId:                                 \n"
++       : "=a"(family),                                 /* Output in eax */
++         "=d"(cpu),                                    /* Output in ebx */
++         "=b"(ext)                                     /* Output in edx */
++       :                                               /* No inputs */
++       : "cc", "ecx"                                   /* Clobber list */
++    );
++#endif
++    if (familyModel)
++        *familyModel = family;
++    if (extFeatures)
++        *extFeatures = ext;
++
++    return cpu;
++}
++
++void juce_initLogicalCpuInfo()
++{
++    int familyModelWord, extFeaturesWord;
++    int featuresWord = getCPUIDWord (&familyModelWord, &extFeaturesWord);
++
++    logicalCpuInfo.htSupported = false;
++    logicalCpuInfo.htAvailable = false;
++    logicalCpuInfo.numLogicalPerPackage = 1;
++    logicalCpuInfo.numPackages = 0;
++    logicalCpuInfo.physicalAffinityMask = 0;
++
++#if SUPPORT_AFFINITIES
++    cpu_set_t processAffinity;
++
++    /*
++       N.B. If this line causes a compile error, then you've probably not got the latest
++       version of glibc installed.
++
++       If you don't want to update your copy of glibc and don't care about cpu affinities,
++       then you can just disable all this stuff by removing the SUPPORT_AFFINITIES macro
++       from the linuxincludes.h file.
++    */
++    if (sched_getaffinity (getpid(),
++                           sizeof (cpu_set_t),
++                           &processAffinity) != sizeof (cpu_set_t))
++    {
++        return;
++    }
++
++    // Checks: CPUID supported, model >= Pentium 4, Hyperthreading bit set, logical CPUs per package > 1
++    if (featuresWord == 0
++        || ((familyModelWord >> 8) & 0xf) < 15
++        || (featuresWord & (1 << 28)) == 0
++        || ((extFeaturesWord >> 16) & 0xff) < 2)
++    {
++        for (int i = 0; i < 64; ++i)
++            if (CPU_ISSET (i, &processAffinity))
++                logicalCpuInfo.physicalAffinityMask |= (1 << i);
++
++        return;
++    }
++
++    logicalCpuInfo.htSupported = true;
++    logicalCpuInfo.numLogicalPerPackage = (extFeaturesWord >> 16) & 0xff;
++
++    cpu_set_t affinityMask;
++    cpu_set_t physAff;
++    CPU_ZERO (&physAff);
++
++    unsigned char i = 1;
++    unsigned char physIdMask = 0xFF;
++    unsigned char physIdShift = 0;
++
++    //unsigned char apicId, logId, physId;
++
++    while (i < logicalCpuInfo.numLogicalPerPackage)
++    {
++        i *= 2;
++        physIdMask <<= 1;
++        physIdShift++;
++    }
++
++    CPU_SET (0, &affinityMask);
++    logicalCpuInfo.numPackages = 0;
++
++//xxx revisit this at some point..
++/*    while ((affinityMask != 0) && (affinityMask <= processAffinity))
++    {
++        int ret;
++        if (! sched_setaffinity (getpid(), sizeof (cpu_set_t), &affinityMask))
++        {
++            sched_yield(); // schedule onto correct CPU
++
++            featuresWord = getCPUIDWord(&familyModelWord, &extFeaturesWord);
++            apicId = (unsigned char)(extFeaturesWord >> 24);
++            logId = (unsigned char)(apicId & ~physIdMask);
++            physId = (unsigned char)(apicId >> physIdShift);
++
++            if (logId != 0)
++                logicalCpuInfo.htAvailable = true;
++
++            if ((((int)logId) % logicalCpuInfo.numLogicalPerPackage) == 0)
++            {
++                // This is a physical CPU
++                physAff |= affinityMask;
++                logicalCpuInfo.numPackages++;
++            }
++        }
++
++        affinityMask = affinityMask << 1;
++    }
++
++    sched_setaffinity (getpid(), sizeof(unsigned long), &processAffinity);
++*/
++
++    logicalCpuInfo.physicalAffinityMask = 0;
++
++    for (int i = 0; i < 64; ++i)
++        if (CPU_ISSET (i, &physAff))
++            logicalCpuInfo.physicalAffinityMask |= (1 << i);
++
++#endif
++}
++
++//==============================================================================
++void Logger::outputDebugString (const String& text)
++{
++    fprintf (stdout, (const char*) (text + T("\n")));
++}
++
++void Logger::outputDebugPrintf (const tchar* format, ...)
++{
++    String text;
++    va_list args;
++    va_start (args, format);
++    text.vprintf(format, args);
++    outputDebugString(text);
++}
++
++const String SystemStats::getOSType()
++{
++    return SystemStats::Linux;
++}
++
++static const String getCpuInfo (const char* key, bool lastOne = false)
++{
++    String info;
++    char buf [256];
++
++    FILE* f = fopen ("/proc/cpuinfo", "r");
++
++    while (f != 0 && fgets (buf, sizeof(buf), f))
++    {
++        if (strncmp (buf, key, strlen (key)) == 0)
++        {
++            char* p = buf;
++
++            while (*p && *p != '\n')
++                ++p;
++
++            if (*p != 0)
++                *p = 0;
++
++            p = buf;
++
++            while (*p != 0 && *p != ':')
++                ++p;
++
++            if (*p != 0 && *(p + 1) != 0)
++                info = p + 2;
++
++            if (! lastOne)
++                break;
++        }
++    }
++
++    fclose (f);
++    return info;
++}
++
++bool SystemStats::hasMMX()
++{
++    return getCpuInfo ("flags").contains (T("mmx"));
++}
++
++bool SystemStats::hasSSE()
++{
++    return getCpuInfo ("flags").contains (T("sse"));
++}
++
++bool SystemStats::hasSSE2()
++{
++    return getCpuInfo ("flags").contains (T("sse2"));
++}
++
++bool SystemStats::has3DNow()
++{
++    return getCpuInfo ("flags").contains (T("3dnow"));
++}
++
++const String SystemStats::getCpuVendor()
++{
++    return getCpuInfo ("vendor_id");
++}
++
++int SystemStats::getCpuSpeedInMegaherz()
++{
++    const String speed (getCpuInfo ("cpu MHz"));
++
++    return (int) (speed.getFloatValue() + 0.5f);
++}
++
++bool SystemStats::hasHyperThreading()
++{
++    return logicalCpuInfo.htAvailable;
++}
++
++int SystemStats::getMemorySizeInMegabytes()
++{
++#ifndef __CYGWIN__
++    struct sysinfo sysi;
++
++    if (sysinfo (&sysi) == 0)
++        return (sysi.totalram * sysi.mem_unit / (1024 * 1024));
++
++    return 0;
++
++#else
++    jassertfalse
++    return 256;
++#endif
++}
++
++unsigned int juce_millisecondsSinceStartup()
++{
++    static unsigned int calibrate = 0;
++    static bool calibrated = false;
++    timeval t;
++    unsigned int ret = 0;
++
++    if (! gettimeofday (&t, 0))
++    {
++        if (! calibrated)
++        {
++#ifndef __CYGWIN__
++            struct sysinfo sysi;
++
++            if (sysinfo (&sysi) == 0)
++                // Safe to assume system was not brought up earlier than 1970!
++                calibrate = t.tv_sec - sysi.uptime;
++#else
++            // bit of a hack, but things should all still work, as we're not often
++            // really interested in how long the machine's been turned on, and just
++            // use this call for relative times..
++            calibrate = t.tv_sec;
++#endif
++
++            calibrated = true;
++        }
++
++        ret = 1000 * (t.tv_sec - calibrate) + (t.tv_usec / 1000);
++    }
++
++    return ret;
++}
++
++double juce_millisecondsSinceStartupHiRes()
++{
++    return Time::getHighResolutionTicks() * (1.0 / 1000000.0);
++}
++
++int64 Time::getHighResolutionTicks()
++{
++    timeval t;
++    if (gettimeofday(&t,NULL))
++        return 0;
++
++    return ((int64) t.tv_sec * (int64) 1000000) + (int64) t.tv_usec;
++}
++
++int64 Time::getHighResolutionTicksPerSecond()
++{
++    // Microseconds
++    return 1000000;
++}
++
++bool Time::setSystemTimeToThisTime() const
++{
++    timeval t;
++    t.tv_sec = millisSinceEpoch % 1000000;
++    t.tv_usec = millisSinceEpoch - t.tv_sec;
++
++    return settimeofday (&t, NULL) ? false : true;
++}
++
++const String Uuid::generateUuid()
++{
++#ifdef JUCE_UUID
++    uuid_t uuid;
++    char *s = new char[37];
++    String uuidStr;
++
++    uuid_generate (uuid);
++    uuid_unparse (uuid, s);
++
++    uuidStr = s;
++    delete[] s;
++
++    return uuidStr;
++#else
++    jassertfalse
++    return String::empty;
++#endif
++}
++
++int SystemStats::getPageSize()
++{
++    static int systemPageSize = 0;
++
++    if (systemPageSize == 0)
++        systemPageSize = sysconf (_SC_PAGESIZE);
++
++    return systemPageSize;
++}
++
++int SystemStats::getNumPhysicalCpus()
++{
++    if (logicalCpuInfo.numPackages)
++        return logicalCpuInfo.numPackages;
++
++    return getNumLogicalCpus();
++}
++
++int SystemStats::getNumLogicalCpus()
++{
++    const int lastCpu = getCpuInfo ("processor", true).getIntValue();
++
++    return lastCpu + 1;
++}
++
++uint32 SystemStats::getPhysicalAffinityMask()
++{
++#if SUPPORT_AFFINITIES
++    return logicalCpuInfo.physicalAffinityMask;
++#else
++    /* affinities aren't supported because either the appropriate header files weren't found,
++       or the SUPPORT_AFFINITIES macro was turned off in linuxheaders.h
++    */
++    jassertfalse
++    return 0;
++#endif
++
++}
++
++//==============================================================================
++void SystemStats::initialiseStats()
++{
++    // Process starts off as root when running suid
++    Process::lowerPrivilege();
++
++    String s (SystemStats::getJUCEVersion());
++
++    juce_initLogicalCpuInfo();
++}
++
++void PlatformUtilities::fpuReset()
++{
++}
++
++END_JUCE_NAMESPACE
diff --git a/packages/juce/juce_1.29.bb b/packages/juce/juce_1.29.bb
new file mode 100644
index 0000000000..0127a355a0
--- /dev/null
+++ b/packages/juce/juce_1.29.bb
@@ -0,0 +1,34 @@
+DESCRIPTION = "JUCE is a cross-platform application framework"
+HOMEPAGE = "http://www.rawmaterialsoftware.com/juce"
+AUTHOR = "Julian Stoerer"
+MAINTAINER = "Michael 'Mickey' Lauer <mickey@Vanille.de>"
+LICENSE = "GPL"
+DEPENDS = "alsa-lib freetype x11"
+PR = "r0"
+
+#FIXME the patches are a) HACKS and b) something's wrong with lineend conversion
+SRC_URI = "http://www.rawmaterialsoftware.com/juce/downloads/juce_1_29.zip \
+           file://remove-x86isms.patch;patch=1 \
+           file://no-opengl.patch;patch=1"
+S = "${WORKDIR}/juce"
+
+LIB = "libjuce_debug"
+
+do_compile() {
+	cd ${S}/build/linux && oe_runmake
+	cd ${S}/demo/build/linux && oe_runmake
+}
+
+do_stage() {
+	oe_libinstall -a -C bin ${LIB} ${STAGING_LIBDIR}
+	#FIXME add includes
+}
+
+do_install() {
+	install -d ${D}${bindir}
+	install -m 0655 demo/build/linux/build/jucedemo ${D}${bindir}
+}
+
+PACKAGES = "jucedemo"
+FILES_jucedemo = "${bindir}"
+
diff --git a/packages/links/links-x11_2.1pre20.bb b/packages/links/links-x11_2.1pre21.bb
index f763df7f60..f763df7f60 100644
--- a/packages/links/links-x11_2.1pre20.bb
+++ b/packages/links/links-x11_2.1pre21.bb
diff --git a/packages/links/links_2.1pre20.bb b/packages/links/links_2.1pre21.bb
index 81906242d3..e0a991e148 100644
--- a/packages/links/links_2.1pre20.bb
+++ b/packages/links/links_2.1pre21.bb
@@ -16,4 +16,4 @@ EXTRA_OECONF = "--enable-javascript --with-libfl --enable-graphics \
 	        --with-ssl=${STAGING_LIBDIR}/.. --with-libjpeg \
 	        --without-libtiff --without-svgalib --with-fb \
 	        --without-directfb --without-pmshell --without-atheos \
-	        --without-x"
+	        --without-x --without-sdl"
diff --git a/packages/linux/linux-openzaurus-2.6.16/hrw-pcmcia-ids-r1.patch b/packages/linux/linux-openzaurus-2.6.16/hrw-pcmcia-ids-r1.patch
new file mode 100644
index 0000000000..c14482babb
--- /dev/null
+++ b/packages/linux/linux-openzaurus-2.6.16/hrw-pcmcia-ids-r1.patch
@@ -0,0 +1,45 @@
+
+The ident for Seagate 8GB microdrive is
+"SEAGATE", "ST1"
+hash 0x76dc4190, 0xcfba9599
+manfid 0x0111, 0x0000
+
+Signed-off-by: Marcin Juszkiewicz <openembedded@hrw.one.pl>
+
+ drivers/ide/legacy/ide-cs.c |    1 +
+ 1 file changed, 1 insertion(+)
+
+Index: linux-2.6.16/drivers/ide/legacy/ide-cs.c
+===================================================================
+--- linux-2.6.16.orig/drivers/ide/legacy/ide-cs.c	2006-04-20 12:41:41.000000000 +0200
++++ linux-2.6.16/drivers/ide/legacy/ide-cs.c	2006-04-20 12:45:19.640621552 +0200
+@@ -444,6 +444,7 @@
+ 	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "CD-ROM", 0x281f1c5d, 0x66536591),
+ 	PCMCIA_DEVICE_PROD_ID12("PCMCIA", "PnPIDE", 0x281f1c5d, 0x0c694728),
+ 	PCMCIA_DEVICE_PROD_ID12("SHUTTLE TECHNOLOGY LTD.", "PCCARD-IDE/ATAPI Adapter", 0x4a3f0ba0, 0x322560e1),
++	PCMCIA_DEVICE_PROD_ID12("SEAGATE", "ST1", 0x76dc4190, 0xcfba9599),	/* Seagate 8GB microdrive */
+ 	PCMCIA_DEVICE_PROD_ID12("TOSHIBA", "MK2001MPL", 0xb4585a1a, 0x3489e003),
+ 	PCMCIA_DEVICE_PROD_ID1("TRANSCEND    512M   ", 0xd0909443),
+ 	PCMCIA_DEVICE_PROD_ID12("WIT", "IDE16", 0x244e5994, 0x3e232852),
+
+
+-------------------------------------------------------------------------
+With pcmcia-cs -> pcmciautils change some cards which was working with
+hostap driver now are bound into orinoco driver.
+
+This patch made them bound into hostap like it was before.
+
+Signed-off-by: Marcin Juszkiewicz <openembedded@hrw.one.pl>
+
+--- linux/drivers/net/wireless/hostap/hostap_cs.c.orig	2006-04-09 12:42:34.944903728 +0200
++++ linux/drivers/net/wireless/hostap/hostap_cs.c	2006-04-09 12:42:37.474519168 +0200
+@@ -912,6 +912,9 @@
+ 	PCMCIA_DEVICE_PROD_ID123(
+ 		"SMC", "SMC2632W", "Version 01.02",
+ 		0xc4f8b18b, 0x474a1f2a, 0x4b74baa0),
++	PCMCIA_DEVICE_PROD_ID123(
++		"Pretec", "CompactWLAN Card 802.11b", "2.5",
++		0x1cadd3e5, 0xe697636c, 0x7a5bfcf1),
+ 	PCMCIA_DEVICE_PROD_ID12("BUFFALO", "WLI-CF-S11G", 
+ 				0x2decece3, 0x82067c18),
+ 	PCMCIA_DEVICE_PROD_ID12("Compaq", "WL200_11Mbps_Wireless_PCI_Card",
diff --git a/packages/linux/linux-openzaurus_2.6.16.bb b/packages/linux/linux-openzaurus_2.6.16.bb
index 1225eb5830..3230c0b1b8 100644
--- a/packages/linux/linux-openzaurus_2.6.16.bb
+++ b/packages/linux/linux-openzaurus_2.6.16.bb
@@ -1,6 +1,6 @@
 include linux-openzaurus.inc
 
-PR = "r5"
+PR = "r6"
 
 # Handy URLs
 # git://rsync.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6.git \
@@ -66,7 +66,7 @@ SRC_URI = "http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.16.tar.bz2 \
            ${RPSRC}/sharpsl_pm-do-r2.patch;patch=1 \
            ${RPSRC}/usb_pxa27x_udc-r0.patch;patch=1 \
            ${RPSRC}/usb_add_epalloc-r1.patch;patch=1 \
-	   ${DOSRC}/kexec-arm-r2.patch;patch=1 \
+           ${DOSRC}/kexec-arm-r2.patch;patch=1 \
            ${RPSRC}/pxa_cf_initorder_hack-r1.patch;patch=1 \
            ${RPSRC}/mmcsd_no_scr_check-r0.patch;patch=1 \
            ${RPSRC}/poodle_ts_hack-r0.patch;patch=1 \
@@ -75,6 +75,7 @@ SRC_URI = "http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.16.tar.bz2 \
            ${RPSRC}/pxa-linking-bug.patch;patch=1 \
            file://serial-add-support-for-non-standard-xtals-to-16c950-driver.patch;patch=1 \
            file://connectplus-remove-ide-HACK.patch;patch=1 \
+           file://hrw-pcmcia-ids-r1.patch;patch=1 \
            file://defconfig-c7x0 \
            file://defconfig-ipaq-pxa270 \
            file://defconfig-collie \
diff --git a/packages/nslu2-binary-only/unslung-rootfs/NOTES b/packages/nslu2-binary-only/unslung-rootfs/NOTES
index 82d7448a80..e8b0255a9b 100644
--- a/packages/nslu2-binary-only/unslung-rootfs/NOTES
+++ b/packages/nslu2-binary-only/unslung-rootfs/NOTES
@@ -512,3 +512,8 @@ sambacodepages bb files must be kept in sync regarding the samba code pages
 that are left in the image and the ones that are added to the package (and it
 is also a good idea if the kernel defconfig reflects the inclusion of NLS
 support for the code pages that are left in the image, of course).
+
+Fixed ppp-mppe.c to remove unresolved symbols when loading module.
+
+Disable the ourtelnetrescueuser account in the passwd file entirely since
+Unslung doesn't need it anymore.
diff --git a/packages/nslu2-binary-only/unslung-rootfs/telnet-passwd.patch b/packages/nslu2-binary-only/unslung-rootfs/telnet-passwd.patch
new file mode 100644
index 0000000000..9ccfcc12e9
--- /dev/null
+++ b/packages/nslu2-binary-only/unslung-rootfs/telnet-passwd.patch
@@ -0,0 +1,22 @@
+--- nslu2-linksys-ramdisk-2.3r63/etc/passwd~	2006-04-18 21:54:47.000000000 -0500
++++ nslu2-linksys-ramdisk-2.3r63/etc/passwd	2006-04-18 21:56:53.000000000 -0500
+@@ -4,7 +4,7 @@
+ mail:x:8:12:mail:/var/spool/mail:
+ ftp:x:14:50:FTP User:/:
+ nobody:x:99:99:Nobody:/:
+-ourtelnetrescueuser:sPuRQwXaya5YE:100:100::/home/user:/bin/sh
++ourtelnetrescueuser:x:100:100::/home/user:/dev/null
+ guest:xqnMpE/plEnFs:501:501::/home/user/guest:/dev/null
+ admin:cgwvsHpJSf6XU:502:501::/home/user/admin:/dev/null
+ 
+--- nslu2-linksys-ramdisk-2.3r63/usr/local/passwd~	2006-04-18 21:54:47.000000000 -0500
++++ nslu2-linksys-ramdisk-2.3r63/usr/local/passwd	2006-04-18 21:57:48.000000000 -0500
+@@ -4,7 +4,7 @@
+ mail:x:8:12:mail:/var/spool/mail:
+ ftp:x:14:50:FTP User:/:
+ nobody:x:99:99:Nobody:/:
+-ourtelnetrescueuser:sPuRQwXaya5YE:100:100::/home/user:/bin/sh
++ourtelnetrescueuser:x:100:100::/home/user:/dev/null
+ guest:xqnMpE/plEnFs:501:501::/home/user/guest:/dev/null
+ admin:cgwvsHpJSf6XU:502:501::/home/user/admin:/dev/null
+ 
diff --git a/packages/nslu2-binary-only/unslung-rootfs_2.3r63.bb b/packages/nslu2-binary-only/unslung-rootfs_2.3r63.bb
index f105e6830a..1c805a6975 100644
--- a/packages/nslu2-binary-only/unslung-rootfs_2.3r63.bb
+++ b/packages/nslu2-binary-only/unslung-rootfs_2.3r63.bb
@@ -44,6 +44,7 @@ SRC_URI = "http://nslu.sf.net/downloads/nslu2-linksys-ramdisk-2.3r63-2.tar.bz2 \
 	   file://security-fixes.patch;patch=1 \
 	   file://rc.sysinit-clean_var.patch;patch=1 \
 	   file://rc.modules-nls.patch;patch=1 \
+	   file://telnet-passwd.patch;patch=1 \
 	   file://upgrade.htm \
 	   file://telnet.htm \
 	   file://rc.bootbin \
diff --git a/packages/openobex/files/libusb_crosscompile_check.patch b/packages/openobex/files/libusb_crosscompile_check.patch
new file mode 100644
index 0000000000..c28921b8ca
--- /dev/null
+++ b/packages/openobex/files/libusb_crosscompile_check.patch
@@ -0,0 +1,12 @@
+diff -Naur openobex-1.2_old/acinclude.m4 openobex-1.2/acinclude.m4
+--- openobex-1.2_old/acinclude.m4	2006-03-07 19:57:49.000000000 +0200
++++ openobex-1.2/acinclude.m4	2006-04-18 23:07:25.000000000 +0300
+@@ -195,7 +195,7 @@
+ 
+ 	if (test "${usb_enable}" = "yes" && test "${usb_found}" = "yes"); then
+ 		AC_DEFINE(HAVE_USB, 1, [Define if system supports USB and it's enabled])
+-		AC_CHECK_FILE(${usb_prefix}/lib/pkgconfig/libusb.pc, REQUIRES="$REQUIRES libusb")
++		REQUIRES="libusb"
+ 	fi
+ 
+ 	AM_CONDITIONAL(APPS, test "${apps_enable}" = "yes")
diff --git a/packages/openobex/openobex_1.2.bb b/packages/openobex/openobex_1.2.bb
index 421b342476..97f030d3e2 100644
--- a/packages/openobex/openobex_1.2.bb
+++ b/packages/openobex/openobex_1.2.bb
@@ -8,7 +8,8 @@ LICENSE = "GPL"
 PR = "r1"
 
 SRC_URI = "${SOURCEFORGE_MIRROR}/openobex/openobex-${PV}.tar.gz \
-           file://disable-cable-test.patch;patch=1"
+           file://disable-cable-test.patch;patch=1" \
+	   file://libusb_crosscompile_check.patch;patch=1"
 
 inherit autotools binconfig pkgconfig
 
diff --git a/packages/python/python-sip4_4.4.1.bb b/packages/python/python-sip4_4.4.1.bb
new file mode 100644
index 0000000000..97f7375056
--- /dev/null
+++ b/packages/python/python-sip4_4.4.1.bb
@@ -0,0 +1,43 @@
+DESCRIPTION = "Runtime helper for sip-generated python wrapper libraries"
+SECTION = "devel/python"
+HOMEPAGE = "http://www.riverbankcomputing.co.uk/sip"
+AUTHOR = "Phil Thompson"
+MAINTAINER = "Michael 'Mickey' Lauer <mickey@Vanille.de>"
+LICENSE = "GPL"
+DEPENDS = "python"
+RDEPENDS = "python-core"
+PR = "ml0"
+
+SRC_URI = "http://www.vanille.de/mirror/sip-${PV}.tar.gz"
+S = "${WORKDIR}/sip-${PV}/siplib"
+
+inherit qmake distutils-base
+
+EXTRA_QMAKEVARS_POST = " TEMPLATE=lib \
+                         CONFIG=console \
+                         DESTDIR= \
+                         VERSION=1.0.0 \
+                         TARGET=sip \
+                         DEFINES=SIP_QT_SUPPORT \
+                         INCLUDEPATH+=. \
+                         INCLUDEPATH+=${STAGING_INCDIR}/${PYTHON_DIR} \
+                         INCLUDEPATH+=${STAGING_INCDIR}"
+
+
+do_configure_prepend() {
+	cat siplib.sbf | sed s,target,TARGET, | sed s,sources,SOURCES, | sed s,headers,HEADERS, > siplib.pro
+}
+
+do_stage() {
+	install -d ${STAGING_DIR}/${BUILD_SYS}/lib/${PYTHON_DIR}/site-packages/
+	# sipconfig.py sipdistutils.py
+	install -m 0644 sip.h ${STAGING_INCDIR}/sip.h
+}
+
+do_install() {
+	install -d ${D}${libdir}/${PYTHON_DIR}/site-packages/
+	install -m 0755 libsip.so.1.0.0 ${D}${libdir}/${PYTHON_DIR}/site-packages/sip.so
+}
+
+FILES_${PN} = "${libdir}/${PYTHON_DIR}/site-packages/sip.so"
+
diff --git a/packages/sip/sip-native_4.2rc1.bb b/packages/sip/sip-native_4.2rc1.bb
deleted file mode 100644
index 1f58bb75ed..0000000000
--- a/packages/sip/sip-native_4.2rc1.bb
+++ /dev/null
@@ -1,19 +0,0 @@
-DESCRIPTION = "SIP - A Python Wrapper Generator"
-SECTION = "base"
-PRIORITY = "optional"
-MAINTAINER = "Michael 'Mickey' Lauer <mickey@Vanille.de>"
-LICENSE = "GPL"
-
-SRC_URI = "http://www.vanille.de/mirror/sip-${PV}.tar.gz"
-S = "${WORKDIR}/sip-${PV}/sipgen"
-
-inherit qmake native
-
-DEFAULT_PREFERENCE = "-1"
-
-EXTRA_QMAKEVARS_POST = "DESTDIR=${STAGING_BINDIR} CONFIG=console"
-
-do_configure_prepend() {
-	cat sipgen.sbf | sed s,target,TARGET, | sed s,sources,SOURCES, | sed s,headers,HEADERS, > sipgen.pro
-}
-
diff --git a/packages/sip/sip4-native_4.4.1.bb b/packages/sip/sip4-native_4.4.1.bb
new file mode 100644
index 0000000000..54e5beca4a
--- /dev/null
+++ b/packages/sip/sip4-native_4.4.1.bb
@@ -0,0 +1,23 @@
+DESCRIPTION = "SIP is a C++/Python Wrapper Generator"
+SECTION = "base"
+HOMEPAGE = "http://www.riverbankcomputing.co.uk/sip"
+AUTHOR = "Phil Thompson"
+PRIORITY = "optional"
+MAINTAINER = "Michael 'Mickey' Lauer <mickey@Vanille.de>"
+LICENSE = "GPL"
+
+SRC_URI = "http://www.riverbankcomputing.com/Downloads/sip4/sip-${PV}.tar.gz"
+S = "${WORKDIR}/sip-${PV}/sipgen"
+
+inherit qmake native
+
+EXTRA_QMAKEVARS_POST = "DESTDIR=${S} CONFIG=console"
+
+do_configure_prepend() {
+	cat sipgen.sbf | sed s,target,TARGET, | sed s,sources,SOURCES, | sed s,headers,HEADERS, > sipgen.pro
+}
+
+do_stage() {
+	install -m 0755 sip ${STAGING_BINDIR}/sip4
+}
+
diff --git a/packages/sip/sip_3.10.1.bb b/packages/sip/sip_3.10.1.bb
deleted file mode 100644
index db3600f07f..0000000000
--- a/packages/sip/sip_3.10.1.bb
+++ /dev/null
@@ -1,15 +0,0 @@
-DESCRIPTION = "SIP - A Python Wrapper Generator"
-SECTION = "devel"
-PRIORITY = "optional"
-MAINTAINER = "Michael 'Mickey' Lauer <mickey@Vanille.de>"
-LICENSE = "GPL"
-DEPENDS = "python-native"
-
-SRC_URI = "http://www.vanille.de/mirror/sip-${PV}.tar.gz"
-S = "${WORKDIR}/sip-${PV}/sipgen"
-
-inherit qmake
-
-QMAKE_PROFILES = "sipgen.pro.in"
-EXTRA_QMAKEVARS_POST = "DESTDIR=${S}"
-
diff --git a/packages/uae/e-uae_0.8.27.bb b/packages/uae/e-uae_0.8.27.bb
index 60b9b7d8e9..454136cc05 100644
--- a/packages/uae/e-uae_0.8.27.bb
+++ b/packages/uae/e-uae_0.8.27.bb
@@ -5,7 +5,7 @@ DEPENDS = "libsdl-qpe"
 LICENSE = "GPL"
 PR = "r1"
 
-SRC_URI = "http://rcdrummond.net/uae/e-uae-${PV}/e-uae-${PV}.tar.bz2 \
+SRC_URI = "http://rcdrummond.net/uae/old/e-uae-${PV}/e-uae-${PV}.tar.bz2 \
            file://configure.patch;patch=1"
 #           file://m4.patch;patch=1"
 
diff --git a/packages/xlibs/libxxf86dga_1.0.0.bb b/packages/xlibs/libxxf86dga_1.0.0.bb
index 9a4824c153..46ab999c5f 100644
--- a/packages/xlibs/libxxf86dga_1.0.0.bb
+++ b/packages/xlibs/libxxf86dga_1.0.0.bb
@@ -2,7 +2,7 @@ DESCRIPTION = "Xxf86dga extension library."
 SECTION = "x11/libs"
 LICENSE = "XFree86"
 
-DEPENDS = "libx11 libxext xxf86dgaproto"
+DEPENDS = "libx11 libxext xf86dgaproto"
 
 SRC_URI = "${XORG_MIRROR}/X11R7.0/src/lib/libXxf86dga-${PV}.tar.bz2"
 S = "${WORKDIR}/libXxf86dga-${PV}"
diff --git a/packages/xlibs/libxxf86vm_1.0.0.bb b/packages/xlibs/libxxf86vm_1.0.0.bb
index fe67e123d9..a5df50e566 100644
--- a/packages/xlibs/libxxf86vm_1.0.0.bb
+++ b/packages/xlibs/libxxf86vm_1.0.0.bb
@@ -2,7 +2,7 @@ DESCRIPTION = "Xxf86vm extension library."
 SECTION = "x11/libs"
 LICENSE = "MIT"
 
-DEPENDS = "libx11 libxext xxf86vidmodeproto"
+DEPENDS = "libx11 libxext xf86vidmodeproto"
 
 SRC_URI = "${XORG_MIRROR}/X11R7.0/src/lib/libXxf86vm-${PV}.tar.bz2"
 S = "${WORKDIR}/libXxf86vm-${PV}"