VSTUI X11 port and embeddable GTK wrapper.

Build mdaSpecMeter and GUI.


git-svn-id: http://svn.drobilla.net/lad/mda-lv2@1340 a436a847-0d15-0410-975c-d299462d15a1

6 files changed, 9869 insertions, 0 deletions

diff --git a/vstgui/TODO b/vstgui/TODO
new file mode 100644
index 0000000..27096e5
--- /dev/null
+++ b/vstgui/TODO
@@ -0,0 +1,19 @@
+//-----------------------------------------------------------------------------
+// VST Plug-Ins SDK Linux ONLY Port
+// VSTGUIL: Graphical User Interface Framework for VST plugins on LINUX:
+//
+// Version: 0.1
+// Author: kRAkEn/gORe
+// Date: 2007/01/21
+//-----------------------------------------------------------------------------
+
+Todo List:
+
+- Fix multiple CParamDisplay objects not showed correctly (only the first is shown)
+- Update other controls from a single control->update (), usually params displays not updating while mouse drag
+- Fix fonts names and sizes (actually only fixed and courier)
+- COffscreenContext not working (add an internal GC different from the frame GC)
+- Fix COffscreenContext CopyFrom
+- Turn back on CViewContainer::bOffscreenDraw (actually turned off to see something)
+- Keep out MOTIF defines (now that IS the default)
+- Make CBitmap work on every kind of GC (not pFrame only)
diff --git a/vstgui/vstcontrols.cpp b/vstgui/vstcontrols.cpp
new file mode 100644
index 0000000..0b0800c
--- /dev/null
+++ b/vstgui/vstcontrols.cpp
@@ -0,0 +1,3651 @@
+/* ----------------------------------------------------------------------------
+ * VSTGUI for X11/LV2/PNG
+ * Author: Dave Robillard
+ * Released under the revised BSD license, as below
+ * ----------------------------------------------------------------------------
+ *
+ * Based on:
+ * ----------------------------------------------------------------------------
+ * VSTGUIL: Graphical User Interface Framework for VST plugins on LINUX
+ * Version: 0.1, Date: 2007/01/21
+ * Author: kRAkEn/gORe
+ *
+ * Which was based on:
+ * ----------------------------------------------------------------------------
+ * VSTGUI: Graphical User Interface Framework for VST plugins
+ * Version 3.0       $Date: 2005/08/12 12:45:00 $
+ * ----------------------------------------------------------------------------
+ * VSTGUI LICENSE
+ * 2004, Steinberg Media Technologies, All Rights Reserved
+ * ----------------------------------------------------------------------------
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of the Steinberg Media Technologies nor the names of
+ *     its contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A  PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+ * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ * ----------------------------------------------------------------------------
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+
+#ifndef __vstcontrols__
+#include "vstcontrols.h"
+#endif
+
+#include "vstkeycode.h"
+
+namespace VSTGUI {
+
+// some external variables (vstgui.cpp)
+extern long gStandardFontSize [];
+extern const char *gStandardFontName [];
+
+//------------------------------------------------------------------------
+// CControl
+//------------------------------------------------------------------------
+/*! @class CControl
+This object manages the tag identification and the value of a control object.
+
+Note:
+Since version 2.1, when an object uses the transparency for its background and draws on it (tranparency area)
+or the transparency area changes during different draws (CMovieBitmap ,...), the background will be false (not updated),
+you have to rewrite the draw function in order to redraw the background and then call the draw of the object.
+*/
+CControl::CControl (const CRect &size, CControlListener *listener, long tag,
+                    CBitmap *pBackground)
+:    CView (size),
+    listener (listener), tag (tag), oldValue (1), defaultValue (0.5f),
+    value (0), vmin (0), vmax (1.f), wheelInc (0.1f), lastTicks (-1)
+{
+    delta = 500;
+
+    if (delta < 250)
+        delta = 250;
+
+    setTransparency (false);
+    setMouseEnabled (true);
+    backOffset (0 ,0);
+
+    setBackground (pBackground);
+}
+
+//------------------------------------------------------------------------
+CControl::~CControl ()
+{
+}
+
+//------------------------------------------------------------------------
+void CControl::beginEdit ()
+{
+    // begin of edit parameter
+    getFrame ()->setFocusView(this);
+    getFrame ()->beginEdit (tag);
+}
+
+//------------------------------------------------------------------------
+void CControl::endEdit ()
+{
+    // end of edit parameter
+    getFrame ()->endEdit (tag);
+}
+
+//------------------------------------------------------------------------
+bool CControl::isDirty () const
+{
+    if (oldValue != value || CView::isDirty ())
+        return true;
+    return false;
+}
+
+//------------------------------------------------------------------------
+void CControl::setDirty (const bool val)
+{
+    CView::setDirty (val);
+    if (val)
+    {
+        if (value != -1.f)
+            oldValue = -1.f;
+        else
+            oldValue = 0.f;
+    }
+    else
+        oldValue = value;
+}
+
+//------------------------------------------------------------------------
+void CControl::setBackOffset (CPoint &offset)
+{
+    backOffset = offset;
+}
+
+//-----------------------------------------------------------------------------
+void CControl::copyBackOffset ()
+{
+    backOffset (size.left, size.top);
+}
+
+//------------------------------------------------------------------------
+void CControl::bounceValue ()
+{
+    if (value > vmax)
+        value = vmax;
+    else if (value < vmin)
+        value = vmin;
+}
+
+//-----------------------------------------------------------------------------
+bool CControl::checkDefaultValue (CDrawContext *pContext, long button)
+{
+    if (button == (kControl|kLButton))
+    {
+        // begin of edit parameter
+        beginEdit ();
+
+        value = getDefaultValue ();
+        if (isDirty () && listener)
+            listener->valueChanged (pContext, this);
+
+        // end of edit parameter
+        endEdit ();
+        return true;
+    }
+    return false;
+}
+
+//-----------------------------------------------------------------------------
+bool CControl::isDoubleClick ()
+{
+    long ticks = getFrame ()->getTicks ();
+    if (lastTicks <= 0)
+    {
+        lastTicks = ticks;
+        return false;
+    }
+
+    if (lastTicks + delta > ticks)
+        lastTicks = 0;
+    else
+    {
+        lastTicks = ticks;
+        return false;
+    }
+    return true;
+}
+
+//------------------------------------------------------------------------
+// COnOffButton
+//------------------------------------------------------------------------
+/*! @class COnOffButton
+Define a button with 2 positions.
+The pixmap includes the 2 subpixmaps (i.e the rectangle used for the display of this button is half-height of the pixmap).
+When its value changes, the listener is called.
+*/
+COnOffButton::COnOffButton (const CRect &size, CControlListener *listener, long tag,
+                            CBitmap *background, long style)
+: CControl (size, listener, tag, background)
+, style (style)
+{}
+
+//------------------------------------------------------------------------
+COnOffButton::~COnOffButton ()
+{}
+
+//------------------------------------------------------------------------
+void COnOffButton::draw (CDrawContext *pContext)
+{
+//    DBG ("COnOffButton::draw");
+
+    CCoord off;
+
+    if (value && pBackground)
+        off = pBackground->getHeight () / 2;
+    else
+        off = 0;
+
+    if (pBackground)
+    {
+        if (bTransparencyEnabled)
+            pBackground->drawTransparent (pContext, size, CPoint (0, off));
+        else
+            pBackground->draw (pContext, size, CPoint (0, off));
+    }
+    setDirty (false);
+}
+
+//------------------------------------------------------------------------
+void COnOffButton::mouse (CDrawContext *pContext, CPoint &where, long button)
+{
+    if (!bMouseEnabled)
+        return;
+
+    if (button == -1) button = pContext->getMouseButtons ();
+    if (!(button & kLButton))
+        return;
+
+    if (listener && (button & (kAlt | kShift | kControl | kApple)))
+    {
+        if (listener->controlModifierClicked (pContext, this, button) != 0)
+            return;
+    }
+
+    value = ((long)value) ? 0.f : 1.f;
+
+    if (listener && style == kPostListenerUpdate)
+    {
+        // begin of edit parameter
+        beginEdit ();
+
+        listener->valueChanged (pContext, this);
+
+        // end of edit parameter
+        endEdit ();
+    }
+
+    doIdleStuff ();
+
+    if (listener && style == kPreListenerUpdate)
+    {
+        // begin of edit parameter
+        beginEdit ();
+
+        listener->valueChanged (pContext, this);
+
+        // end of edit parameter
+        endEdit ();
+    }
+}
+
+
+//------------------------------------------------------------------------
+// CKnob
+//------------------------------------------------------------------------
+/*! @class CKnob
+Define a knob with a given background and foreground handle.
+The handle describes a circle over the background (between -45deg and +225deg).
+By clicking Alt+Left Mouse the default value is used.
+By clicking Alt+Left Mouse the value changes with a vertical move (version 2.1)
+*/
+CKnob::CKnob (const CRect &size, CControlListener *listener, long tag,
+              CBitmap *background, CBitmap *handle, const CPoint &offset)
+:    CControl (size, listener, tag, background), offset (offset), pHandle (handle)
+{
+    if (pHandle)
+    {
+        pHandle->remember ();
+        inset = (long)((float)pHandle->getWidth () / 2.f + 2.5f);
+    }
+    else
+        inset = 3;
+
+    colorShadowHandle = kGreyCColor;
+    colorHandle = kWhiteCColor;
+    radius = (float)(size.right - size.left) / 2.f;
+
+    rangeAngle = 1.f;
+    setStartAngle ((float)(5.f * kPI / 4.f));
+    setRangeAngle ((float)(-3.f * kPI / 2.f));
+    zoomFactor = 1.5f;
+
+    setWantsFocus (true);
+}
+
+//------------------------------------------------------------------------
+CKnob::~CKnob ()
+{
+    if (pHandle)
+        pHandle->forget ();
+}
+
+//------------------------------------------------------------------------
+void CKnob::draw (CDrawContext *pContext)
+{
+//    DBG ("CKnob::draw");
+
+    if (pBackground)
+    {
+        if (bTransparencyEnabled)
+            pBackground->drawTransparent (pContext, size, offset);
+        else
+            pBackground->draw (pContext, size, offset);
+    }
+    drawHandle (pContext);
+    setDirty (false);
+}
+
+//------------------------------------------------------------------------
+void CKnob::drawHandle (CDrawContext *pContext)
+{
+    CPoint where;
+    valueToPoint (where);
+
+    if (pHandle)
+    {
+        long width  = (long)pHandle->getWidth ();
+        long height = (long)pHandle->getHeight ();
+        where.offset (size.left - width / 2, size.top - height / 2);
+
+        CRect handleSize (0, 0, width, height);
+        handleSize.offset (where.h, where.v);
+        pHandle->drawTransparent (pContext, handleSize);
+    }
+    else
+    {
+        CPoint origin (size.width () / 2, size.height () / 2);
+
+        where.offset (size.left - 1, size.top);
+        origin.offset (size.left - 1, size.top);
+        pContext->setFrameColor (colorShadowHandle);
+        pContext->moveTo (where);
+        pContext->lineTo (origin);
+
+        where.offset (1, -1);
+        origin.offset (1, -1);
+        pContext->setFrameColor (colorHandle);
+        pContext->moveTo (where);
+        pContext->lineTo (origin);
+    }
+}
+
+//------------------------------------------------------------------------
+void CKnob::mouse (CDrawContext *pContext, CPoint &where, long button)
+{
+    if (!bMouseEnabled)
+        return;
+
+    if (button == -1) button = pContext->getMouseButtons ();
+    if (!(button & kLButton))
+        return;
+
+    if (listener && button & (kAlt | kShift | kControl | kApple))
+    {
+        if (listener->controlModifierClicked (pContext, this, button) != 0)
+            return;
+    }
+
+    // check if default value wanted
+    if (checkDefaultValue (pContext, button))
+        return;
+
+    float old = oldValue;
+    CPoint firstPoint;
+    bool  modeLinear = false;
+    float fEntryState = value;
+    float middle = (vmax - vmin) * 0.5f;
+    float range = 200.f;
+    float coef = (vmax - vmin) / range;
+    long  oldButton = button;
+
+    long mode    = kCircularMode;
+    long newMode = getFrame ()->getKnobMode ();
+    if (kLinearMode == newMode)
+    {
+        if (!(button & kAlt))
+            mode = newMode;
+    }
+    else if (button & kAlt)
+        mode = kLinearMode;
+
+    if (mode == kLinearMode && (button & kLButton))
+    {
+        if (button & kShift)
+            range *= zoomFactor;
+        firstPoint = where;
+        modeLinear = true;
+        coef = (vmax - vmin) / range;
+    }
+    else
+    {
+        CPoint where2 (where);
+        where2.offset (-size.left, -size.top);
+        old = valueFromPoint (where2);
+    }
+
+    CPoint oldWhere (-1, -1);
+
+    // begin of edit parameter
+    beginEdit ();
+    do
+    {
+        button = pContext->getMouseButtons ();
+        if (where != oldWhere)
+        {
+            oldWhere = where;
+            if (modeLinear)
+            {
+                CCoord diff = (firstPoint.v - where.v) + (where.h - firstPoint.h);
+                if (button != oldButton)
+                {
+                    range = 200.f;
+                    if (button & kShift)
+                        range *= zoomFactor;
+
+                    float coef2 = (vmax - vmin) / range;
+                    fEntryState += diff * (coef - coef2);
+                    coef = coef2;
+                    oldButton = button;
+                }
+                value = fEntryState + diff * coef;
+                bounceValue ();
+            }
+            else
+            {
+                where.offset (-size.left, -size.top);
+                value = valueFromPoint (where);
+                if (old - value > middle)
+                    value = vmax;
+                else if (value - old > middle)
+                    value = vmin;
+                else
+                    old = value;
+            }
+            if (isDirty () && listener)
+                listener->valueChanged (pContext, this);
+        }
+        getMouseLocation (pContext, where);
+        doIdleStuff ();
+
+    } while (button & kLButton);
+
+    // end of edit parameter
+    endEdit ();
+}
+
+//------------------------------------------------------------------------
+bool CKnob::onWheel (CDrawContext *pContext, const CPoint &where, float distance)
+{
+    if (!bMouseEnabled)
+        return false;
+
+    long buttons = pContext->getMouseButtons ();
+    if (buttons & kShift)
+        value += 0.1f * distance * wheelInc;
+    else
+        value += distance * wheelInc;
+    bounceValue ();
+
+    if (isDirty () && listener)
+    {
+        // begin of edit parameter
+        beginEdit ();
+
+        listener->valueChanged (pContext, this);
+
+        // end of edit parameter
+        endEdit ();
+    }
+    return true;
+}
+
+//------------------------------------------------------------------------
+long CKnob::onKeyDown (VstKeyCode& keyCode)
+{
+    switch (keyCode.virt)
+    {
+    case VKEY_UP :
+    case VKEY_RIGHT :
+    case VKEY_DOWN :
+    case VKEY_LEFT :
+        {
+            float distance = 1.f;
+            if (keyCode.virt == VKEY_DOWN || keyCode.virt == VKEY_LEFT)
+                distance = -distance;
+
+            if (keyCode.modifier & MODIFIER_SHIFT)
+                value += 0.1f * distance * wheelInc;
+            else
+                value += distance * wheelInc;
+            bounceValue ();
+
+            if (isDirty () && listener)
+            {
+                // begin of edit parameter
+                beginEdit ();
+
+                listener->valueChanged (0, this);
+
+                // end of edit parameter
+                endEdit ();
+            }
+        } return 1;
+    }
+    return -1;
+}
+
+//------------------------------------------------------------------------
+void CKnob::setStartAngle (float val)
+{
+    startAngle = val;
+    compute ();
+}
+
+//------------------------------------------------------------------------
+void CKnob::setRangeAngle (float val)
+{
+    rangeAngle = val;
+    compute ();
+}
+
+//------------------------------------------------------------------------
+void CKnob::compute ()
+{
+    aCoef = (vmax - vmin) / rangeAngle;
+    bCoef = vmin - aCoef * startAngle;
+    halfAngle = ((float)k2PI - fabsf (rangeAngle)) * 0.5f;
+    setDirty ();
+}
+
+//------------------------------------------------------------------------
+void CKnob::valueToPoint (CPoint &point) const
+{
+    float alpha = (value - bCoef) / aCoef;
+    point.h = (long)(radius + cosf (alpha) * (radius - inset) + 0.5f);
+    point.v = (long)(radius - sinf (alpha) * (radius - inset) + 0.5f);
+}
+
+//------------------------------------------------------------------------
+float CKnob::valueFromPoint (CPoint &point) const
+{
+    float v;
+    float alpha = (float)atan2 (radius - point.v, point.h - radius);
+    if (alpha < 0.f)
+        alpha += (float)k2PI;
+
+    float alpha2 = alpha - startAngle;
+    if (rangeAngle < 0)
+    {
+        alpha2 -= rangeAngle;
+        float alpha3 = alpha2;
+        if (alpha3 < 0.f)
+            alpha3 += (float)k2PI;
+        else if (alpha3 > k2PI)
+            alpha3 -= (float)k2PI;
+        if (alpha3 > halfAngle - rangeAngle)
+            v = vmax;
+        else if (alpha3 > -rangeAngle)
+            v = vmin;
+        else
+        {
+            if (alpha2 > halfAngle - rangeAngle)
+                alpha2 -= (float)k2PI;
+            else if (alpha2 < -halfAngle)
+                alpha2 += (float)k2PI;
+            v = aCoef * alpha2 + vmax;
+        }
+    }
+    else
+    {
+        float alpha3 = alpha2;
+        if (alpha3 < 0.f)
+            alpha3 += (float)k2PI;
+        else if (alpha3 > k2PI)
+            alpha3 -= (float)k2PI;
+        if (alpha3 > rangeAngle + halfAngle)
+            v = vmin;
+        else if (alpha3 > rangeAngle)
+            v = vmax;
+        else
+        {
+            if (alpha2 > rangeAngle + halfAngle)
+                alpha2 -= (float)k2PI;
+            else if (alpha2 < -halfAngle)
+                alpha2 += (float)k2PI;
+            v = aCoef * alpha2 + vmin;
+        }
+    }
+
+    return v;
+}
+
+//------------------------------------------------------------------------
+void CKnob::setColorShadowHandle (CColor color)
+{
+    colorShadowHandle = color;
+    setDirty ();
+}
+
+//------------------------------------------------------------------------
+void CKnob::setColorHandle (CColor color)
+{
+    colorHandle = color;
+    setDirty ();
+}
+
+//------------------------------------------------------------------------
+void CKnob::setHandleBitmap (CBitmap *bitmap)
+{
+    if (pHandle)
+    {
+        pHandle->forget ();
+        pHandle = 0;
+    }
+
+    if (bitmap)
+    {
+        pHandle = bitmap;
+        pHandle->remember ();
+        inset = (long)((float)pHandle->getWidth () / 2.f + 2.5f);
+    }
+}
+
+
+//------------------------------------------------------------------------
+// CParamDisplay
+//------------------------------------------------------------------------
+/*! @class CParamDisplay
+Define a rectangle view where a text-value can be displayed with a given font and color.
+The user can specify its convert function (from float to char) by default the string format is "%2.2f".
+The text-value is centered in the given rect.
+*/
+CParamDisplay::CParamDisplay (const CRect &size, CBitmap *background, const long style)
+:    CControl (size, 0, 0, background), stringConvert (0), stringConvert2 (0), string2FloatConvert (0),
+    horiTxtAlign (kCenterText), style (style), bTextTransparencyEnabled (true)
+{
+    backOffset (0, 0);
+
+    fontID      = kNormalFont;
+    txtFace     = kNormalFace;
+    fontColor   = kWhiteCColor;
+    backColor   = kBlackCColor;
+    frameColor  = kBlackCColor;
+    shadowColor = kRedCColor;
+    userData    = 0;
+    if (style & kNoDrawStyle)
+        setDirty (false);
+}
+
+//------------------------------------------------------------------------
+CParamDisplay::~CParamDisplay ()
+{}
+
+//------------------------------------------------------------------------
+void CParamDisplay::setStyle (long val)
+{
+    if (style != val)
+    {
+        style = val;
+        setDirty ();
+    }
+}
+
+//------------------------------------------------------------------------
+void CParamDisplay::draw (CDrawContext *pContext)
+{
+//    DBG ("CParamDisplay::draw");
+
+    char string[256];
+    string[0] = 0;
+
+    if (stringConvert2)
+        stringConvert2 (value, string, userData);
+    else if (stringConvert)
+        stringConvert (value, string);
+    else
+        sprintf (string, "%2.2f", value);
+
+    drawText (pContext, string);
+}
+
+//------------------------------------------------------------------------
+void CParamDisplay::drawText (CDrawContext *pContext, char *string, CBitmap *newBack)
+{
+    setDirty (false);
+
+    if (style & kNoDrawStyle)
+        return;
+
+    // draw the background
+    if (newBack)
+    {
+        if (bTransparencyEnabled)
+            newBack->drawTransparent (pContext, size, backOffset);
+        else
+            newBack->draw (pContext, size, backOffset);
+    }
+    else if (pBackground)
+    {
+        if (bTransparencyEnabled)
+            pBackground->drawTransparent (pContext, size, backOffset);
+        else
+            pBackground->draw (pContext, size, backOffset);
+    }
+    else
+    {
+        if (!bTransparencyEnabled)
+        {
+            pContext->setFillColor (backColor);
+            pContext->fillRect (size);
+
+            if (!(style & (k3DIn|k3DOut|kNoFrame)))
+            {
+                pContext->setFrameColor (frameColor);
+                pContext->drawRect (size);
+            }
+        }
+    }
+    // draw the frame for the 3D effect
+    if (style & (k3DIn|k3DOut))
+    {
+        if (style & k3DIn)
+            pContext->setFrameColor (backColor);
+        else
+            pContext->setFrameColor (frameColor);
+        CPoint p;
+        pContext->moveTo (p (size.left, size.bottom));
+        pContext->lineTo (p (size.left, size.top));
+        pContext->lineTo (p (size.right + 1, size.top));
+
+        if (style & k3DIn)
+            pContext->setFrameColor (frameColor);
+        else
+            pContext->setFrameColor (backColor);
+        pContext->moveTo (p (size.right, size.top + 1));
+        pContext->lineTo (p (size.right, size.bottom));
+        pContext->lineTo (p (size.left, size.bottom));
+    }
+
+    if (!(style & kNoTextStyle) && string)
+    {
+        CRect oldClip;
+        pContext->getClipRect (oldClip);
+        CRect newClip (size);
+        newClip.bound (oldClip);
+        pContext->setClipRect (newClip);
+        pContext->setFont (fontID, 0, txtFace);
+
+        // draw darker text (as shadow)
+        if (style & kShadowText)
+        {
+            CRect newSize (size);
+            newSize.offset (1, 1);
+            pContext->setFontColor (shadowColor);
+            pContext->drawString (string, newSize, !bTextTransparencyEnabled, horiTxtAlign);
+        }
+        pContext->setFontColor (fontColor);
+        pContext->drawString (string, size, !bTextTransparencyEnabled, horiTxtAlign);
+        pContext->setClipRect (oldClip);
+    }
+}
+
+//------------------------------------------------------------------------
+void CParamDisplay::setFont (CFont newFontID)
+{
+    // to force the redraw
+    if (fontID != newFontID)
+        setDirty ();
+    fontID = newFontID;
+}
+
+//------------------------------------------------------------------------
+void CParamDisplay::setTxtFace (CTxtFace newTxtFace)
+{
+    // to force the redraw
+    if (txtFace != newTxtFace)
+        setDirty ();
+    txtFace = newTxtFace;
+}
+
+//------------------------------------------------------------------------
+void CParamDisplay::setFontColor (CColor color)
+{
+    // to force the redraw
+    if (fontColor != color)
+        setDirty ();
+    fontColor = color;
+}
+
+//------------------------------------------------------------------------
+void CParamDisplay::setBackColor (CColor color)
+{
+    // to force the redraw
+    if (backColor != color)
+        setDirty ();
+    backColor = color;
+}
+
+//------------------------------------------------------------------------
+void CParamDisplay::setFrameColor (CColor color)
+{
+    // to force the redraw
+    if (frameColor != color)
+        setDirty ();
+    frameColor = color;
+}
+
+//------------------------------------------------------------------------
+void CParamDisplay::setShadowColor (CColor color)
+{
+    // to force the redraw
+    if (shadowColor != color)
+        setDirty ();
+    shadowColor = color;
+}
+
+//------------------------------------------------------------------------
+void CParamDisplay::setHoriAlign (CHoriTxtAlign hAlign)
+{
+    // to force the redraw
+    if (horiTxtAlign != hAlign)
+        setDirty ();
+    horiTxtAlign = hAlign;
+}
+
+//------------------------------------------------------------------------
+void CParamDisplay::setStringConvert (void (*convert) (float value, char *string))
+{
+    stringConvert = convert;
+}
+
+//------------------------------------------------------------------------
+void CParamDisplay::setStringConvert (void (*convert) (float value, char *string,
+                                      void *userDta), void *userData_)
+{
+    stringConvert2 = convert;
+    userData = userData_;
+}
+
+//------------------------------------------------------------------------
+void CParamDisplay::setString2FloatConvert (void (*convert) (char *string, float &output))
+{
+    string2FloatConvert = convert;
+}
+
+//------------------------------------------------------------------------
+// CTextLabel
+//------------------------------------------------------------------------
+/*! @class CTextLabel
+*/
+CTextLabel::CTextLabel (const CRect& size, const char* txt, CBitmap* background, const long style)
+: CParamDisplay (size, background, style)
+, text (0)
+{
+    setText (txt);
+}
+
+//------------------------------------------------------------------------
+CTextLabel::~CTextLabel ()
+{
+    freeText ();
+}
+
+//------------------------------------------------------------------------
+void CTextLabel::freeText ()
+{
+    if (text)
+        free (text);
+    text = 0;
+}
+
+//------------------------------------------------------------------------
+void CTextLabel::setText (const char* txt)
+{
+    freeText ();
+    if (txt)
+    {
+        text = (char*)malloc (strlen (txt)+1);
+        strcpy (text, txt);
+    }
+}
+
+//------------------------------------------------------------------------
+const char* CTextLabel::getText () const
+{
+    return text;
+}
+
+//------------------------------------------------------------------------
+void CTextLabel::draw (CDrawContext *pContext)
+{
+//    DBG ("CTextLabel::draw");
+
+    drawText (pContext, text);
+    setDirty (false);
+}
+
+
+//------------------------------------------------------------------------
+// CTextEdit
+//------------------------------------------------------------------------
+/*! @class CTextEdit
+Define a rectangle view where a text-value can be displayed and edited with a given font and color.
+The user can specify its convert function (from char to char). The text-value is centered in the given rect.
+A pixmap can be used as background.
+*/
+CTextEdit::CTextEdit (const CRect &size, CControlListener *listener, long tag,
+    const char *txt, CBitmap *background, const long style)
+:    CParamDisplay (size, background, style), platformFontColor (0), platformControl (0),
+    platformFont (0), editConvert (0), editConvert2 (0)
+{
+    this->listener = listener;
+    this->tag = tag;
+
+    if (txt)
+        strcpy (text, txt);
+    else
+        strcpy (text, "");
+    setWantsFocus (true);
+}
+
+//------------------------------------------------------------------------
+CTextEdit::~CTextEdit ()
+{}
+
+//------------------------------------------------------------------------
+void CTextEdit::setText (char *txt)
+{
+    if (txt)
+    {
+        if (strcmp (text, txt))
+        {
+            strcpy (text, txt);
+
+            // to force the redraw
+            setDirty ();
+        }
+    }
+    else
+    {
+        if (strcmp (text, ""))
+        {
+            strcpy (text, "");
+
+            // to force the redraw
+            setDirty ();
+        }
+    }
+}
+
+//------------------------------------------------------------------------
+void CTextEdit::getText (char *txt) const
+{
+    if (txt)
+        strcpy (txt, text);
+}
+
+//------------------------------------------------------------------------
+void CTextEdit::draw (CDrawContext *pContext)
+{
+//    DBG ("CTextEdit::draw");
+
+    if (platformControl)
+    {
+        setDirty (false);
+        return;
+    }
+
+    char string[256];
+    string[0] = 0;
+
+    if (editConvert2)
+        editConvert2 (text, string, userData);
+    else if (editConvert)
+        editConvert (text, string);
+    // Allow to display strings through the stringConvert
+    // callbacks inherited from CParamDisplay
+    else if (stringConvert2)
+    {
+        string[0] = 0;
+        stringConvert2 (value, string, userData);
+        strcpy(text, string);
+    }
+    else if (stringConvert)
+    {
+        string[0] = 0;
+        stringConvert (value, string);
+        strcpy(text, string);
+    }
+    else
+        sprintf (string, "%s", text);
+
+    drawText (pContext, string);
+    setDirty (false);
+}
+
+//------------------------------------------------------------------------
+void CTextEdit::mouse (CDrawContext *pContext, CPoint &where, long button)
+{
+    if (!bMouseEnabled)
+        return;
+
+    if (button == -1) button = pContext->getMouseButtons ();
+
+    if (listener && button & (kAlt | kShift | kControl | kApple))
+    {
+        if (listener->controlModifierClicked (pContext, this, button) != 0)
+            return;
+    }
+
+    if (button & kLButton)
+    {
+        if (getFrame ()->getFocusView () != this)
+        {
+            if (style & kDoubleClickStyle)
+                if (!isDoubleClick ())
+                    return;
+
+            beginEdit();
+            takeFocus (pContext);
+        }
+    }
+}
+
+//------------------------------------------------------------------------
+// #include <Xm/Text.h>
+extern XFontStruct *gFontStructs[];
+
+//------------------------------------------------------------------------
+void CTextEdit::takeFocus (CDrawContext *pContext)
+{
+    bWasReturnPressed = false;
+
+/*
+    // we have to add the Text to the parent !!
+    Dimension posX, posY;
+    Widget widget = (Widget)(getFrame ()->getSystemWindow ());
+    XtVaGetValues (widget, XmNx, &posX, XmNy, &posY, 0);
+
+    Arg args[20];
+    int n = 0;
+    XtSetArg (args[n], XmNx, size.left + posX); n++;
+    XtSetArg (args[n], XmNy, size.top + posY); n++;
+    XtSetArg (args[n], XmNwidth, size.width () + 1); n++;
+    XtSetArg (args[n], XmNheight, size.height () + 2); n++;
+
+    XtSetArg (args[n], XmNvalue, text); n++;
+
+    XtSetArg (args[n], XmNshadowType, XmSHADOW_IN); n++;
+    XtSetArg (args[n], XmNshadowThickness, 0); n++;
+    XtSetArg (args[n], XmNcursorPositionVisible, true); n++;
+
+    XtSetArg (args[n], XmNmarginWidth, 0); n++;
+    XtSetArg (args[n], XmNmarginHeight, 0); n++;
+    XtSetArg (args[n], XmNresizeHeight, True); n++;
+    XtSetArg (args[n], XmNborderWidth, 0); n++;
+    XtSetArg (args[n], XmNeditMode, XmSINGLE_LINE_EDIT); n++;
+
+    // get/set the current font
+    XmFontList fl = 0;
+    XFontStruct* fs = gFontStructs [fontID];
+    if (fs)
+    {
+        XmFontListEntry entry = XmFontListEntryCreate (XmFONTLIST_DEFAULT_TAG, XmFONT_IS_FONT, fs);
+        XmFontList fl = XmFontListAppendEntry (0, entry);
+        XtSetArg (args[n], XmNfontList, fl); n++;
+    }
+
+    platformControl = XmCreateText (XtParent (widget), "Text", args, n);
+    XtManageChild ((Widget)platformControl);
+    if (fl)
+        XmFontListFree (fl);
+    XmTextSetSelection ((Widget)platformControl, 0, strlen (text), 0);
+    XmTextSetHighlight ((Widget)platformControl, 0, strlen (text), XmHIGHLIGHT_SELECTED);
+*/
+}
+
+//------------------------------------------------------------------------
+void CTextEdit::looseFocus (CDrawContext *pContext)
+{
+    // Call this yet to avoid recursive call
+    endEdit();
+    if (getFrame ()->getFocusView () == this)
+        getFrame ()->setFocusView (0);
+
+    if (platformControl == 0)
+        return;
+
+/*
+    char oldText[256];
+    strcpy (oldText, text);
+
+    char *pNewText = XmTextGetString ((Widget)platformControl);
+    strcpy (text, pNewText);
+    XtFree (pNewText);
+
+    XtUnmanageChild ((Widget)platformControl);
+    XtDestroyWidget ((Widget)platformControl);
+
+    CPoint origOffset;
+    bool resetContextOffset = false;
+    if (!pContext)
+    {
+        // create a local context
+        pContext = getFrame ()->createDrawContext ();
+        if (getParentView ())
+        {
+            resetContextOffset = true;
+            origOffset.x = pContext->offset.x;
+            origOffset.y = pContext->offset.y;
+            CView *view= getParentView ();
+            CRect rect2;
+            view->getViewSize (rect2);
+            CPoint offset;
+            view->localToFrame (offset);
+            rect2.offset (offset.x, offset.y);
+            pContext->offset.h = rect2.left;
+            pContext->offset.v = rect2.top;
+        }
+    }
+    else
+        pContext->remember ();
+
+    // update dependency
+    bool change = false;
+    if (strcmp (oldText, text))
+    {
+        change = true;
+        if (listener)
+            listener->valueChanged (pContext, this);
+    }
+
+    platformControl = 0;
+    if (resetContextOffset)
+    {
+        pContext->offset.x = origOffset.x;
+        pContext->offset.y = origOffset.y;
+    }
+    pContext->forget ();
+
+    if (change)
+        doIdleStuff ();
+
+    CView* receiver = pParentView ? pParentView : pParentFrame;
+    if (receiver)
+        receiver->notify (this, "LooseFocus");
+*/
+}
+
+//------------------------------------------------------------------------
+void CTextEdit::setTextEditConvert (void (*convert) (char *input, char *string))
+{
+    editConvert = convert;
+}
+
+//------------------------------------------------------------------------
+void CTextEdit::setTextEditConvert (void (*convert) (char *input, char *string,
+                                      void *userDta), void *userData)
+{
+    editConvert2 = convert;
+    this->userData = userData;
+}
+
+//------------------------------------------------------------------------
+// COptionMenuScheme
+//------------------------------------------------------------------------
+/*! @class COptionMenuScheme
+Used to define the appearance (font color, background color...) of a popup-menu.
+To define the scheme of a menu, use the appropriate setScheme method (see COptionMenu).
+@section coptionmenuscheme_new_in_3_0 New since 3.0
+You can also use the global variable gOptionMenuScheme to use one scheme on all menus.
+@section coptionmenuscheme_note Note
+If you want to use it on Mac OS X, you must set the macro MAC_ENABLE_MENU_SCHEME (needs Mac OS X 10.3 or higher)
+*/
+COptionMenuScheme* gOptionMenuScheme = 0;
+
+//------------------------------------------------------------------------
+COptionMenuScheme::COptionMenuScheme ()
+{
+    backgroundColor = kGreyCColor;
+    selectionColor = kBlueCColor;
+    textColor = kBlackCColor;
+    hiliteTextColor = kWhiteCColor;
+    disableTextColor = kWhiteCColor;
+
+    font = kNormalFontSmall;
+}
+
+//------------------------------------------------------------------------
+COptionMenuScheme::~COptionMenuScheme ()
+{
+}
+
+//------------------------------------------------------------------------
+void COptionMenuScheme::getItemSize (const char* text, CDrawContext* pContext, CPoint& size)
+{
+    if (!strcmp (text, kMenuSeparator)) // separator
+    {
+        // was: size.h = size.v = 6;
+        size.h = 6;
+        size.v = 18;
+        // separators must have same height, otherwise we have problems
+        // in multi-column menus :(
+    }
+    else
+    {
+        pContext->setFont (font);
+        size.h = pContext->getStringWidth (text) + 18;
+        size.v = 18;
+    }
+}
+
+//------------------------------------------------------------------------
+void COptionMenuScheme::drawItemBack (CDrawContext* pContext, const CRect& rect, bool hilite)
+{
+    if (hilite)
+        pContext->setFillColor (selectionColor);
+    else
+        pContext->setFillColor (backgroundColor);
+    pContext->fillRect (rect);
+}
+
+//------------------------------------------------------------------------
+void COptionMenuScheme::drawItem (const char* text, long itemId, long state, CDrawContext* pContext, const CRect& rect)
+{
+    bool hilite = (state & kSelected) != 0;
+
+    drawItemBack (pContext, rect, hilite);
+
+    if (!strcmp (text, kMenuSeparator))
+    {
+        CCoord y = rect.top + rect.height () / 2;
+
+        const CColor bc = { 0, 0, 0, 150};
+        const CColor wc = { 255, 255, 255, 150};
+
+        pContext->setFrameColor (bc);
+        pContext->moveTo (CPoint (rect.left + 2, y - 1));
+        pContext->lineTo (CPoint (rect.right - 2, y - 1));
+        pContext->setFrameColor (wc);
+        pContext->moveTo (CPoint (rect.left + 2, y));
+        pContext->lineTo (CPoint (rect.right - 2, y));
+        return;
+    }
+
+    CRect r;
+    if (state & kChecked)
+    {
+        r (6, 4, 14, 12);
+        r.offset (rect.left, rect.top);
+        if (hilite)
+            pContext->setFillColor (hiliteTextColor);
+        else
+            pContext->setFillColor (textColor);
+        pContext->fillEllipse (r);
+    }
+
+    r = rect;
+    r.left += 18;
+    pContext->setFont (font);
+    if (state & kDisabled)
+        pContext->setFontColor (disableTextColor);
+    else
+    {
+        if (hilite)
+            pContext->setFontColor (hiliteTextColor);
+        else
+            pContext->setFontColor (textColor);
+    }
+
+    // this needs to be done right, without changing the text pointer in anyway ;-)
+    char *ptr = (char*)strstr (text, "\t");
+    if (ptr)
+    {
+        char modifier[32];
+        strcpy (modifier, ptr + 1);
+        *ptr = 0;
+        pContext->drawString (text, r, false, kLeftText);
+
+        *ptr = '\t';
+        r.left = r.right - 50;
+        pContext->drawString (modifier, r, false, kLeftText);
+    }
+    else
+        pContext->drawString (text, r, false, kLeftText);
+}
+
+
+//------------------------------------------------------------------------
+// COptionMenu
+//------------------------------------------------------------------------
+/*! @class COptionMenu
+Define a rectangle view where a text-value can be displayed with a given font and color.
+The text-value is centered in the given rect.
+A pixmap can be used as background, a second pixmap can be used when the option menu is popuped.
+There are 2 styles with or without a shadowed text. When a mouse click occurs, a popup menu is displayed.
+*/
+COptionMenu::COptionMenu (const CRect &size, CControlListener *listener, long tag,
+                          CBitmap *background, CBitmap *bgWhenClick, const long style)
+:    CParamDisplay (size, background, style), bgWhenClick (bgWhenClick), nbItemsPerColumn (-1),
+    prefixNumbers (0), scheme (0)
+{
+    this->listener = listener;
+    this->tag = tag;
+
+    nbEntries = 0;
+    nbSubMenus = 0;
+    currentIndex = -1;
+    lastButton = kRButton;
+    platformControl = 0;
+    lastResult = -1;
+    lastMenu = 0;
+
+    if (bgWhenClick)
+        bgWhenClick->remember ();
+
+    nbSubMenuAllocated = nbAllocated = 0;
+
+    check = 0;
+    entry = 0;
+    submenuEntry = 0;
+}
+
+//------------------------------------------------------------------------
+COptionMenu::~COptionMenu ()
+{
+    removeAllEntry ();
+
+    if (bgWhenClick)
+        bgWhenClick->forget ();
+}
+
+//------------------------------------------------------------------------
+void COptionMenu::setPrefixNumbers (long preCount)
+{
+    prefixNumbers = preCount;
+}
+
+//-----------------------------------------------------------------------------
+bool COptionMenu::allocateSubMenu (long nb)
+{
+    long newAllocated = nbSubMenuAllocated + nb;
+
+    if (submenuEntry)
+        submenuEntry = (COptionMenu**)realloc (submenuEntry, newAllocated * sizeof (COptionMenu*));
+    else
+        submenuEntry = (COptionMenu**)malloc (newAllocated * sizeof (COptionMenu*));
+
+    long i;
+    for (i = nbSubMenuAllocated; i < newAllocated; i++)
+        submenuEntry[i] = 0;
+
+    nbSubMenuAllocated = newAllocated;
+
+    return true;
+}
+
+//------------------------------------------------------------------------
+bool COptionMenu::allocateMenu (long nb)
+{
+    long newAllocated = nbAllocated + nb;
+
+    if (check)
+        check = (bool*)realloc (check, newAllocated * sizeof (bool));
+    else
+        check = (bool*)malloc (newAllocated * sizeof (bool));
+    if (!check)
+        return false;
+
+    if (entry)
+        entry = (char**)realloc (entry, newAllocated * sizeof (char*));
+    else
+        entry = (char**)malloc (newAllocated * sizeof (char*));
+    if (!entry)
+    {
+        free (check);
+        return false;
+    }
+
+    long i;
+    for (i = nbAllocated; i < newAllocated; i++)
+    {
+        check[i] = false;
+        entry[i] = 0;
+    }
+
+    nbAllocated = newAllocated;
+
+    return true;
+}
+
+//------------------------------------------------------------------------
+COptionMenu* COptionMenu::getSubMenu (long idx) const
+{
+    if (submenuEntry && idx < nbSubMenus)
+        return submenuEntry[idx];
+    return 0;
+}
+
+//------------------------------------------------------------------------
+bool COptionMenu::addEntry (COptionMenu *subMenu, char *txt)
+{
+    if (nbEntries >= MAX_ENTRY || !subMenu || !txt)
+        return false;
+
+    if (nbEntries >= nbAllocated)
+        if (!allocateMenu (32))
+            return false;
+
+    entry[nbEntries] = (char*)malloc (256);
+    switch (prefixNumbers)
+    {
+        case 2:
+            sprintf (entry[nbEntries], "-M%1d %s", (int)(nbEntries + 1), txt);
+            break;
+
+        case 3:
+            sprintf (entry[nbEntries], "-M%02d %s", (int)(nbEntries + 1), txt);
+            break;
+
+        case 4:
+            sprintf (entry[nbEntries], "-M%03d %s", (int)(nbEntries + 1), txt);
+            break;
+
+        default:
+            sprintf (entry[nbEntries], "-M%s", txt);
+    }
+
+
+    if (nbSubMenus >= nbSubMenuAllocated)
+        if (!allocateSubMenu (10))
+            return false;
+
+    submenuEntry[nbSubMenus++] = subMenu;
+    subMenu->remember ();
+
+    nbEntries++;
+
+    if (currentIndex < 0)
+        currentIndex = 0;
+
+    return true;
+}
+
+//------------------------------------------------------------------------
+bool COptionMenu::addEntry (char *txt, long index)
+{
+    if (nbEntries >= MAX_ENTRY)
+        return false;
+
+    if (nbEntries >= nbAllocated)
+        if (!allocateMenu (32))
+            return false;
+
+    entry[nbEntries] = (char*)malloc (256);
+
+    long pos = nbEntries;
+
+    // switch the entries for the insert
+    if (index >= 0)
+    {
+        for (long i = nbEntries; i > index; i--)
+            strcpy (entry[i], entry[i - 1]);
+        if (index >= nbEntries)
+            pos = nbEntries;
+        else
+            pos = index;
+        if (currentIndex >= index)
+            currentIndex++;
+    }
+
+    *entry[pos] = 0;
+    if (txt)
+    {
+        switch (prefixNumbers)
+        {
+            case 2:
+                sprintf (entry[pos], "%1d %s", (int)(index + 1), txt);
+                break;
+
+            case 3:
+                sprintf (entry[pos], "%02d %s", (int)(index + 1), txt);
+                break;
+
+            case 4:
+                sprintf (entry[pos], "%03d %s", (int)(index + 1), txt);
+                break;
+
+            default:
+                strncpy (entry[pos], txt, 256);
+        }
+    }
+
+    nbEntries++;
+
+    if (currentIndex < 0)
+        currentIndex = 0;
+
+    return true;
+}
+
+//------------------------------------------------------------------------
+long COptionMenu::getCurrent (char *txt, bool countSeparator) const
+{
+    if (currentIndex < 0)
+        return -1;
+
+    long result = 0;
+
+    if (countSeparator)
+    {
+        if (txt)
+            strcpy (txt, entry[currentIndex]);
+        result = currentIndex;
+    }
+    else
+    {
+        for (long i = 0; i < currentIndex; i++)
+        {
+            if (strcmp (entry[i], kMenuSeparator) && strncmp (entry[i], kMenuTitle, 2))
+                result++;
+        }
+        if (txt)
+            strcpy (txt, entry[currentIndex]);
+    }
+    return result;
+}
+
+//------------------------------------------------------------------------
+bool COptionMenu::setCurrent (long index, bool countSeparator)
+{
+    if (index < 0 || index >= nbEntries)
+        return false;
+
+    if (countSeparator)
+    {
+        if (!strcmp (entry[index], kMenuSeparator) && strncmp (entry[index], kMenuTitle, 2))
+            return false;
+
+        currentIndex = index;
+    }
+    else
+    {
+        long newCurrent = 0;
+        long i = 0;
+        while (i <= index && newCurrent < nbEntries)
+        {
+            if (strcmp (entry[newCurrent], kMenuSeparator) && strncmp (entry[newCurrent], kMenuTitle, 2))
+                i++;
+            newCurrent++;
+        }
+        currentIndex = newCurrent - 1;
+    }
+    if (style & (kMultipleCheckStyle & ~kCheckStyle))
+        check[currentIndex] = !check[currentIndex];
+
+    // to force the redraw
+    setDirty ();
+
+    return true;
+}
+
+//------------------------------------------------------------------------
+bool COptionMenu::getEntry (long index, char *txt) const
+{
+    if (index < 0 || index >= nbEntries)
+        return false;
+
+    if (txt)
+        strcpy (txt, entry[index]);
+    return true;
+}
+
+//------------------------------------------------------------------------
+bool COptionMenu::setEntry (long index, char *txt)
+{
+    if (index < 0 || index >= nbEntries)
+        return false;
+
+    if (txt)
+        strcpy (entry[index], txt);
+    return true;
+}
+
+//------------------------------------------------------------------------
+bool COptionMenu::removeEntry (long index)
+{
+    if (index < 0 || index >= nbEntries)
+        return false;
+
+    nbEntries--;
+
+    // switch the entries
+    for (long i = index; i < nbEntries; i++)
+    {
+        strcpy (entry[i], entry[i + 1]);
+        check[i] = check [i + 1];
+    }
+
+    if (currentIndex >= index)
+        currentIndex--;
+
+    // delete the last one
+    free (entry[nbEntries]);
+    entry[nbEntries] = 0;
+    check[nbEntries] = false;
+
+    if (nbEntries == 0)
+        currentIndex = -1;
+    return true;
+}
+
+//------------------------------------------------------------------------
+bool COptionMenu::removeAllEntry ()
+{
+    long i;
+    for (i = 0; i < nbEntries; i++)
+    {
+        free (entry[i]);
+        entry[i] = 0;
+        check[i] = false;
+    }
+
+    nbEntries = 0;
+    currentIndex = -1;
+
+    for (i = 0; i < nbSubMenus; i++)
+    {
+        submenuEntry[i]->forget ();
+        submenuEntry[i] = 0;
+    }
+    nbSubMenus = 0;
+
+    if (check)
+        free (check);
+    check = 0;
+    if (entry)
+        free (entry);
+    entry = 0;
+    if (submenuEntry)
+        free (submenuEntry);
+    submenuEntry = 0;
+    nbAllocated = 0;
+    nbSubMenuAllocated = 0;
+
+    return true;
+}
+
+//------------------------------------------------------------------------
+long COptionMenu::getIndex (char *txt) const
+{
+    if (!txt)
+        return -1;
+
+    // search entries
+    for (long i = 0; i < nbEntries; i++)
+        if (!strcmp (entry[i], txt))
+            return i;
+
+    // not found
+    return -1;
+}
+
+//------------------------------------------------------------------------
+bool COptionMenu::checkEntry (long index, bool state)
+{
+    if (index < 0 || index >= nbEntries)
+        return false;
+
+    check[index] = state;
+
+    return true;
+}
+
+//------------------------------------------------------------------------
+bool COptionMenu::checkEntryAlone (long index)
+{
+    if (index < 0 || index >= nbEntries)
+        return false;
+    for (long i = 0; i < nbEntries; i++)
+        check[i] = false;
+    check[index] = true;
+
+    return true;
+}
+
+//------------------------------------------------------------------------
+bool COptionMenu::isCheckEntry (long index) const
+{
+    if (index < 0 || index >= nbEntries)
+        return false;
+
+    return check[index];
+}
+
+//------------------------------------------------------------------------
+void COptionMenu::draw (CDrawContext *pContext)
+{
+//    DBG ("COptionMenu::draw");
+
+    if (currentIndex >= 0 && nbEntries)
+        drawText (pContext, entry[currentIndex] + prefixNumbers);
+    else
+        drawText (pContext, NULL);
+}
+
+//------------------------------------------------------------------------
+void COptionMenu::mouse (CDrawContext *pContext, CPoint &where, long button)
+{
+    if (!bMouseEnabled || !getFrame () || !pContext)
+        return;
+
+    lastButton = (button != -1) ? button : pContext->getMouseButtons ();
+
+    if (listener && button & (kAlt | kShift | kControl | kApple))
+    {
+        if (listener->controlModifierClicked (pContext, this, button) != 0)
+            return;
+    }
+
+    if (lastButton & (kLButton|kRButton|kApple))
+    {
+        if (bgWhenClick)
+        {
+            char string[256];
+            if (currentIndex >= 0)
+                sprintf (string, "%s", entry[currentIndex]);
+            else
+                string[0] = 0;
+
+            drawText (pContext, string, bgWhenClick);
+        }
+
+        beginEdit();
+        takeFocus (pContext);
+    }
+}
+
+//------------------------------------------------------------------------
+/*
+#include <Xm/RowColumn.h>
+#include <Xm/ToggleB.h>
+#include <Xm/PushB.h>
+#include <Xm/SeparatoG.h>
+
+static void _unmapCallback (Widget item, XtPointer clientData, XtPointer callData);
+static void _activateCallback (Widget item, XtPointer clientData, XtPointer callData);
+
+//------------------------------------------------------------------------
+static void _unmapCallback (Widget item, XtPointer clientData, XtPointer callData)
+{
+    COptionMenu *optionMenu= (COptionMenu*)clientData;
+    optionMenu->looseFocus ();
+}
+
+//------------------------------------------------------------------------
+static void _activateCallback (Widget item, XtPointer clientData, XtPointer callData)
+{
+    COptionMenu *optionMenu= (COptionMenu*)clientData;
+    optionMenu->setCurrentSelected ((void*)item);
+}
+*/
+
+//------------------------------------------------------------------------
+COptionMenu *COptionMenu::getLastItemMenu (long &idxInMenu) const
+{
+    idxInMenu = lastMenu ? (long)lastMenu->getValue (): -1;
+    return lastMenu;
+}
+
+//------------------------------------------------------------------------
+COptionMenu *COptionMenu::getItemMenu (long idx, long &idxInMenu, long &offsetIdx)
+{
+    COptionMenu *menu = 0;
+    for (long i = 0; i < nbSubMenus; i++)
+    {
+        menu = submenuEntry[i]->getItemMenu (idx, idxInMenu, offsetIdx);
+        if (menu)
+            break;
+    }
+    return menu;
+}
+
+//------------------------------------------------------------------------
+void COptionMenu::removeItems ()
+{
+    for (long i = 0; i < nbSubMenus; i++)
+        submenuEntry[i]->removeItems ();
+}
+
+//------------------------------------------------------------------------
+void *COptionMenu::appendItems (long &offsetIdx)
+{
+    //bool multipleCheck = style & (kMultipleCheckStyle & ~kCheckStyle);
+	return NULL;
+}
+
+//------------------------------------------------------------------------
+void COptionMenu::setValue (float val)
+{
+    if ((long)val < 0 || (long)val >= nbEntries)
+        return;
+
+    currentIndex = (long)val;
+    if (style & (kMultipleCheckStyle & ~kCheckStyle))
+        check[currentIndex] = !check[currentIndex];
+    CParamDisplay::setValue (val);
+
+    // to force the redraw
+    setDirty ();
+}
+
+//------------------------------------------------------------------------
+void COptionMenu::takeFocus (CDrawContext *pContext)
+{
+    if (!getFrame ())
+        return;
+
+/*
+
+    bool multipleCheck = style & (kMultipleCheckStyle & ~kCheckStyle);
+    lastResult = -1;
+    lastMenu = 0;
+
+    Arg args[10];
+    int n = 0;
+
+    // get the position of the pParent
+    CRect rect;
+    getFrame ()->getSize (&rect);
+
+    if (pContext)
+    {
+        rect.left += pContext->offset.h;
+        rect.top  += pContext->offset.v;
+    }
+
+    // create a popup menu
+    int offset;
+    if (style & kPopupStyle)
+        offset = (int)(rect.top + size.top);
+    else
+        offset = (int)(rect.top + size.bottom);
+
+    XtSetArg (args[n], XmNx, rect.left + size.left); n++;
+    XtSetArg (args[n], XmNy, offset); n++;
+    XtSetArg (args[n], XmNmenuHistory, currentIndex); n++;
+    XtSetArg (args[n], XmNtraversalOn, true); n++;
+
+    platformControl = (void*)XmCreatePopupMenu ((Widget)(getFrame ()->getSystemWindow ()),
+            "popup", args, n);
+
+    XtAddCallback ((Widget)platformControl, XmNunmapCallback, _unmapCallback, this);
+
+    // insert the menu items
+    for (long i = 0; i < nbEntries; i++)
+    {
+        if (!strcmp (entry[i], kMenuSeparator))
+        {
+            itemWidget[i] = (void*)XtCreateManagedWidget ("separator",
+                             xmSeparatorGadgetClass, (Widget)platformControl, 0, 0);
+        }
+        else
+        {
+            if (multipleCheck)
+            {
+                itemWidget[i] = (void*)XtVaCreateManagedWidget (entry[i],
+                    xmToggleButtonWidgetClass, (Widget)platformControl,
+                    XmNset, check[i], XmNvisibleWhenOff, false, 0);
+                XtAddCallback ((Widget)itemWidget[i], XmNvalueChangedCallback, _activateCallback, this);
+            }
+            else if (style & kCheckStyle)
+            {
+                itemWidget[i] = (void*)XtVaCreateManagedWidget (entry[i],
+                    xmToggleButtonWidgetClass, (Widget)platformControl,
+                    XmNset, (i == currentIndex) ? true : false, XmNvisibleWhenOff, false, 0);
+                XtAddCallback ((Widget)itemWidget[i], XmNvalueChangedCallback, _activateCallback, this);
+            }
+            else
+            {
+                itemWidget[i] = (void*)XtVaCreateManagedWidget (entry[i],
+                    xmPushButtonWidgetClass, (Widget)platformControl, 0);
+                XtAddCallback ((Widget)itemWidget[i], XmNactivateCallback, _activateCallback, this);
+            }
+        }
+    }
+
+    XtManageChild ((Widget)platformControl);
+    getFrame ()->setFocusView (0);
+    endEdit();
+*/
+}
+
+//------------------------------------------------------------------------
+void COptionMenu::looseFocus (CDrawContext *pContext)
+{
+    if (platformControl == 0)
+        return;
+
+/*
+    for (long i = 0; i < nbEntries; i++)
+        if (itemWidget[i])
+            XtDestroyWidget ((Widget)itemWidget[i]);
+
+    if (platformControl)
+    {
+        XtUnmanageChild ((Widget)platformControl);
+        XtDestroyWidget ((Widget)platformControl);
+    }
+*/
+    platformControl = 0;
+}
+
+//------------------------------------------------------------------------
+void COptionMenu::setCurrentSelected (void *itemSelected)
+{
+    // retrieve the current index
+    if (itemSelected != 0)
+    {
+        for (long i = 0; i < nbEntries; i++)
+            if (itemWidget[i] == itemSelected)
+            {
+                currentIndex = i;
+                break;
+            }
+    }
+
+    // update dependency
+    CDrawContext *pContext = new CDrawContext (getFrame (), (void*)getFrame ()->getGC (), (void*)getFrame ()->getBackBuffer ());
+
+    setValue (currentIndex);
+
+    if (listener)
+        listener->valueChanged (pContext, this);
+    delete pContext;
+}
+
+
+//------------------------------------------------------------------------
+// CAnimKnob
+//------------------------------------------------------------------------
+/*! @class CAnimKnob
+Such as a CKnob control object, but there is a unique pixmap which contains different views (subpixmaps) of this knob.
+According to the value, a specific subpixmap is displayed. The different subpixmaps are stacked in the pixmap object.
+*/
+CAnimKnob::CAnimKnob (const CRect &size, CControlListener *listener, long tag,
+                      CBitmap *background, CPoint &offset)
+: CKnob (size, listener, tag, background, 0, offset), bInverseBitmap (false)
+{
+    heightOfOneImage = size.height ();
+    subPixmaps = (short)(background->getHeight () / heightOfOneImage);
+    inset = 0;
+}
+
+//------------------------------------------------------------------------
+CAnimKnob::CAnimKnob (const CRect &size, CControlListener *listener, long tag,
+                      long subPixmaps,         // number of subPixmaps
+                      CCoord heightOfOneImage,   // height of one image in pixel
+                      CBitmap *background, CPoint &offset)
+: CKnob (size, listener, tag, background, 0, offset),
+   subPixmaps (subPixmaps), heightOfOneImage (heightOfOneImage), bInverseBitmap (false)
+{
+    inset = 0;
+}
+
+//------------------------------------------------------------------------
+CAnimKnob::~CAnimKnob ()
+{}
+
+//-----------------------------------------------------------------------------------------------
+bool CAnimKnob::isDirty () const
+{
+    if (!bDirty)
+    {
+        CPoint p;
+        valueToPoint (p);
+        if (p == lastDrawnPoint)
+            return false;
+    }
+    return CKnob::isDirty ();
+}
+
+//------------------------------------------------------------------------
+void CAnimKnob::draw (CDrawContext *pContext)
+{
+//    DBG ("CAnimKnob::draw");
+
+    CPoint where (0, 0);
+    if (value >= 0.f)
+    {
+        CCoord tmp = heightOfOneImage * (subPixmaps - 1);
+        if (bInverseBitmap)
+            where.v = (long)((1 - value) * (float)tmp);
+        else
+            where.v = (long)(value * (float)tmp);
+        for (CCoord realY = 0; realY <= tmp; realY += heightOfOneImage)
+        {
+            if (where.v < realY)
+            {
+                where.v = realY - heightOfOneImage;
+                if (where.v < 0)
+                    where.v = 0;
+                break;
+            }
+        }
+    }
+
+    if (pBackground)
+    {
+        if (bTransparencyEnabled)
+            pBackground->drawTransparent (pContext, size, where);
+        else
+            pBackground->draw (pContext, size, where);
+    }
+    valueToPoint (lastDrawnPoint);
+    setDirty (false);
+}
+
+//------------------------------------------------------------------------
+// CVerticalSwitch
+//------------------------------------------------------------------------
+/*! @class CVerticalSwitch
+Define a switch with a given number of positions, the current position is defined by the position
+of the last click on this object (the object is divided in its height by the number of position).
+Each position has its subpixmap, each subpixmap is stacked in the given handle pixmap.
+By clicking Alt+Left Mouse the default value is used.
+*/
+CVerticalSwitch::CVerticalSwitch (const CRect &size, CControlListener *listener, long tag,
+                                  CBitmap *background, CPoint &offset)
+: CControl (size, listener, tag, background), offset (offset)
+{
+    heightOfOneImage = size.height ();
+    subPixmaps = (long)(background->getHeight () / heightOfOneImage);
+    iMaxPositions = subPixmaps;
+
+    setDefaultValue (0.f);
+}
+
+//------------------------------------------------------------------------
+CVerticalSwitch::CVerticalSwitch (const CRect &size, CControlListener *listener, long tag,
+                                  long subPixmaps,       // number of subPixmaps
+                                  CCoord heightOfOneImage, // height of one image in pixel
+                                  long iMaxPositions,
+                                  CBitmap *background, CPoint &offset)
+: CControl (size, listener, tag, background), offset (offset),
+    subPixmaps (subPixmaps), heightOfOneImage (heightOfOneImage),
+    iMaxPositions (iMaxPositions)
+{
+    setDefaultValue (0.f);
+}
+
+//------------------------------------------------------------------------
+CVerticalSwitch::~CVerticalSwitch ()
+{}
+
+//------------------------------------------------------------------------
+void CVerticalSwitch::draw (CDrawContext *pContext)
+{
+//    DBG ("CVerticalSwitch::draw");
+
+    if (pBackground)
+    {
+        // source position in bitmap
+        CPoint where (0, heightOfOneImage * ((long)(value * (iMaxPositions - 1) + 0.5f)));
+
+        if (bTransparencyEnabled)
+            pBackground->drawTransparent (pContext, size, where);
+        else
+            pBackground->draw (pContext, size, where);
+    }
+    setDirty (false);
+}
+
+//------------------------------------------------------------------------
+void CVerticalSwitch::mouse (CDrawContext *pContext, CPoint &where, long button)
+{
+    if (!bMouseEnabled)
+        return;
+
+    if (button == -1) button = pContext->getMouseButtons ();
+    if (!(button & kLButton))
+        return;
+
+    if (listener && button & (kAlt | kShift | kControl | kApple))
+    {
+        if (listener->controlModifierClicked (pContext, this, button) != 0)
+            return;
+    }
+
+    // check if default value wanted
+    if (checkDefaultValue (pContext, button))
+        return;
+
+    double coef = (double)heightOfOneImage / (double)iMaxPositions;
+
+    // begin of edit parameter
+    beginEdit ();
+    do
+    {
+        value = (long)((where.v - size.top) / coef) / (float)(iMaxPositions - 1);
+        if (value > 1.f)
+            value = 1.f;
+        else if (value < 0.f)
+            value = 0.f;
+
+        if (isDirty () && listener)
+            listener->valueChanged (pContext, this);
+
+        getMouseLocation (pContext, where);
+
+        doIdleStuff ();
+    }
+    while (pContext->getMouseButtons () == button);
+
+    // end of edit parameter
+    endEdit ();
+}
+
+
+//------------------------------------------------------------------------
+// CHorizontalSwitch
+//------------------------------------------------------------------------
+/*! @class CHorizontalSwitch
+Same as the CVerticalSwitch but horizontal.
+*/
+CHorizontalSwitch::CHorizontalSwitch (const CRect &size, CControlListener *listener, long tag,
+                                  CBitmap *background, CPoint &offset)
+: CControl (size, listener, tag, background), offset (offset)
+{
+    heightOfOneImage = size.width ();
+    subPixmaps = (long)(background->getWidth () / heightOfOneImage);
+    iMaxPositions = subPixmaps;
+
+    setDefaultValue (0.f);
+}
+
+//------------------------------------------------------------------------
+CHorizontalSwitch::CHorizontalSwitch (const CRect &size, CControlListener *listener, long tag,
+                                  long subPixmaps,   // number of subPixmaps
+                                  CCoord heightOfOneImage, // height of one image in pixel
+                                  long iMaxPositions,
+                                  CBitmap *background, CPoint &offset)
+: CControl (size, listener, tag, background), offset (offset),
+    subPixmaps (subPixmaps),
+    iMaxPositions (iMaxPositions),
+	heightOfOneImage (heightOfOneImage)
+{
+    setDefaultValue (0.f);
+}
+
+//------------------------------------------------------------------------
+CHorizontalSwitch::~CHorizontalSwitch ()
+{}
+
+//------------------------------------------------------------------------
+void CHorizontalSwitch::draw (CDrawContext *pContext)
+{
+//    DBG ("CHorizontalSwitch::draw");
+
+    if (pBackground)
+    {
+        // source position in bitmap
+        CPoint where (0, heightOfOneImage * ((long)(value * (iMaxPositions - 1) + 0.5f)));
+
+        if (bTransparencyEnabled)
+            pBackground->drawTransparent (pContext, size, where);
+        else
+            pBackground->draw (pContext, size, where);
+    }
+    setDirty (false);
+}
+
+//------------------------------------------------------------------------
+void CHorizontalSwitch::mouse (CDrawContext *pContext, CPoint &where, long button)
+{
+    if (!bMouseEnabled)
+        return;
+
+    if (button == -1) button = pContext->getMouseButtons ();
+
+    if (listener && button & (kAlt | kShift | kControl | kApple))
+    {
+        if (listener->controlModifierClicked (pContext, this, button) != 0)
+            return;
+    }
+
+    if (!(button & kLButton))
+        return;
+
+    // check if default value wanted
+    if (checkDefaultValue (pContext, button))
+        return;
+
+    double coef = (double)pBackground->getWidth () / (double)iMaxPositions;
+
+    // begin of edit parameter
+    beginEdit ();
+    do
+    {
+        value = (long)((where.h - size.left) / coef) / (float)(iMaxPositions - 1);
+        if (value > 1.f)
+            value = 1.f;
+        else if (value < 0.f)
+            value = 0.f;
+
+        if (isDirty () && listener)
+            listener->valueChanged (pContext, this);
+
+        getMouseLocation (pContext, where);
+
+        doIdleStuff ();
+    }
+    while (pContext->getMouseButtons () == button);
+
+    // end of edit parameter
+    endEdit ();
+}
+
+
+//------------------------------------------------------------------------
+// CRockerSwitch
+//------------------------------------------------------------------------
+/*! @class CRockerSwitch
+Define a rocker switch with 3 states using 3 subpixmaps.
+One click on its leftside, then the first subpixmap is displayed.
+One click on its rightside, then the third subpixmap is displayed.
+When the mouse button is relaxed, the second subpixmap is framed.
+*/
+CRockerSwitch::CRockerSwitch (const CRect &size, CControlListener *listener, long tag,              // identifier tag (ID)
+                              CBitmap *background, CPoint &offset, const long style)
+:    CControl (size, listener, tag, background), offset (offset), style (style)
+{
+    heightOfOneImage = size.width ();
+}
+
+//------------------------------------------------------------------------
+CRockerSwitch::CRockerSwitch (const CRect &size, CControlListener *listener, long tag,              // identifier tag (ID)
+                              CCoord heightOfOneImage, // height of one image in pixel
+                              CBitmap *background, CPoint &offset, const long style)
+:    CControl (size, listener, tag, background), offset (offset),
+    heightOfOneImage (heightOfOneImage), style (style)
+{}
+
+//------------------------------------------------------------------------
+CRockerSwitch::~CRockerSwitch ()
+{}
+
+//------------------------------------------------------------------------
+void CRockerSwitch::draw (CDrawContext *pContext)
+{
+//   DBG ("CRockerSwitch::draw");
+
+    CPoint where (offset.h, offset.v);
+
+    if (value == 1.f)
+        where.v += 2 * heightOfOneImage;
+    else if (value == 0.f)
+        where.v += heightOfOneImage;
+
+    if (pBackground)
+    {
+        if (bTransparencyEnabled)
+            pBackground->drawTransparent (pContext, size, where);
+        else
+            pBackground->draw (pContext, size, where);
+    }
+    setDirty (false);
+}
+
+//------------------------------------------------------------------------
+void CRockerSwitch::mouse (CDrawContext *pContext, CPoint &where, long button)
+{
+    if (!bMouseEnabled)
+        return;
+
+    if (button == -1) button = pContext->getMouseButtons ();
+
+    if (listener && button & (kAlt | kShift | kControl | kApple))
+    {
+        if (listener->controlModifierClicked (pContext, this, button) != 0)
+            return;
+    }
+
+    if (!(button & kLButton))
+        return;
+
+    float fEntryState = value;
+
+    CCoord  width_2  = size.width () / 2;
+    CCoord  height_2 = size.height () / 2;
+
+    // begin of edit parameter
+    beginEdit ();
+
+    if (button)
+    {
+        do
+        {
+            if (style & kHorizontal)
+            {
+                if (where.h >= size.left && where.v >= size.top  &&
+                    where.h <= (size.left + width_2) && where.v <= size.bottom)
+                    value = -1.0f;
+                else if (where.h >= (size.left + width_2) && where.v >= size.top  &&
+                    where.h <= size.right && where.v <= size.bottom)
+                    value = 1.0f;
+                else
+                    value = fEntryState;
+            }
+            else
+            {
+                if (where.h >= size.left && where.v >= size.top  &&
+                    where.h <= size.right && where.v <= (size.top + height_2))
+                    value = -1.0f;
+                else if (where.h >= size.left && where.v >= (size.top + height_2) &&
+                    where.h <= size.right && where.v <= size.bottom)
+                    value = 1.0f;
+                else
+                    value = fEntryState;
+            }
+
+            if (isDirty () && listener)
+                listener->valueChanged (pContext, this);
+
+            getMouseLocation (pContext, where);
+
+            doIdleStuff ();
+        }
+        while (pContext->getMouseButtons ());
+    }
+    else
+    {
+        if (where.h >= size.left && where.v >= size.top  &&
+                where.h <= (size.left + width_2) && where.v <= size.bottom)
+            value = -1.0f;
+        else if (where.h >= (size.left + width_2) && where.v >= size.top  &&
+                where.h <= size.right && where.v <= size.bottom)
+            value = 1.0f;
+
+        if (listener)
+            listener->valueChanged (pContext, this);
+    }
+
+    value = 0.f;  // set button to UNSELECTED state
+    if (listener)
+        listener->valueChanged (pContext, this);
+
+    // end of edit parameter
+    endEdit ();
+}
+
+//------------------------------------------------------------------------
+bool CRockerSwitch::onWheel (CDrawContext *pContext, const CPoint &where, float distance)
+{
+    if (!bMouseEnabled)
+        return false;
+
+    if (distance > 0)
+        value = -1.0f;
+    else
+        value = 1.0f;
+
+    // begin of edit parameter
+    beginEdit ();
+
+    if (isDirty () && listener)
+        listener->valueChanged (pContext, this);
+
+    value = 0.0f;  // set button to UNSELECTED state
+    if (listener)
+        listener->valueChanged (pContext, this);
+
+    // end of edit parameter
+    endEdit ();
+
+    return true;
+}
+
+
+//------------------------------------------------------------------------
+// CMovieBitmap
+//------------------------------------------------------------------------
+/*! @class CMovieBitmap
+A movie pixmap allows to display different subpixmaps according to its current value.
+*/
+CMovieBitmap::CMovieBitmap (const CRect &size, CControlListener *listener, long tag,
+                            CBitmap *background, CPoint &offset)
+  :    CControl (size, listener, tag, background), offset (offset),
+        subPixmaps (subPixmaps), heightOfOneImage (heightOfOneImage)
+{
+    heightOfOneImage = size.height ();
+    subPixmaps = (long)(background->getHeight () / heightOfOneImage);
+}
+
+//------------------------------------------------------------------------
+CMovieBitmap::CMovieBitmap (const CRect &size, CControlListener *listener, long tag,
+                            long subPixmaps,        // number of subPixmaps
+                            CCoord heightOfOneImage,  // height of one image in pixel
+                            CBitmap *background, CPoint &offset)
+  :    CControl (size, listener, tag, background), offset (offset),
+        subPixmaps (subPixmaps), heightOfOneImage (heightOfOneImage)
+{}
+
+//------------------------------------------------------------------------
+CMovieBitmap::~CMovieBitmap ()
+{}
+
+//------------------------------------------------------------------------
+void CMovieBitmap::draw (CDrawContext *pContext)
+{
+ //   DBG ("CMovieBitmap::draw");
+
+    CPoint where (offset.h, offset.v);
+
+    if (value > 1.0f)
+        value = 1.0f;
+
+     if (value > 0.0f)
+        where.v += heightOfOneImage * (int)(value * (subPixmaps - 1) + 0.5);
+
+    if (pBackground)
+    {
+        if (bTransparencyEnabled)
+            pBackground->drawTransparent (pContext, size, where);
+        else
+            pBackground->draw (pContext, size, where);
+    }
+    setDirty (false);
+}
+
+
+//------------------------------------------------------------------------
+// CMovieButton
+//------------------------------------------------------------------------
+/*! @class CMovieButton
+A movie button is a bi-states button with 2 subpixmaps. These subpixmaps are stacked in the pixmap.
+*/
+CMovieButton::CMovieButton (const CRect &size, CControlListener *listener, long tag,              // identifier tag (ID)
+                            CBitmap *background, CPoint &offset)
+: CControl (size, listener, tag, background), offset (offset), buttonState (value)
+{
+    heightOfOneImage = size.height ();
+}
+
+//------------------------------------------------------------------------
+CMovieButton::CMovieButton (const CRect &size, CControlListener *listener, long tag,
+                            CCoord heightOfOneImage, // height of one image in pixel
+                            CBitmap *background, CPoint &offset)
+    :    CControl (size, listener, tag, background), offset (offset),
+        heightOfOneImage (heightOfOneImage), buttonState (value)
+{}
+
+//------------------------------------------------------------------------
+CMovieButton::~CMovieButton ()
+{}
+
+//------------------------------------------------------------------------
+void CMovieButton::draw (CDrawContext *pContext)
+{
+  //  DBG ("CMovieButton::draw");
+
+    CPoint where;
+
+    where.h = 0;
+
+    bounceValue ();
+
+    if (value)
+        where.v = heightOfOneImage;
+    else
+        where.v = 0;
+
+    if (pBackground)
+    {
+        if (bTransparencyEnabled)
+            pBackground->drawTransparent (pContext, size, where);
+        else
+            pBackground->draw (pContext, size, where);
+    }
+    buttonState = value;
+
+    setDirty (false);
+}
+
+//------------------------------------------------------------------------
+void CMovieButton::mouse (CDrawContext *pContext, CPoint &where, long button)
+{
+    if (!bMouseEnabled)
+        return;
+
+    if (button == -1) button = pContext->getMouseButtons ();
+
+    if (listener && button & (kAlt | kShift | kControl | kApple))
+    {
+        if (listener->controlModifierClicked (pContext, this, button) != 0)
+            return;
+    }
+
+    if (!(button & kLButton))
+        return;
+
+    // this simulates a real windows button
+    float fEntryState = value;
+
+    // begin of edit parameter
+    beginEdit ();
+
+    if (pContext->getMouseButtons ())
+    {
+        do
+        {
+            if (where.h >= size.left &&
+                    where.v >= size.top  &&
+                    where.h <= size.right &&
+                    where.v <= size.bottom)
+                value = !fEntryState;
+            else
+                value = fEntryState;
+
+            if (isDirty () && listener)
+                listener->valueChanged (pContext, this);
+
+            getMouseLocation (pContext, where);
+
+            doIdleStuff ();
+        }
+        while (pContext->getMouseButtons () == button);
+    }
+    else
+    {
+        value = !value;
+        if (listener)
+            listener->valueChanged (pContext, this);
+    }
+
+    // end of edit parameter
+    endEdit ();
+
+    buttonState = value;
+}
+
+
+//------------------------------------------------------------------------
+// CAutoAnimation
+//------------------------------------------------------------------------
+/*! @class CAutoAnimation
+An auto-animation control contains a given number of subpixmap which can be displayed in loop.
+Two functions allows to get the previous or the next subpixmap (these functions increase or decrease the current value of this control).
+*/
+// displays bitmaps within a (child-) window
+CAutoAnimation::CAutoAnimation (const CRect &size, CControlListener *listener, long tag,
+                                CBitmap *background, CPoint &offset)
+: CControl (size, listener, tag, background), offset (offset), bWindowOpened (false)
+{
+    heightOfOneImage = size.height ();
+    subPixmaps = (long)(background->getHeight () / heightOfOneImage);
+
+    totalHeightOfBitmap = heightOfOneImage * subPixmaps;
+}
+
+//------------------------------------------------------------------------
+CAutoAnimation::CAutoAnimation (const CRect &size, CControlListener *listener, long tag,
+                                long subPixmaps,     // number of subPixmaps...
+                                CCoord heightOfOneImage, // height of one image in pixel
+                                CBitmap *background, CPoint &offset)
+    :    CControl (size, listener, tag, background), offset (offset),
+        subPixmaps (subPixmaps), heightOfOneImage (heightOfOneImage),
+        bWindowOpened (false)
+{
+    totalHeightOfBitmap = heightOfOneImage * subPixmaps;
+}
+
+//------------------------------------------------------------------------
+CAutoAnimation::~CAutoAnimation ()
+{}
+
+//------------------------------------------------------------------------
+void CAutoAnimation::draw (CDrawContext *pContext)
+{
+ //   DBG ("CAutoAnimation::draw");
+
+    if (isWindowOpened ())
+    {
+        CPoint where;
+        where.v = (long)value + offset.v;
+        where.h = offset.h;
+
+        if (pBackground)
+        {
+            if (bTransparencyEnabled)
+                pBackground->drawTransparent (pContext, size, where);
+            else
+                pBackground->draw (pContext, size, where);
+        }
+    }
+    setDirty (false);
+}
+
+//------------------------------------------------------------------------
+void CAutoAnimation::mouse (CDrawContext *pContext, CPoint &where, long button)
+{
+    if (!bMouseEnabled)
+        return;
+
+    if (button == -1) button = pContext->getMouseButtons ();
+
+    if (listener && button & (kAlt | kShift | kControl | kApple))
+    {
+        if (listener->controlModifierClicked (pContext, this, button) != 0)
+            return;
+    }
+
+    if (!(button & kLButton))
+        return;
+
+    if (!isWindowOpened ())
+    {
+        value = 0;
+        openWindow ();
+        setDirty (); // force to redraw
+        if (listener)
+            listener->valueChanged (pContext, this);
+    }
+    else
+    {
+        // stop info animation
+        value = 0; // draw first pic of bitmap
+        setDirty ();
+        closeWindow ();
+    }
+}
+
+//------------------------------------------------------------------------
+void CAutoAnimation::openWindow ()
+{
+    bWindowOpened = true;
+}
+
+//------------------------------------------------------------------------
+void CAutoAnimation::closeWindow ()
+{
+    bWindowOpened = false;
+}
+
+//------------------------------------------------------------------------
+void CAutoAnimation::nextPixmap ()
+{
+    value += heightOfOneImage;
+    if (value >= (totalHeightOfBitmap - heightOfOneImage))
+        value = 0;
+}
+
+//------------------------------------------------------------------------
+void CAutoAnimation::previousPixmap ()
+{
+    value -= heightOfOneImage;
+    if (value < 0.f)
+        value = (float)(totalHeightOfBitmap - heightOfOneImage - 1);
+}
+
+
+//------------------------------------------------------------------------
+// CSlider
+//------------------------------------------------------------------------
+/*! @class CSlider
+Define a slider with a given background and handle.
+The range of variation of the handle should be defined.
+By default the handler is drawn with transparency (white color).
+By clicking Alt+Left Mouse the default value is used.
+*/
+CSlider::CSlider (const CRect &rect, CControlListener *listener, long tag,
+                  long      iMinPos, // min position in pixel
+                  long      iMaxPos, // max position in pixel
+                  CBitmap  *handle,  // bitmap of slider
+                  CBitmap  *background, // bitmap of background
+                  CPoint   &offset,  // offset in the background
+                  const long style)  // style (kBottom,kRight,kTop,kLeft,kHorizontal,kVertical)
+  :    CControl (rect, listener, tag, background),    offset (offset), pHandle (handle),
+    pOScreen (0), style (style), bFreeClick (true)
+{
+    setDrawTransparentHandle (true);
+
+    if (pHandle)
+    {
+        pHandle->remember ();
+        widthOfSlider  = pHandle->getWidth ();
+        heightOfSlider = pHandle->getHeight ();
+    }
+    else
+    {
+        widthOfSlider  = 1;
+        heightOfSlider = 1;
+    }
+
+    widthControl  = size.width ();
+    heightControl = size.height ();
+
+    if (style & kHorizontal)
+    {
+        minPos = iMinPos - size.left;
+        rangeHandle = iMaxPos - iMinPos;
+        CPoint p (0, 0);
+        setOffsetHandle (p);
+    }
+    else
+    {
+        minPos = iMinPos - size.top;
+        rangeHandle = iMaxPos - iMinPos;
+        CPoint p (0, 0);
+        setOffsetHandle (p);
+    }
+
+    zoomFactor = 10.f;
+
+    setWantsFocus (true);
+}
+
+//------------------------------------------------------------------------
+CSlider::CSlider (const CRect &rect, CControlListener *listener, long tag,
+                  CPoint   &offsetHandle,    // handle offset
+                  long     _rangeHandle, // size of handle range
+                  CBitmap  *handle,     // bitmap of slider
+                  CBitmap  *background, // bitmap of background
+                  CPoint   &offset,     // offset in the background
+                  const long style)     // style (kBottom,kRight,kTop,kLeft,kHorizontal,kVertical)
+:    CControl (rect, listener, tag, background), offset (offset), pHandle (handle),
+    pOScreen (0), style (style), minPos (0), bFreeClick (true)
+{
+    setDrawTransparentHandle (true);
+
+    if (pHandle)
+    {
+        pHandle->remember ();
+        widthOfSlider  = pHandle->getWidth ();
+        heightOfSlider = pHandle->getHeight ();
+    }
+    else
+    {
+        widthOfSlider  = 1;
+        heightOfSlider = 1;
+    }
+
+    widthControl  = size.width ();
+    heightControl = size.height ();
+    if (style & kHorizontal)
+        rangeHandle = _rangeHandle - widthOfSlider;
+    else
+        rangeHandle = _rangeHandle - heightOfSlider;
+
+    setOffsetHandle (offsetHandle);
+
+    zoomFactor = 10.f;
+
+    setWantsFocus (true);
+}
+
+//------------------------------------------------------------------------
+CSlider::~CSlider ()
+{
+    if (pHandle)
+        pHandle->forget ();
+}
+
+//------------------------------------------------------------------------
+void CSlider::setOffsetHandle (CPoint &val)
+{
+    offsetHandle = val;
+
+    if (style & kHorizontal)
+    {
+        minTmp = offsetHandle.h + minPos;
+        maxTmp = minTmp + rangeHandle + widthOfSlider;
+    }
+    else
+    {
+        minTmp = offsetHandle.v + minPos;
+        maxTmp = minTmp + rangeHandle + heightOfSlider;
+    }
+}
+
+//-----------------------------------------------------------------------------
+bool CSlider::attached (CView *parent)
+{
+    if (pOScreen)
+        delete pOScreen;
+
+    pOScreen = 0; // @TODO - faking offscreen
+//    pOScreen = new COffscreenContext (getFrame (), widthControl, heightControl, kBlackCColor);
+
+    return CControl::attached (parent);
+}
+
+//-----------------------------------------------------------------------------
+bool CSlider::removed (CView *parent)
+{
+    if (pOScreen)
+    {
+        delete pOScreen;
+        pOScreen = 0;
+    }
+    return CControl::removed (parent);
+}
+
+//------------------------------------------------------------------------
+void CSlider::draw (CDrawContext *pContext)
+{
+ //   DBG ("CSlider::draw");
+
+    CDrawContext* drawContext = pOScreen ? pOScreen : pContext;
+
+    if (pOScreen && bTransparencyEnabled)
+        pOScreen->copyTo (pContext, size);
+
+    float fValue;
+    if (style & kLeft || style & kTop)
+        fValue = value;
+    else
+        fValue = 1.f - value;
+
+    // (re)draw background
+    CRect rect (0, 0, widthControl, heightControl);
+    if (!pOScreen)
+        rect.offset (size.left, size.top);
+    if (pBackground)
+    {
+        if (bTransparencyEnabled)
+            pBackground->drawTransparent (drawContext, rect, offset);
+        else
+            pBackground->draw (drawContext, rect, offset);
+    }
+
+    // calc new coords of slider
+    CRect   rectNew;
+    if (style & kHorizontal)
+    {
+        rectNew.top    = offsetHandle.v;
+        rectNew.bottom = rectNew.top + heightOfSlider;
+
+        rectNew.left   = offsetHandle.h + (int)(fValue * rangeHandle);
+        rectNew.left   = (rectNew.left < minTmp) ? minTmp : rectNew.left;
+
+        rectNew.right  = rectNew.left + widthOfSlider;
+        rectNew.right  = (rectNew.right > maxTmp) ? maxTmp : rectNew.right;
+    }
+    else
+    {
+        rectNew.left   = offsetHandle.h;
+        rectNew.right  = rectNew.left + widthOfSlider;
+
+        rectNew.top    = offsetHandle.v + (int)(fValue * rangeHandle);
+        rectNew.top    = (rectNew.top < minTmp) ? minTmp : rectNew.top;
+
+        rectNew.bottom = rectNew.top + heightOfSlider;
+        rectNew.bottom = (rectNew.bottom > maxTmp) ? maxTmp : rectNew.bottom;
+    }
+    if (!pOScreen)
+        rectNew.offset (size.left, size.top);
+
+    // draw slider at new position
+    if (pHandle)
+    {
+        if (bDrawTransparentEnabled)
+            pHandle->drawTransparent (drawContext, rectNew);
+        else
+            pHandle->draw (drawContext, rectNew);
+    }
+
+    if (pOScreen)
+        pOScreen->copyFrom (pContext, size);
+
+    setDirty (false);
+}
+
+//------------------------------------------------------------------------
+void CSlider::mouse (CDrawContext *pContext, CPoint &where, long button)
+{
+    if (!bMouseEnabled)
+        return;
+
+    if (button == -1) button = pContext->getMouseButtons ();
+
+    if (listener && button & (kAlt | kShift | kControl | kApple))
+    {
+        if (listener->controlModifierClicked (pContext, this, button) != 0)
+            return;
+    }
+
+    // check if default value wanted
+    if (checkDefaultValue (pContext, button))
+        return;
+
+    // allow left mousebutton only
+    if (!(button & kLButton))
+        return;
+
+    CCoord delta;
+    if (style & kHorizontal)
+        delta = size.left + offsetHandle.h;
+    else
+        delta = size.top + offsetHandle.v;
+    if (!bFreeClick)
+    {
+        float fValue;
+        if (style & kLeft || style & kTop)
+            fValue = value;
+        else
+            fValue = 1.f - value;
+        CCoord actualPos;
+        CRect rect;
+
+        if (style & kHorizontal)
+        {
+            actualPos = offsetHandle.h + (int)(fValue * rangeHandle) + size.left;
+
+            rect.left   = actualPos;
+            rect.top    = size.top  + offsetHandle.v;
+            rect.right  = rect.left + widthOfSlider;
+            rect.bottom = rect.top  + heightOfSlider;
+
+            if (!where.isInside (rect))
+                return;
+            else
+                delta += where.h - actualPos;
+        }
+        else
+        {
+            actualPos = offsetHandle.v + (int)(fValue * rangeHandle) + size.top;
+
+            rect.left   = size.left  + offsetHandle.h;
+            rect.top    = actualPos;
+            rect.right  = rect.left + widthOfSlider;
+            rect.bottom = rect.top  + heightOfSlider;
+
+            if (!where.isInside (rect))
+                return;
+            else
+                delta += where.v - actualPos;
+        }
+    }
+    else
+    {
+        if (style & kHorizontal)
+            delta += widthOfSlider / 2 - 1;
+        else
+            delta += heightOfSlider / 2 - 1;
+    }
+
+    float oldVal    = value;
+    long  oldButton = button;
+
+    // begin of edit parameter
+    beginEdit ();
+
+    while (1)
+    {
+        button = pContext->getMouseButtons ();
+        if (!(button & kLButton))
+            break;
+
+        if ((oldButton != button) && (button & kShift))
+        {
+            oldVal    = value;
+            oldButton = button;
+        }
+        else if (!(button & kShift))
+            oldVal = value;
+
+        if (style & kHorizontal)
+            value = (float)(where.h - delta) / (float)rangeHandle;
+        else
+            value = (float)(where.v - delta) / (float)rangeHandle;
+
+        if (style & kRight || style & kBottom)
+            value = 1.f - value;
+
+        if (button & kShift)
+            value = oldVal + ((value - oldVal) / zoomFactor);
+        bounceValue ();
+
+        if (isDirty () && listener)
+            listener->valueChanged (pContext, this);
+
+        getMouseLocation (pContext, where);
+
+        doIdleStuff ();
+    }
+
+    // end of edit parameter
+    endEdit ();
+}
+
+//------------------------------------------------------------------------
+bool CSlider::onWheel (CDrawContext *pContext, const CPoint &where, float distance)
+{
+    if (!bMouseEnabled)
+        return false;
+
+    long buttons = pContext->getMouseButtons ();
+    if (buttons & kShift)
+        value += 0.1f * distance * wheelInc;
+    else
+        value += distance * wheelInc;
+    bounceValue ();
+
+    if (isDirty () && listener)
+    {
+        // begin of edit parameter
+        beginEdit ();
+
+        listener->valueChanged (pContext, this);
+
+        // end of edit parameter
+        endEdit ();
+    }
+
+    return true;
+}
+
+//------------------------------------------------------------------------
+long CSlider::onKeyDown (VstKeyCode& keyCode)
+{
+    switch (keyCode.virt)
+    {
+    case VKEY_UP :
+    case VKEY_RIGHT :
+    case VKEY_DOWN :
+    case VKEY_LEFT :
+        {
+            float distance = 1.f;
+            if (keyCode.virt == VKEY_DOWN || keyCode.virt == VKEY_LEFT)
+                distance = -distance;
+
+            if (keyCode.modifier & MODIFIER_SHIFT)
+                value += 0.1f * distance * wheelInc;
+            else
+                value += distance * wheelInc;
+            bounceValue ();
+
+            if (isDirty () && listener)
+            {
+                // begin of edit parameter
+                beginEdit ();
+
+                listener->valueChanged (0, this);
+
+                // end of edit parameter
+                endEdit ();
+            }
+        } return 1;
+    }
+    return -1;
+}
+
+//------------------------------------------------------------------------
+void CSlider::setHandle (CBitmap *_pHandle)
+{
+    if (pHandle)
+        pHandle->forget ();
+    pHandle = _pHandle;
+    if (pHandle)
+    {
+        pHandle->remember ();
+        widthOfSlider  = pHandle->getWidth ();
+        heightOfSlider = pHandle->getHeight ();
+    }
+}
+
+
+//------------------------------------------------------------------------
+// CVerticalSlider
+//------------------------------------------------------------------------
+/*! @class CVerticalSlider
+This is the vertical slider. See CSlider.
+*/
+CVerticalSlider::CVerticalSlider (const CRect &rect, CControlListener *listener, long tag,
+                                  long      iMinPos, // min position in pixel
+                                  long      iMaxPos, // max position in pixel
+                                  CBitmap  *handle,  // bitmap of slider
+                                  CBitmap  *background, // bitmap of background
+                                  CPoint   &offset,  // offset in the background
+                                  const long style)  // style (kLeft, kRight)
+  :    CSlider (rect, listener, tag, iMinPos, iMaxPos, handle, background, offset, style|kVertical)
+{}
+
+//------------------------------------------------------------------------
+CVerticalSlider::CVerticalSlider (const CRect &rect, CControlListener *listener, long tag,
+                          CPoint   &offsetHandle,    // handle offset
+                          long     rangeHandle, // size of handle range
+                          CBitmap  *handle,     // bitmap of slider
+                          CBitmap  *background, // bitmap of background
+                          CPoint   &offset,     // offset in the background
+                          const long style)     // style (kLeft, kRight)
+:    CSlider (rect, listener, tag, offsetHandle, rangeHandle, handle, background, offset, style|kVertical)
+{}
+
+
+//------------------------------------------------------------------------
+// CHorizontalSlider
+//------------------------------------------------------------------------
+/*! @class CHorizontalSlider
+This is the horizontal slider. See CSlider.
+*/
+CHorizontalSlider::CHorizontalSlider (const CRect &rect, CControlListener *listener, long tag,
+                                  long      iMinPos, // min Y position in pixel
+                                  long      iMaxPos, // max Y position in pixel
+                                  CBitmap  *handle,  // bitmap of slider
+                                  CBitmap  *background, // bitmap of background
+                                  CPoint   &offset,  // offset in the background
+                                  const long style)  // style (kLeft, kRight)
+  :    CSlider (rect, listener, tag, iMinPos, iMaxPos, handle, background, offset, style|kHorizontal)
+{}
+
+//------------------------------------------------------------------------
+CHorizontalSlider::CHorizontalSlider (const CRect &rect, CControlListener *listener, long tag,
+                          CPoint   &offsetHandle,    // handle offset
+                          long     rangeHandle, // size of handle range
+                          CBitmap  *handle,     // bitmap of slider
+                          CBitmap  *background, // bitmap of background
+                          CPoint   &offset,     // offset in the background
+                          const long style)     // style (kLeft, kRight)
+:    CSlider (rect, listener, tag, offsetHandle, rangeHandle, handle, background, offset, style|kHorizontal)
+{}
+
+
+//------------------------------------------------------------------------
+// CSpecialDigit
+//------------------------------------------------------------------------
+/*! @class CSpecialDigit
+Can be used to display a counter with maximum 7 digits.
+All digit have the same size and are stacked in height in the pixmap.
+*/
+CSpecialDigit::CSpecialDigit (const CRect &size,
+                              CControlListener *listener,
+                              long      tag,        // tag identifier
+                              long     dwPos,      // actual value
+                              long      iNumbers,   // amount of numbers (max 7)
+                              long      *xpos,      // array of all XPOS
+                              long      *ypos,      // array of all YPOS
+                              long      width,      // width of ONE number
+                              long      height,     // height of ONE number
+                              CBitmap  *background)    // bitmap numbers
+  :    CControl (size, listener, tag, background),
+        iNumbers (iNumbers), width (width), height (height)
+{
+    setValue ((float)dwPos);          // actual value
+
+    if (iNumbers > 7)
+        iNumbers = 7;
+
+    if (xpos == NULL)
+    {
+        // automatically init xpos/ypos if not provided by caller
+        const int numw = (const int)background->getWidth();
+        int x = (int)size.left;
+        for (long i = 0; i < iNumbers; i++)
+        {
+            this->xpos[i] = x;
+            this->ypos[i] = (long)size.top;
+            x += numw;
+        }
+    }
+    else
+    {
+        // store coordinates of x/y pos of each digit
+        for (long i = 0; i < iNumbers; i++)
+        {
+            this->xpos[i] = xpos[i];
+            this->ypos[i] = ypos[i];
+        }
+    }
+
+    setMax ((float)pow (10., (double)iNumbers) - 1.0f);
+    setMin (0.0f);
+}
+
+//------------------------------------------------------------------------
+CSpecialDigit::~CSpecialDigit ()
+{}
+
+//------------------------------------------------------------------------
+void CSpecialDigit::draw (CDrawContext *pContext)
+{
+//    DBG ("CSpecialDigit::draw");
+
+    CPoint  where;
+    CRect   rectDest;
+    long    i, j;
+    long    dwValue;
+    long     one_digit[16];
+
+    if ((long)value >= getMax ())
+        dwValue = (long)getMax ();
+    else if ((long)value < getMin ())
+        dwValue = (long)getMin ();
+    else
+        dwValue = (long)value;
+
+    for (i = 0, j = ((long)getMax () + 1) / 10; i < iNumbers; i++, j /= 10)
+    {
+        one_digit[i] = dwValue / j;
+        dwValue -= (one_digit[i] * j);
+    }
+
+    where.h = 0;
+    for (i = 0; i < iNumbers; i++)
+    {
+        j = one_digit[i];
+        if (j > 9)
+            j = 9;
+
+        rectDest.left   = xpos[i];
+        rectDest.top    = ypos[i];
+
+        rectDest.right  = rectDest.left + width;
+        rectDest.bottom = rectDest.top  + height;
+
+        // where = src from bitmap
+        where.v = j * height;
+        if (pBackground)
+        {
+            if (bTransparencyEnabled)
+                pBackground->drawTransparent (pContext, rectDest, where);
+            else
+                pBackground->draw (pContext, rectDest, where);
+        }
+    }
+
+    setDirty (false);
+}
+
+//------------------------------------------------------------------------
+float CSpecialDigit::getNormValue () const
+{
+    float fTemp;
+    fTemp = value / getMax ();
+    if (fTemp > 1.0f)
+        fTemp = 1.0f;
+    else if (fTemp < 0.0f)
+        fTemp = 0.0f;
+
+    return fTemp;
+}
+
+
+//------------------------------------------------------------------------
+// CKickButton
+//------------------------------------------------------------------------
+/*! @class CKickButton
+Define a button with 2 states using 2 subpixmaps.
+One click on it, then the second subpixmap is displayed.
+When the mouse button is relaxed, the first subpixmap is framed.
+*/
+CKickButton::CKickButton (const CRect &size, CControlListener *listener, long tag,
+                          CBitmap *background, CPoint &offset)
+:    CControl (size, listener, tag, background), offset (offset)
+{
+    heightOfOneImage = size.height ();
+}
+
+//------------------------------------------------------------------------
+CKickButton::CKickButton (const CRect &size, CControlListener *listener, long tag,
+                          CCoord heightOfOneImage, // height of one image in pixel
+                          CBitmap *background, CPoint &offset)
+:    CControl (size, listener, tag, background), offset (offset),
+    heightOfOneImage (heightOfOneImage)
+{}
+
+//------------------------------------------------------------------------
+CKickButton::~CKickButton ()
+{}
+
+//------------------------------------------------------------------------
+void CKickButton::draw (CDrawContext *pContext)
+{
+ //   DBG ("CKickButton::draw");
+
+    CPoint where (offset.h, offset.v);
+
+    bounceValue ();
+
+    if (value)
+        where.v += heightOfOneImage;
+
+    if (pBackground)
+    {
+        if (bTransparencyEnabled)
+            pBackground->drawTransparent (pContext, size, where);
+        else
+            pBackground->draw (pContext, size, where);
+    }
+    setDirty (false);
+}
+
+//------------------------------------------------------------------------
+void CKickButton::mouse (CDrawContext *pContext, CPoint &where, long button)
+{
+    if (!bMouseEnabled)
+        return;
+
+    if (button == -1) button = pContext->getMouseButtons ();
+
+    if (listener && button & (kAlt | kShift | kControl | kApple))
+    {
+        if (listener->controlModifierClicked (pContext, this, button) != 0)
+            return;
+    }
+
+    if (!(button & kLButton))
+        return;
+
+    // this simulates a real windows button
+    float fEntryState = value;
+
+    // begin of edit parameter
+    beginEdit ();
+
+    if (pContext->getMouseButtons () == kLButton)
+    {
+        do
+        {
+            if (where.h >= size.left && where.v >= size.top  &&
+                where.h <= size.right && where.v <= size.bottom)
+                value = !fEntryState;
+            else
+                value = fEntryState;
+
+            if (isDirty () && listener)
+                listener->valueChanged (pContext, this);
+
+            getMouseLocation (pContext, where);
+
+            doIdleStuff ();
+        }
+        while (pContext->getMouseButtons () == kLButton);
+    }
+    else
+    {
+        value = !value;
+        if (listener)
+            listener->valueChanged (pContext, this);
+    }
+
+    value = 0.0f;  // set button to UNSELECTED state
+    if (listener)
+        listener->valueChanged (pContext, this);
+
+    // end of edit parameter
+    endEdit ();
+}
+
+
+//------------------------------------------------------------------------
+// CSplashScreen
+//------------------------------------------------------------------------
+/*! @class CSplashScreen
+One click on its activated region and its pixmap is displayed, in this state the other control can not be used,
+an another click on the displayed area reinstalls the normal frame.
+This can be used to display a help view over the other views.
+*/
+// one click draw its pixmap, an another click redraw its parent
+CSplashScreen::CSplashScreen (const CRect &size, CControlListener *listener, long tag,
+                              CBitmap *background,
+                              CRect   &toDisplay,
+                              CPoint  &offset)
+:    CControl (size, listener, tag, background),
+    toDisplay (toDisplay), offset (offset), bitmapTransparency (255)
+{}
+
+//------------------------------------------------------------------------
+CSplashScreen::~CSplashScreen ()
+{}
+
+//------------------------------------------------------------------------
+void CSplashScreen::setBitmapTransparency (unsigned char transparency)
+{
+    bitmapTransparency = transparency;
+    setTransparency (bitmapTransparency != 255);
+}
+
+//------------------------------------------------------------------------
+void CSplashScreen::draw (CDrawContext *pContext)
+{
+ //   DBG ("CSplashScreen::draw");
+
+    if (value && pBackground)
+    {
+        if (bTransparencyEnabled)
+        {
+            if (bitmapTransparency)
+                pBackground->drawAlphaBlend (pContext, toDisplay, offset, bitmapTransparency);
+            else
+            pBackground->drawTransparent (pContext, toDisplay, offset);
+        }
+        else
+            pBackground->draw (pContext, toDisplay, offset);
+    }
+    setDirty (false);
+}
+
+//------------------------------------------------------------------------
+bool CSplashScreen::hitTest (const CPoint& where, const long buttons)
+{
+    bool result = CView::hitTest (where, buttons);
+    if (result && !(buttons & kLButton))
+        return false;
+    return result;
+}
+
+//------------------------------------------------------------------------
+void CSplashScreen::mouse (CDrawContext *pContext, CPoint &where, long button)
+{
+    if (!bMouseEnabled)
+        return;
+
+    if (button == -1) button = pContext->getMouseButtons ();
+
+    if (listener && button & (kAlt | kShift | kControl | kApple))
+    {
+        if (listener->controlModifierClicked (pContext, this, button) != 0)
+            return;
+    }
+
+    if (!(button & kLButton))
+        return;
+
+    value = !value;
+    if (value)
+    {
+        if (getFrame () && getFrame ()->setModalView (this))
+        {
+            keepSize = size;
+            size = toDisplay;
+            mouseableArea = size;
+//            draw (pContext);
+            if (listener)
+                listener->valueChanged (pContext, this);
+        }
+        setDirty ();
+    }
+    else
+    {
+        size = keepSize;
+        mouseableArea = size;
+        if (listener)
+            listener->valueChanged (pContext, this);
+        if (getFrame ())
+        {
+            getFrame ()->setDirty (true);
+            getFrame ()->setModalView (NULL);
+        }
+    }
+}
+
+//------------------------------------------------------------------------
+void CSplashScreen::unSplash ()
+{
+    setDirty ();
+    value = 0.f;
+
+    size = keepSize;
+    if (getFrame ())
+    {
+        if (getFrame ()->getModalView () == this)
+        {
+            getFrame ()->setModalView (NULL);
+            getFrame ()->redraw ();
+        }
+    }
+}
+
+//------------------------------------------------------------------------
+// CVuMeter
+//------------------------------------------------------------------------
+CVuMeter::CVuMeter (const CRect &size, CBitmap *onBitmap, CBitmap *offBitmap,
+                    long nbLed, const long style)
+    : CControl (size, 0, 0),
+      onBitmap (onBitmap), offBitmap (offBitmap), pOScreen (0),
+      nbLed (nbLed), style (style)
+{
+    bUseOffscreen = false;
+
+    setDecreaseStepValue (0.1f);
+
+    if (onBitmap)
+        onBitmap->remember ();
+    if (offBitmap)
+        offBitmap->remember ();
+
+    rectOn  (size.left, size.top, size.right, size.bottom);
+    rectOff (size.left, size.top, size.right, size.bottom);
+}
+
+//------------------------------------------------------------------------
+CVuMeter::~CVuMeter ()
+{
+    if (onBitmap)
+        onBitmap->forget ();
+    if (offBitmap)
+        offBitmap->forget ();
+}
+
+//------------------------------------------------------------------------
+void CVuMeter::setDirty (const bool val)
+{
+    CView::setDirty (val);
+}
+
+//-----------------------------------------------------------------------------
+bool CVuMeter::attached (CView *parent)
+{
+    if (pOScreen)
+        delete pOScreen;
+/*
+    if (bUseOffscreen)
+    {
+        pOScreen = new COffscreenContext (getFrame (), (long)size.width (), (long)size.height (), kBlackCColor);
+        rectOn  (0, 0, size.width (), size.height ());
+        rectOff (0, 0, size.width (), size.height ());
+    }
+    else
+*/
+    {
+        rectOn  (size.left, size.top, size.right, size.bottom);
+        rectOff (size.left, size.top, size.right, size.bottom);
+    }
+
+    return CControl::attached (parent);
+}
+
+//------------------------------------------------------------------------
+void CVuMeter::setUseOffscreen (bool val)
+{
+//    bUseOffscreen = val; // @TODO - faking offscreen
+    bUseOffscreen = false;
+}
+
+//-----------------------------------------------------------------------------
+bool CVuMeter::removed (CView *parent)
+{
+    if (pOScreen)
+    {
+        delete pOScreen;
+        pOScreen = 0;
+    }
+    return CControl::removed (parent);
+}
+
+//------------------------------------------------------------------------
+void CVuMeter::draw (CDrawContext *_pContext)
+{
+ //   DBG ("CVuMeter::draw");
+
+    if (!onBitmap)
+        return;
+
+    CPoint pointOn;
+    CPoint pointOff;
+    CDrawContext *pContext = _pContext;
+
+    bounceValue ();
+
+    float newValue = oldValue - decreaseValue;
+    if (newValue < value)
+        newValue = value;
+    oldValue = newValue;
+
+/*
+    if (bUseOffscreen)
+    {
+        if (!pOScreen)
+        {
+            pOScreen = new COffscreenContext (getFrame (), (long)size.width (), (long)size.height (), kBlackCColor);
+            rectOn  (0, 0, size.width (), size.height ());
+            rectOff (0, 0, size.width (), size.height ());
+        }
+        pContext = pOScreen;
+    }
+*/
+
+    if (style & kHorizontal)
+    {
+        CCoord tmp = (long)(((long)(nbLed * newValue + 0.5f) / (float)nbLed) * onBitmap->getWidth ());
+        pointOff (tmp, 0);
+        if (!bUseOffscreen)
+        tmp += size.left;
+
+        rectOff.left = tmp;
+        rectOn.right = tmp;
+    }
+    else
+    {
+        CCoord tmp = (long)(((long)(nbLed * (getMax () - newValue) + 0.5f) / (float)nbLed) * onBitmap->getHeight ());
+        pointOn (0, tmp);
+        if (!bUseOffscreen)
+        tmp += size.top;
+
+        rectOff.bottom = tmp;
+        rectOn.top     = tmp;
+    }
+
+    if (offBitmap)
+    {
+        if (bTransparencyEnabled)
+            offBitmap->drawTransparent (pContext, rectOff, pointOff);
+        else
+            offBitmap->draw (pContext, rectOff, pointOff);
+    }
+
+    if (bTransparencyEnabled)
+        onBitmap->drawTransparent (pContext, rectOn, pointOn);
+    else
+        onBitmap->draw (pContext, rectOn, pointOn);
+
+    if (pOScreen)
+        pOScreen->copyFrom (_pContext, size);
+
+    setDirty (false);
+}
+
+} // namespace VSTGUI
+
+//------------------------------------------------------------------------
+// END.
+//------------------------------------------------------------------------
diff --git a/vstgui/vstcontrols.h b/vstgui/vstcontrols.h
new file mode 100644
index 0000000..0505f82
--- /dev/null
+++ b/vstgui/vstcontrols.h
@@ -0,0 +1,994 @@
+/* ----------------------------------------------------------------------------
+ * VSTGUI for X11/LV2/PNG
+ * Author: Dave Robillard
+ * Released under the revised BSD license, as below
+ * ----------------------------------------------------------------------------
+ *
+ * Based on:
+ * ----------------------------------------------------------------------------
+ * VSTGUIL: Graphical User Interface Framework for VST plugins on LINUX
+ * Version: 0.1, Date: 2007/01/21
+ * Author: kRAkEn/gORe
+ *
+ * Which was based on:
+ * ----------------------------------------------------------------------------
+ * VSTGUI: Graphical User Interface Framework for VST plugins
+ * Version 3.0       $Date: 2005/08/12 12:45:00 $
+ * ----------------------------------------------------------------------------
+ * VSTGUI LICENSE
+ * 2004, Steinberg Media Technologies, All Rights Reserved
+ * ----------------------------------------------------------------------------
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of the Steinberg Media Technologies nor the names of
+ *     its contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A  PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+ * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ * ----------------------------------------------------------------------------
+ */
+
+#ifndef __vstcontrols__
+#define __vstcontrols__
+
+#ifndef __vstgui__
+#include "vstgui.h"
+#endif
+
+//------------------
+// defines
+//------------------
+#ifndef kPI
+#define kPI    3.14159265358979323846
+#endif
+
+#ifndef k2PI
+#define k2PI   6.28318530717958647692
+#endif
+
+#ifndef kPI_2
+#define kPI_2  1.57079632679489661923f
+#endif
+
+#ifndef kPI_4
+#define kPI_4  0.78539816339744830962
+#endif
+
+#ifndef kE
+#define kE     2.7182818284590452354
+#endif
+
+#ifndef kLN2
+#define kLN2   0.69314718055994530942
+#endif
+
+#ifndef kSQRT2
+#define kSQRT2 1.41421356237309504880
+#endif
+
+//------------------
+// CControlEnum type
+//------------------
+enum CControlEnum
+{
+	kHorizontal			= 1 << 0,
+	kVertical			= 1 << 1,
+	kShadowText			= 1 << 2,
+	kLeft				= 1 << 3,
+	kRight				= 1 << 4,
+	kTop				= 1 << 5,
+	kBottom				= 1 << 6,
+	k3DIn				= 1 << 7,
+	k3DOut				= 1 << 8,
+	kPopupStyle			= 1 << 9,
+	kCheckStyle			= 1 << 10,
+	kMultipleCheckStyle,
+	kNoTextStyle		= 1 << 11,
+	kNoDrawStyle		= 1 << 12,
+	kDoubleClickStyle	= 1 << 13,
+	kNoFrame			= 1 << 14
+};
+
+//---------------------------
+// Some defines for Menu item
+//---------------------------
+#define kMenuTitle     "-T"
+#define kMenuSeparator "-"
+#define kMenuDisable   "-G"
+#define kMenuSubMenu   "-M"
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+class CControlListener
+{
+public:
+    virtual ~CControlListener () {}
+
+	virtual void valueChanged (VSTGUI::CDrawContext *pContext, VSTGUI::CControl *pControl) = 0;
+	virtual long controlModifierClicked (VSTGUI::CDrawContext *pContext, VSTGUI::CControl *pControl, long button) { return 0; }	// return 1 if you want the control to not handle it, otherwise 0
+};
+
+class AudioEffectX;
+
+//-----------------------------------------------------------------------------
+namespace VSTGUI {
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+// CControl Declaration
+//! base class of all VSTGUI controls
+//-----------------------------------------------------------------------------
+class CControl : public CView
+{
+public:
+	CControl (const CRect &size, CControlListener *listener = 0, long tag = 0,
+						CBitmap *pBackground = 0);
+	virtual ~CControl ();
+
+	virtual void  draw (CDrawContext *pContext) = 0;
+	virtual void  doIdleStuff () { if (pParentFrame) pParentFrame->doIdleStuff (); }
+
+	virtual void  setValue (float val) { value = val; }
+	virtual float getValue () const { return value; };
+
+	virtual void  setMin (float val) { vmin = val; }
+	virtual float getMin () const { return vmin; }
+	virtual void  setMax (float val) { vmax = val; }
+	virtual float getMax () const { return vmax; }
+
+	virtual void  setOldValue (float val) { oldValue = val; }
+	virtual	float getOldValue (void) const { return oldValue; }
+	virtual void  setDefaultValue (float val) { defaultValue = val; }
+	virtual	float getDefaultValue (void) const { return defaultValue; }
+
+	virtual void  setTag (long val) { tag = val; }
+	virtual long  getTag () const { return tag; }
+
+	virtual bool  isDirty () const;
+	virtual void  setDirty (const bool val = true);
+
+	virtual void beginEdit ();
+	virtual void endEdit ();
+
+	virtual void setBackOffset (CPoint &offset);
+	virtual void copyBackOffset ();
+
+	virtual void  setWheelInc (float val) { wheelInc = val; }
+	virtual float getWheelInc () const { return wheelInc; }
+
+	virtual void bounceValue ();
+	virtual bool checkDefaultValue (CDrawContext *pContext, long button);
+
+	CControlListener* getListener () const { return listener; }
+	void setListener (CControlListener* l) { listener = l; }
+	bool isDoubleClick ();
+
+	CLASS_METHODS(CControl, CView)
+
+protected:
+	CControlListener *listener;
+	long  tag;
+	float oldValue;
+	float defaultValue;
+	float value;
+	float vmin;
+	float vmax;
+	float wheelInc;
+
+	long lastTicks;
+	long delta;
+
+	CPoint	backOffset;
+};
+
+
+//-----------------------------------------------------------------------------
+// COnOffButton Declaration
+//! a button control with 2 states
+//-----------------------------------------------------------------------------
+class COnOffButton : public CControl
+{
+public:
+	COnOffButton (const CRect &size, CControlListener *listener, long tag,
+                  CBitmap *background, long style = kPreListenerUpdate);
+	virtual ~COnOffButton ();
+
+	virtual void draw (CDrawContext*);
+	virtual void mouse (CDrawContext *pContext, CPoint &where, long button = -1);
+
+	virtual long getStyle () const { return style; }
+	virtual void setStyle (long newStyle) { style = newStyle; }
+
+	enum {
+		kPreListenerUpdate,			///< listener will be called after doIdleStuff was called
+		kPostListenerUpdate			///< listener will be called before doIdleStuff is called
+	};
+
+	CLASS_METHODS(COnOffButton, CControl)
+protected:
+	long style;
+};
+
+
+//-----------------------------------------------------------------------------
+// CParamDisplay Declaration
+//! a parameter display control
+//-----------------------------------------------------------------------------
+class CParamDisplay : public CControl
+{
+public:
+	CParamDisplay (const CRect &size, CBitmap *background = 0, const long style = 0);
+	virtual ~CParamDisplay ();
+
+	virtual void setFont (CFont fontID);
+	CFont getFont () const { return fontID; }
+
+	virtual void setFontColor (CColor color);
+	CColor getFontColor () const { return fontColor; }
+
+	virtual void setBackColor (CColor color);
+	CColor getBackColor () const { return backColor; }
+
+	virtual void setFrameColor (CColor color);
+	CColor getFrameColor () const { return frameColor; }
+
+	virtual void setShadowColor (CColor color);
+	CColor getShadowColor () const { return shadowColor; }
+
+	virtual void setHoriAlign (CHoriTxtAlign hAlign);
+
+	virtual void setStringConvert (void (*convert) (float value, char *string));
+	virtual void setStringConvert (void (*convert) (float value, char *string, void *userDta),
+									void *userData);
+	virtual void setString2FloatConvert (void (*convert) (char *string, float &output));
+
+	virtual void setStyle (long val);
+	long getStyle () const { return style; }
+
+	virtual void setTxtFace (CTxtFace val);
+	CTxtFace getTxtFace () const { return txtFace; }
+
+	virtual void draw (CDrawContext *pContext);
+
+	virtual void setTextTransparency (bool val) { bTextTransparencyEnabled = val; }
+	bool getTextTransparency () const { return bTextTransparencyEnabled; }
+
+	CLASS_METHODS(CParamDisplay, CControl)
+
+protected:
+	void drawText (CDrawContext *pContext, char *string, CBitmap *newBack = 0);
+
+	void (*stringConvert) (float value, char *string);
+	void (*stringConvert2) (float value, char *string, void *userData);
+	void (*string2FloatConvert) (char *string, float &output);
+	void  *userData;
+
+	CHoriTxtAlign horiTxtAlign;
+	long    style;
+
+	CFont   fontID;
+	CTxtFace txtFace;
+	CColor  fontColor;
+	CColor  backColor;
+	CColor  frameColor;
+	CColor  shadowColor;
+	bool    bTextTransparencyEnabled;
+};
+
+
+//-----------------------------------------------------------------------------
+// CLabel Declaration
+//! a text label
+//-----------------------------------------------------------------------------
+class CTextLabel : public CParamDisplay
+{
+public:
+	CTextLabel (const CRect& size, const char* txt = 0, CBitmap* background = 0, const long style = 0);
+	~CTextLabel ();
+
+	virtual void setText (const char* txt);
+	virtual const char* getText () const;
+
+	virtual	void draw (CDrawContext *pContext);
+
+	CLASS_METHODS(CTextLabel, CParamDisplay)
+
+protected:
+	void freeText ();
+	char* text;
+};
+
+//-----------------------------------------------------------------------------
+// CTextEdit Declaration
+//! a text edit control
+//-----------------------------------------------------------------------------
+class CTextEdit : public CParamDisplay
+{
+public:
+	CTextEdit (const CRect &size, CControlListener *listener, long tag, const char *txt = 0,
+               CBitmap *background = 0, const long style = 0);
+	virtual ~CTextEdit ();
+
+	virtual void setText (char *txt);
+	virtual void getText (char *txt) const;
+
+	virtual	void draw (CDrawContext *pContext);
+	virtual	void mouse (CDrawContext *pContext, CPoint &where, long button = -1);
+
+	virtual void setTextEditConvert (void (*editConvert) (char *input, char *string));
+	virtual void setTextEditConvert (void (*editConvert2) (char *input, char *string,
+										void *userDta), void *userData);
+
+	virtual	void takeFocus (CDrawContext *pContext = 0);
+	virtual	void looseFocus (CDrawContext *pContext = 0);
+
+	void *platformFontColor;
+	void *platformControl;
+	bool bWasReturnPressed;
+
+	CLASS_METHODS(CTextEdit, CParamDisplay)
+
+protected:
+	void *platformFont;
+	char text[256];
+
+	void (*editConvert) (char *input, char *string);
+	void (*editConvert2) (char *input, char *string, void *userData);
+};
+
+
+//-----------------------------------------------------------------------------
+// COptionMenuScheme Declaration
+//-----------------------------------------------------------------------------
+class COptionMenuScheme : public CReferenceCounter
+{
+public:
+	COptionMenuScheme ();
+	virtual ~COptionMenuScheme ();
+
+	enum { kChecked = 0x01, kDisabled = 0x02, kSelected = 0x04, kSubMenu = 0x08, kTitle = 0x10 };
+
+	virtual void getItemSize (const char* text, CDrawContext* pContext, CPoint& size);
+	virtual void drawItem (const char* text, long itemId, long state, CDrawContext* pContext, const CRect& rect);
+
+	void setColors (CColor back, CColor select, CColor text, CColor htext, CColor dtext)
+	{ backgroundColor = back; selectionColor = select; textColor = text;
+	hiliteTextColor = htext; disableTextColor = dtext;}
+
+	void setFont (CFont f) { font = f; }
+protected:
+
+	CColor backgroundColor;
+	CColor selectionColor;
+	CColor textColor;
+	CColor hiliteTextColor;
+	CColor disableTextColor;
+	CFont font;
+
+	virtual void drawItemBack (CDrawContext* pContext, const CRect& rect, bool hilite);
+};
+
+//-----------------------------------------------------------------------------
+extern COptionMenuScheme* gOptionMenuScheme;
+
+//-----------------------------------------------------------------------------
+// COptionMenu Declaration
+//! a popup menu control
+//-----------------------------------------------------------------------------
+class COptionMenu : public CParamDisplay
+{
+public:
+	COptionMenu (const CRect &size, CControlListener *listener, long tag,
+                 CBitmap *background = 0, CBitmap *bgWhenClick = 0,
+                 const long style = 0);
+	virtual ~COptionMenu ();
+
+	enum { MAX_ENTRY = 1024 };
+
+	virtual void setValue (float val);
+	virtual bool addEntry (COptionMenu *subMenu, char *txt);
+	virtual	bool addEntry (char *txt, long index = -1);
+	virtual	long getCurrent (char *txt = 0, bool countSeparator = true) const;
+	virtual	bool setCurrent (long index, bool countSeparator = true);
+	virtual	bool getEntry (long index, char *txt) const;
+	virtual	bool setEntry (long index, char *txt);
+	virtual	bool removeEntry (long index);
+	virtual	bool removeAllEntry ();
+	virtual long getNbEntries () const { return nbEntries; }
+	virtual long getIndex (char *txt) const;
+
+	virtual bool checkEntry (long index, bool state);
+	virtual bool checkEntryAlone (long index);
+	virtual bool isCheckEntry (long index) const;
+
+	virtual	void draw (CDrawContext *pContext);
+	virtual	void mouse (CDrawContext *pContext, CPoint &where, long button = -1);
+
+	virtual	void takeFocus (CDrawContext *pContext = 0);
+	virtual	void looseFocus (CDrawContext *pContext = 0);
+
+	virtual void setNbItemsPerColumn (long val) { nbItemsPerColumn = val; }
+	virtual long getNbItemsPerColumn () const { return nbItemsPerColumn; }
+
+	void    setCurrentSelected (void *itemSelected);
+
+	long getLastResult () const { return lastResult; }
+	COptionMenu *getLastItemMenu (long &idxInMenu) const;
+
+	void setScheme (COptionMenuScheme* s) { scheme = s; }
+	virtual COptionMenuScheme* getScheme () const { return scheme; }
+
+	virtual void setPrefixNumbers (long preCount);
+
+	COptionMenu* getSubMenu (long idx) const;
+
+	CLASS_METHODS(COptionMenu, CParamDisplay)
+
+protected:
+	COptionMenu *getItemMenu (long idx, long &idxInMenu, long &offsetIdx);
+	void    removeItems ();
+	void    *appendItems (long &offsetIdx);
+
+	void    *platformControl;
+
+	bool   allocateMenu (long nb);
+	bool   allocateSubMenu (long nb);
+
+	char    **entry;
+	COptionMenu **submenuEntry;
+	bool    *check;
+
+	void    *itemWidget[MAX_ENTRY];
+
+	long     nbEntries;
+	long     nbSubMenus;
+	long     currentIndex;
+	CBitmap *bgWhenClick;
+	long     lastButton;
+	long     nbItemsPerColumn;
+	long     nbAllocated;
+	long     nbSubMenuAllocated;
+	long	 lastResult;
+	long	 prefixNumbers;
+	COptionMenu *lastMenu;
+	COptionMenuScheme* scheme;
+};
+
+
+//-----------------------------------------------------------------------------
+// CKnob Declaration
+//! a knob control
+//-----------------------------------------------------------------------------
+class CKnob : public CControl
+{
+public:
+	CKnob (const CRect &size, CControlListener *listener, long tag,
+           CBitmap *background, CBitmap *handle, const CPoint &offset);
+	virtual ~CKnob ();
+
+	virtual void draw (CDrawContext *pContext);
+	virtual	void mouse (CDrawContext *pContext, CPoint &where, long button = -1);
+	virtual bool onWheel (CDrawContext *pContext, const CPoint &where, float distance);
+	virtual long onKeyDown (VstKeyCode& keyCode);
+
+	virtual void drawHandle (CDrawContext *pContext);
+
+	virtual void  setStartAngle (float val);
+	virtual float getStartAngle () const { return startAngle; }
+
+	virtual void  setRangeAngle (float val);
+	virtual float getRangeAngle () const { return rangeAngle; }
+
+	virtual void  valueToPoint (CPoint &point) const;
+	virtual float valueFromPoint (CPoint &point) const;
+
+	virtual void setInsetValue (long val) { inset = val; }
+
+	virtual void setColorShadowHandle (CColor color);
+	virtual void setColorHandle (CColor color);
+
+	virtual void setHandleBitmap (CBitmap *bitmap);
+
+	virtual void  setZoomFactor (float val) { zoomFactor = val; }
+	virtual float getZoomFactor () const { return zoomFactor; }
+
+	CLASS_METHODS(CKnob, CControl)
+
+protected:
+	void compute ();
+
+	CPoint   offset;
+	CColor   colorHandle, colorShadowHandle;
+
+	CBitmap *pHandle;
+	long     inset;
+	float    startAngle, rangeAngle, halfAngle;
+	float    aCoef, bCoef;
+	float    radius;
+	float    zoomFactor;
+};
+
+//-----------------------------------------------------------------------------
+// CAnimKnob Declaration
+//! a bitmap knob control
+//-----------------------------------------------------------------------------
+class CAnimKnob : public CKnob
+{
+public:
+	CAnimKnob (const CRect &size, CControlListener *listener, long tag,
+               CBitmap *background, CPoint &offset);
+	CAnimKnob (const CRect &size, CControlListener *listener, long tag,
+               long subPixmaps,        // number of subPixmaps
+               CCoord heightOfOneImage,  // pixel
+               CBitmap *background, CPoint &offset);
+	virtual ~CAnimKnob ();
+
+	virtual bool isDirty () const;
+
+	virtual void draw (CDrawContext* pContext);
+
+	void setInverseBitmap (bool val) { bInverseBitmap = val; }
+
+	CLASS_METHODS(CAnimKnob, CKnob)
+
+protected:
+	long	subPixmaps;		// number of subPixmaps
+	CCoord	heightOfOneImage;
+	bool	bInverseBitmap;
+	CPoint	lastDrawnPoint;
+};
+
+//-----------------------------------------------------------------------------
+// CVerticalSwitch Declaration
+//! a vertical switch control
+//-----------------------------------------------------------------------------
+class CVerticalSwitch : public CControl
+{
+public:
+	CVerticalSwitch (const CRect &size, CControlListener *listener, long tag,
+                     CBitmap *background, CPoint &offset);
+	CVerticalSwitch (const CRect &size, CControlListener *listener, long tag,
+                     long subPixmaps,         // number of subPixmaps
+                     CCoord heightOfOneImage,   // pixel
+                     long iMaxPositions,
+                     CBitmap *background, CPoint &offset);
+	virtual ~CVerticalSwitch ();
+
+	virtual void draw (CDrawContext*);
+	virtual void mouse (CDrawContext *pContext, CPoint &where, long button = -1);
+
+	CLASS_METHODS(CVerticalSwitch, CControl)
+
+protected:
+	CPoint	offset;
+	long	subPixmaps;            // number of subPixmaps
+	CCoord	heightOfOneImage;
+	long	iMaxPositions;
+};
+
+
+//-----------------------------------------------------------------------------
+// CHorizontalSwitch Declaration
+//! a horizontal switch control
+//-----------------------------------------------------------------------------
+class CHorizontalSwitch : public CControl
+{
+public:
+	CHorizontalSwitch (const CRect &size, CControlListener *listener, long tag,
+                       CBitmap *background, CPoint &offset);
+	CHorizontalSwitch (const CRect &size, CControlListener *listener, long tag,
+                       long subPixmaps,        // number of subPixmaps
+                       CCoord heightOfOneImage,  // pixel
+                       long iMaxPositions,
+                       CBitmap *background, CPoint &offset);
+	virtual	~CHorizontalSwitch ();
+
+	virtual void draw (CDrawContext*);
+	virtual void mouse (CDrawContext *pContext, CPoint &where, long button = -1);
+
+	CLASS_METHODS(CHorizontalSwitch, CControl)
+
+protected:
+	CPoint	offset;
+	long	subPixmaps;        // number of subPixmaps
+	long	iMaxPositions;
+	CCoord	heightOfOneImage;
+};
+
+
+//-----------------------------------------------------------------------------
+// CRockerSwitch Declaration
+//! a switch control with 3 sub bitmaps
+//-----------------------------------------------------------------------------
+class CRockerSwitch : public CControl
+{
+public:
+	CRockerSwitch (const CRect &size, CControlListener *listener, long tag,
+                   CBitmap *background, CPoint &offset, const long style = kHorizontal);
+	CRockerSwitch (const CRect &size, CControlListener *listener, long tag,
+                   CCoord heightOfOneImage,  // pixel
+                   CBitmap *background, CPoint &offset, const long style = kHorizontal);
+	virtual ~CRockerSwitch ();
+
+	virtual void draw (CDrawContext*);
+	virtual void mouse (CDrawContext *pContext, CPoint &where, long button = -1);
+	virtual bool onWheel (CDrawContext *pContext, const CPoint &where, float distance);
+
+	CLASS_METHODS(CRockerSwitch, CControl)
+
+protected:
+	CPoint	offset;
+	CCoord	heightOfOneImage;
+	long	style;
+};
+
+
+//-----------------------------------------------------------------------------
+// CMovieBitmap Declaration
+//! a bitmap control that displays different bitmaps according to its current value
+//-----------------------------------------------------------------------------
+class CMovieBitmap : public CControl
+{
+public:
+	CMovieBitmap (const CRect &size, CControlListener *listener, long tag,
+                  CBitmap *background, CPoint &offset);
+	CMovieBitmap (const CRect &size, CControlListener *listener, long tag,
+                  long subPixmaps,        // number of subPixmaps
+                  CCoord heightOfOneImage,  // pixel
+                  CBitmap *background, CPoint &offset);
+	virtual	~CMovieBitmap ();
+
+	virtual void draw (CDrawContext*);
+
+	CLASS_METHODS(CMovieBitmap, CControl)
+
+protected:
+	CPoint	offset;
+	long	subPixmaps;         // number of subPixmaps
+	CCoord	heightOfOneImage;
+};
+
+
+//-----------------------------------------------------------------------------
+// CMovieButton Declaration
+//! a bi-states button with 2 subbitmaps
+//-----------------------------------------------------------------------------
+class CMovieButton : public CControl
+{
+public:
+	CMovieButton (const CRect &size, CControlListener *listener, long tag,
+                  CBitmap *background, CPoint &offset);
+	CMovieButton (const CRect &size, CControlListener *listener, long tag,
+                  CCoord heightOfOneImage,  // pixel
+                  CBitmap *background, CPoint &offset);
+	virtual ~CMovieButton ();
+
+	virtual void draw (CDrawContext*);
+	virtual void mouse (CDrawContext *pContext, CPoint &where, long button = -1);
+
+	CLASS_METHODS(CMovieButton, CControl)
+
+protected:
+	CPoint   offset;
+	CCoord   heightOfOneImage;
+	float    buttonState;
+};
+
+
+//-----------------------------------------------------------------------------
+// CAutoAnimation Declaration
+//!
+//-----------------------------------------------------------------------------
+class CAutoAnimation : public CControl
+{
+public:
+	CAutoAnimation (const CRect &size, CControlListener *listener, long tag,
+                    CBitmap *background, CPoint &offset);
+	CAutoAnimation (const CRect &size, CControlListener *listener, long tag,
+                    long subPixmaps,        // number of subPixmaps...
+                    CCoord heightOfOneImage,  // pixel
+                    CBitmap *background, CPoint &offset);
+	virtual ~CAutoAnimation ();
+
+	virtual void draw (CDrawContext*);
+	virtual void mouse (CDrawContext *pContext, CPoint &where, long button = -1);
+
+	virtual void openWindow (void);
+	virtual void closeWindow (void);
+
+	virtual void nextPixmap (void);
+	virtual void previousPixmap (void);
+
+	bool    isWindowOpened () const { return bWindowOpened; }
+
+	CLASS_METHODS(CAutoAnimation, CControl)
+
+protected:
+	CPoint	offset;
+
+	long	subPixmaps;
+	CCoord	heightOfOneImage;
+	CCoord	totalHeightOfBitmap;
+
+	bool	bWindowOpened;
+};
+
+
+//-----------------------------------------------------------------------------
+// CSlider Declaration
+//! a slider control
+//-----------------------------------------------------------------------------
+class CSlider : public CControl
+{
+public:
+	CSlider (const CRect &size, CControlListener *listener, long tag,
+             long    iMinPos,     // min position in pixel
+             long    iMaxPos,     // max position in pixel
+             CBitmap *handle,     // handle bitmap
+             CBitmap *background, // background bitmap
+             CPoint  &offset,     // offset in the background
+             const long style = kLeft|kHorizontal); // style (kBottom,kRight,kTop,kLeft,kHorizontal,kVertical)
+
+	CSlider (const CRect &rect, CControlListener *listener, long tag,
+             CPoint   &offsetHandle, // handle offset
+             long     rangeHandle,   // size of handle range
+             CBitmap  *handle,       // handle bitmap
+             CBitmap  *background,   // background bitmap
+             CPoint   &offset,       // offset in the background
+             const long style = kLeft|kHorizontal);  // style (kBottom,kRight,kTop,kLeft,kHorizontal,kVertical)
+
+	virtual ~CSlider ();
+
+	virtual bool attached (CView *parent);
+	virtual bool removed (CView *parent);
+	virtual void draw (CDrawContext*);
+	virtual void mouse (CDrawContext *pContext, CPoint &where, long button = -1);
+	virtual bool onWheel (CDrawContext *pContext, const CPoint &where, float distance);
+	virtual long onKeyDown (VstKeyCode& keyCode);
+
+	virtual void setDrawTransparentHandle (bool val) { bDrawTransparentEnabled = val; }
+	virtual void setFreeClick (bool val) { bFreeClick = val; }
+	virtual bool getFreeClick () const { return bFreeClick; }
+	virtual void setOffsetHandle (CPoint &val);
+
+	virtual void     setHandle (CBitmap* pHandle);
+	virtual CBitmap *getHandle () const { return pHandle; }
+
+	virtual void  setZoomFactor (float val) { zoomFactor = val; }
+	virtual float getZoomFactor () const { return zoomFactor; }
+
+	CLASS_METHODS(CSlider, CControl)
+
+protected:
+	CPoint   offset;
+	CPoint   offsetHandle;
+
+	CBitmap *pHandle;
+	COffscreenContext *pOScreen;
+
+	long	style;
+
+	CCoord	widthOfSlider; // size of the handle-slider
+	CCoord	heightOfSlider;
+	CCoord	rangeHandle;
+	CCoord	minTmp;
+	CCoord	maxTmp;
+	CCoord	minPos;
+	CCoord	widthControl;
+	CCoord	heightControl;
+	float	zoomFactor;
+
+	bool     bDrawTransparentEnabled;
+	bool     bFreeClick;
+};
+
+//-----------------------------------------------------------------------------
+// CVerticalSlider Declaration
+//! a vertical slider control
+//-----------------------------------------------------------------------------
+class CVerticalSlider : public CSlider
+{
+public:
+	CVerticalSlider (const CRect &size, CControlListener *listener, long tag,
+                     long    iMinPos,    // min Y position in pixel
+                     long    iMaxPos,    // max Y position in pixel
+                     CBitmap *handle,     // bitmap slider
+                     CBitmap *background, // bitmap background
+                     CPoint  &offset,     // offset in the background
+                     const long style = kBottom); // style (kBottom, kTop))
+
+	CVerticalSlider (const CRect &rect, CControlListener *listener, long tag,
+                     CPoint   &offsetHandle, // handle offset
+                     long     rangeHandle,   // size of handle range
+                     CBitmap  *handle,     // bitmap of slider
+                     CBitmap  *background, // bitmap of background
+                     CPoint   &offset,     // offset in the background
+                     const long style = kBottom);  // style (kBottom, kTop)
+};
+
+//-----------------------------------------------------------------------------
+// CHorizontalSlider Declaration
+//! a horizontal slider control
+//-----------------------------------------------------------------------------
+class CHorizontalSlider : public CSlider
+{
+public:
+	CHorizontalSlider (const CRect &size, CControlListener *listener, long tag,
+                       long    iMinPos,    // min X position in pixel
+                       long    iMaxPos,    // max X position in pixel
+                       CBitmap *handle,     // bitmap slider
+                       CBitmap *background, // bitmap background
+                       CPoint  &offset,     // offset in the background
+                       const long style = kRight); // style (kRight, kLeft)
+
+	CHorizontalSlider (const CRect &rect, CControlListener *listener, long tag,
+                       CPoint   &offsetHandle, // handle offset
+                       long     rangeHandle,   // size of handle range
+                       CBitmap  *handle,     // bitmap of slider
+                       CBitmap  *background, // bitmap of background
+                       CPoint   &offset,     // offset in the background
+                       const long style = kRight);  // style (kRight, kLeft)
+};
+
+
+//-----------------------------------------------------------------------------
+// CSpecialDigit Declaration
+//! special display with custom numbers (0...9)
+//-----------------------------------------------------------------------------
+class CSpecialDigit : public CControl
+{
+public:
+	CSpecialDigit (const CRect &size, CControlListener *listener, long tag, // tag identifier
+                   long     dwPos,     // actual value
+                   long     iNumbers,  // amount of numbers (max 7)
+                   long     *xpos,     // array of all XPOS
+                   long     *ypos,     // array of all YPOS
+                   long     width,     // width of ONE number
+                   long     height,    // height of ONE number
+                   CBitmap  *background);  // bitmap numbers
+	virtual ~CSpecialDigit ();
+
+	virtual void  draw (CDrawContext*);
+
+	virtual float getNormValue (void) const;
+
+	CLASS_METHODS(CSpecialDigit, CControl)
+
+protected:
+	long     iNumbers;   // amount of numbers
+	long     xpos[7];    // array of all XPOS, max 7 possible
+	long     ypos[7];    // array of all YPOS, max 7 possible
+	long     width;      // width  of ONE number
+	long     height;     // height of ONE number
+};
+
+
+//-----------------------------------------------------------------------------
+// CKickButton Declaration
+//!
+//-----------------------------------------------------------------------------
+class CKickButton : public CControl
+{
+public:
+	CKickButton (const CRect &size, CControlListener *listener, long tag,
+                 CBitmap *background, CPoint &offset);
+	CKickButton (const CRect &size, CControlListener *listener, long tag,
+                 CCoord heightOfOneImage,  // pixel
+                 CBitmap *background, CPoint &offset);
+	virtual ~CKickButton ();
+
+	virtual void draw (CDrawContext*);
+	virtual void mouse (CDrawContext *pContext, CPoint &where, long button = -1);
+
+	CLASS_METHODS(CKickButton, CControl)
+
+protected:
+	CPoint	offset;
+	CCoord	heightOfOneImage;
+};
+
+
+//-----------------------------------------------------------------------------
+// CSplashScreen Declaration
+//!
+//-----------------------------------------------------------------------------
+class CSplashScreen : public CControl
+{
+public:
+	CSplashScreen (const CRect &size, CControlListener *listener, long tag,
+                   CBitmap *background,
+                   CRect &toDisplay,
+                   CPoint &offset);
+	virtual ~CSplashScreen ();
+
+	virtual void draw (CDrawContext*);
+	virtual bool hitTest (const CPoint& where, const long buttons = -1);
+	virtual void mouse (CDrawContext *pContext, CPoint &where, long button = -1);
+	virtual void unSplash ();
+
+	void setBitmapTransparency (unsigned char transparency);
+
+	CLASS_METHODS(CSplashScreen, CControl)
+
+protected:
+	CRect	toDisplay;
+	CRect	keepSize;
+	CPoint	offset;
+	unsigned char bitmapTransparency;
+};
+
+
+//-----------------------------------------------------------------------------
+// CVuMeter Declaration
+//!
+//-----------------------------------------------------------------------------
+class CVuMeter : public CControl
+{
+public:
+	CVuMeter (const CRect& size, CBitmap *onBitmap, CBitmap *offBitmap,
+              long nbLed, const long style = kVertical);
+	virtual ~CVuMeter ();
+
+	virtual void setDecreaseStepValue (float value) { decreaseValue = value; }
+
+	virtual bool attached (CView *parent);
+	virtual bool removed (CView *parent);
+	virtual void draw (CDrawContext *pContext);
+	virtual void setDirty (const bool val = true);
+
+	void setUseOffscreen (bool val = true);
+	bool getUseOffscreen () const { return bUseOffscreen; }
+
+	CLASS_METHODS(CVuMeter, CControl)
+
+protected:
+	CBitmap *onBitmap;
+	CBitmap *offBitmap;
+	COffscreenContext *pOScreen;
+
+	long     nbLed;
+	long     style;
+	float    decreaseValue;
+	bool	 bUseOffscreen;
+
+	CRect    rectOn;
+	CRect    rectOff;
+};
+
+
+#if !PLUGGUI
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+class CFileSelector
+{
+public:
+    CFileSelector (AudioEffectX* effect);
+    virtual ~CFileSelector ();
+
+    long run (VstFileSelect *vstFileSelect);
+
+protected:
+    AudioEffectX* effect;
+    VstFileSelect *vstFileSelect;
+};
+#endif
+
+} // namespace VSTGUI
+
+#endif	// __vstcontrol__
diff --git a/vstgui/vstgui.cpp b/vstgui/vstgui.cpp
new file mode 100644
index 0000000..ab52007
--- /dev/null
+++ b/vstgui/vstgui.cpp
@@ -0,0 +1,3996 @@
+/* ----------------------------------------------------------------------------
+ * VSTGUI for X11/LV2/PNG
+ * Author: Dave Robillard
+ * Released under the revised BSD license, as below
+ * ----------------------------------------------------------------------------
+ *
+ * Based on:
+ * ----------------------------------------------------------------------------
+ * VSTGUIL: Graphical User Interface Framework for VST plugins on LINUX
+ * Version: 0.1, Date: 2007/01/21
+ * Author: kRAkEn/gORe
+ *
+ * Which was based on:
+ * ----------------------------------------------------------------------------
+ * VSTGUI: Graphical User Interface Framework for VST plugins
+ * Version 3.0       $Date: 2005/08/12 12:45:00 $
+ * ----------------------------------------------------------------------------
+ * VSTGUI LICENSE
+ * 2004, Steinberg Media Technologies, All Rights Reserved
+ * ----------------------------------------------------------------------------
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of the Steinberg Media Technologies nor the names of
+ *     its contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A  PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+ * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ * ----------------------------------------------------------------------------
+ */
+
+#include <cstdio>
+#include <cstdlib>
+#include <cmath>
+#include <iostream>
+#include <string.h>
+
+#include "vstgui.h"
+#include "audioeffectx.h"
+#include "vstkeycode.h"
+
+//-----------------------------------------------------------------------------
+// Some defines
+//-----------------------------------------------------------------------------
+#ifdef DEBUG
+    #define DBG(x)              std::cout << x << std::endl;
+    #define assertfalse         assert (false);
+#else
+    #define DBG(x)
+    #define assertfalse
+#endif
+
+#define USE_ALPHA_BLEND            0
+#define USE_CLIPPING_DRAWRECT      1
+#define NEW_UPDATE_MECHANISM       1
+
+
+//-----------------------------------------------------------------------------
+// our global display
+Display* display = 0;
+
+
+//-----------------------------------------------------------------------------
+// AEffGUIEditor Implementation
+//-----------------------------------------------------------------------------
+#define kIdleRate    100 // host idle rate in ms
+#define kIdleRate2    50
+#define kIdleRateMin   4 // minimum time between 2 idles in ms
+
+//-----------------------------------------------------------------------------
+VstInt32 AEffGUIEditor::knobMode = kCircularMode;
+
+//-----------------------------------------------------------------------------
+AEffGUIEditor::AEffGUIEditor (AudioEffect* effect)
+: AEffEditor (effect),
+  lLastTicks (0),
+  inIdleStuff (false),
+  bundlePath(NULL),
+  frame (0)
+{
+    rect.left = rect.top = rect.right = rect.bottom = 0;
+    lLastTicks = getTicks ();
+
+    effect->setEditor (this);
+}
+	
+//-----------------------------------------------------------------------------
+AEffGUIEditor::~AEffGUIEditor ()
+{
+}
+
+//-----------------------------------------------------------------------------
+void AEffGUIEditor::setParameter (VstInt32 index, float value)
+{}
+
+//-----------------------------------------------------------------------------
+void AEffGUIEditor::beginEdit (VstInt32 index)
+{
+    ((AudioEffectX*)effect)->beginEdit (index);
+}
+
+//-----------------------------------------------------------------------------
+void AEffGUIEditor::endEdit (VstInt32 index)
+{
+    ((AudioEffectX*)effect)->endEdit (index);
+}
+
+//-----------------------------------------------------------------------------
+#if VST_2_1_EXTENSIONS
+long AEffGUIEditor::onKeyDown (VstKeyCode& keyCode)
+{
+    return frame && frame->onKeyDown (keyCode) == 1 ? 1 : 0;
+}
+
+//-----------------------------------------------------------------------------
+long AEffGUIEditor::onKeyUp (VstKeyCode& keyCode)
+{
+    return frame && frame->onKeyUp (keyCode) == 1 ? 1 : 0;
+}
+
+//-----------------------------------------------------------------------------
+long AEffGUIEditor::setKnobMode (VstInt32 val)
+{
+    knobMode = val;
+    return 1;
+}
+
+//-----------------------------------------------------------------------------
+bool AEffGUIEditor::onWheel (float distance)
+{
+/*
+    if (frame)
+    {
+        CDrawContext context (frame, NULL, systemWindow);
+        CPoint where;
+        context.getMouseLocation (where);
+        return frame->onWheel (&context, where, distance);
+    }
+*/
+    return false;
+}
+#endif
+
+//-----------------------------------------------------------------------------
+long AEffGUIEditor::getRect (ERect **ppErect)
+{
+    *ppErect = &rect;
+    return 1;
+}
+
+//-----------------------------------------------------------------------------
+void AEffGUIEditor::idle ()
+{
+    if (inIdleStuff)
+        return;
+
+    AEffEditor::idle ();
+    if (frame)
+        frame->idle ();
+}
+
+//-----------------------------------------------------------------------------
+void AEffGUIEditor::wait (unsigned int ms)
+{
+    usleep (ms * 1000);
+}
+
+//-----------------------------------------------------------------------------
+unsigned int AEffGUIEditor::getTicks ()
+{
+    return _getTicks ();
+}
+
+//-----------------------------------------------------------------------------
+void AEffGUIEditor::doIdleStuff ()
+{
+    // get the current time
+    unsigned int currentTicks = getTicks ();
+
+    // YG TEST idle ();
+    if (currentTicks < lLastTicks)
+    {
+        wait (kIdleRateMin);
+
+        currentTicks += kIdleRateMin;
+        if (currentTicks < lLastTicks - kIdleRate2)
+            return;
+    }
+
+    idle ();
+
+    // save the next time
+    lLastTicks = currentTicks + kIdleRate;
+
+    inIdleStuff = true;
+
+    if (effect)
+        effect->masterIdle ();
+
+    inIdleStuff = false;
+}
+
+void AEffGUIEditor::update ()
+{
+    if (frame)
+        frame->invalidate (CRect (0, 0, rect.right, rect.bottom));
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+//---For Debugging------------------------
+#if DEBUG
+long gNbCBitmap = 0;
+long gNbCView = 0;
+long gNbCDrawContext = 0;
+long gNbCOffscreenContext = 0;
+long gBitmapAllocation = 0;
+long gNbDC = 0;
+#include <stdarg.h>
+void DebugPrint (const char *format, ...);
+void DebugPrint (const char *format, ...)
+{
+    char string[300];
+    va_list marker;
+    va_start (marker, format);
+    vsprintf (string, format, marker);
+    if (!strcmp(string, ""))
+        strcpy (string, "Empty string\n");
+    fprintf (stderr, string);
+}
+#endif
+//---End For Debugging------------------------
+
+#include <assert.h>
+#include <time.h>
+#include <stdlib.h>
+#include <math.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+
+#define XDRAWPARAM display, (Window)pWindow, (GC) pSystemContext
+#define XWINPARAM  display, (Window)pFrame->getWindow()
+#define XGCPARAM   display, (GC) pSystemContext
+
+// #define XDRAWPARAM display, (Window)pWindow, (GC)pSystemContext
+// #define XWINPARAM  display, (Window)pWindow
+// #define XGCPARAM   display, (GC)pSystemContext
+
+// init the static variable about font
+bool gFontInit = false;
+XFontStruct *gFontStructs[] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+struct SFontTable { const char* name; const char* string; };
+
+static SFontTable gFontTable[] = {
+  {"SystemFont",          "-*-fixed-*-*-*--12-*-*-*-*-*-*-*"}, // kSystemFont
+  {"NormalFontVeryBig",   "-*-fixed-*-*-*--18-*-*-*-*-*-*-*"}, // kNormalFontVeryBig
+  {"NormalFontBig",       "-*-fixed-*-*-*--18-*-*-*-*-*-*-*"}, // kNormalFontBig
+  {"NormalFont",          "-*-fixed-*-*-*--12-*-*-*-*-*-*-*"}, // kNormalFont
+  {"NormalFontSmall",     "-*-courier-*-*-*--10-*-*-*-*-*-*-*"}, // kNormalFontSmall
+  {"NormalFontSmaller",   "-*-courier-*-*-*--9-*-*-*-*-*-*-*"}, // kNormalFontSmaller
+  {"NormalFontVerySmall", "-*-courier-*-*-*--8-*-*-*-*-*-*-*"}, // kNormalFontVerySmall
+  {"SymbolFont",          "-*-fixed-*-*-*--12-*-*-*-*-*-*-*"}  // kSymbolFont
+};
+
+long gStandardFontSize[] = { 12, 18, 18, 12, 10, 9, 8, 13 };
+
+// declaration of different local functions
+static long convertPoint2Angle (CPoint &pm, CPoint &pt);
+
+// stuff for color
+long CDrawContext::nbNewColor = 0;
+
+//-----------------------------------------------------------------------------
+bool CRect::pointInside (const CPoint& where) const
+{
+    return where.h >= left && where.h < right && where.v >= top && where.v < bottom;
+}
+
+//-----------------------------------------------------------------------------
+bool CRect::isEmpty () const
+{
+    if (right <= left)
+        return true;
+    if (bottom <= top)
+        return true;
+    return false;
+}
+
+//-----------------------------------------------------------------------------
+void CRect::bound (const CRect& rect)
+{
+    if (left < rect.left)
+        left = rect.left;
+    if (top < rect.top)
+        top = rect.top;
+    if (right > rect.right)
+        right = rect.right;
+    if (bottom > rect.bottom)
+        bottom = rect.bottom;
+    if (bottom < top)
+        bottom = top;
+    if (right < left)
+        right = left;
+}
+
+namespace VSTGUI {
+
+CColor kTransparentCColor = {255, 255, 255,   0};
+CColor kBlackCColor       = {  0,   0,   0, 255};
+CColor kWhiteCColor       = {255, 255, 255, 255};
+CColor kGreyCColor        = {127, 127, 127, 255};
+CColor kRedCColor         = {255,   0,   0, 255};
+CColor kGreenCColor       = {  0, 255,   0, 255};
+CColor kBlueCColor        = {  0,   0, 255, 255};
+CColor kYellowCColor      = {255, 255,   0, 255};
+CColor kMagentaCColor     = {255,   0, 255, 255};
+CColor kCyanCColor        = {  0, 255, 255, 255};
+
+#define kDragDelay 0
+
+//-----------------------------------------------------------------------------
+// CDrawContext Implementation
+//-----------------------------------------------------------------------------
+/**
+ * CDrawContext constructor.
+ * @param inFrame the parent CFrame
+ * @param inSystemContext the platform system context, can be NULL
+ * @param inWindow the platform window object
+ */
+CDrawContext::CDrawContext (CFrame *inFrame, void *inSystemContext, void *inWindow)
+: pSystemContext (inSystemContext)
+, pWindow (inWindow)
+, pFrame (inFrame)
+, fontSize (-1)
+, fontStyle (0)
+, fontId (kNumStandardFonts)
+, frameWidth (0)
+, lineStyle (kLineOnOffDash)
+, drawMode (kAntialias)
+{
+#if DEBUG
+    gNbCDrawContext++;
+#endif
+
+    // initialize values
+    if (pFrame)
+        pFrame->getViewSize (clipRect);
+    else
+        clipRect (0, 0, 1000, 1000);
+
+    const CColor notInitalized = {0, 0, 0, 0};
+    frameColor = notInitalized;
+    fillColor  = notInitalized;
+    fontColor  = notInitalized;
+
+    // offsets use by offscreen
+    offset (0, 0);
+    offsetScreen (0, 0);
+
+    // set the current font
+    if (pSystemContext)
+    {
+        // set the default values
+        setFont (kNormalFont);
+        setFrameColor (kWhiteCColor);
+        setLineStyle (kLineSolid);
+        setLineWidth (1);
+        setFont (kSystemFont);
+        setDrawMode (kCopyMode);
+    }
+}
+
+//-----------------------------------------------------------------------------
+CDrawContext::~CDrawContext ()
+{
+#if DEBUG
+    gNbCDrawContext--;
+#endif
+}
+
+//-----------------------------------------------------------------------------
+void CDrawContext::setLineStyle (CLineStyle style)
+{
+    if (lineStyle == style)
+        return;
+
+    lineStyle = style;
+
+    long line_width;
+    long line_style;
+    if (frameWidth == 1)
+        line_width = 0;
+    else
+        line_width = frameWidth;
+
+    switch (lineStyle)
+    {
+    case kLineOnOffDash:
+        line_style = LineOnOffDash;
+        break;
+    default:
+        line_style = LineSolid;
+        break;
+    }
+
+    XSetLineAttributes (XGCPARAM, line_width, line_style, CapNotLast, JoinRound);
+}
+
+//-----------------------------------------------------------------------------
+void CDrawContext::setLineWidth (CCoord width)
+{
+    if (frameWidth == width)
+        return;
+
+    frameWidth = width;
+
+    setLineStyle (lineStyle);
+}
+
+//-----------------------------------------------------------------------------
+void CDrawContext::setDrawMode (CDrawMode mode)
+{
+    if (drawMode == mode)
+        return;
+
+    drawMode = mode;
+
+    long iMode = 0;
+    switch (drawMode)
+    {
+    case kXorMode :
+        iMode = GXinvert;
+        break;
+    case kOrMode :
+        iMode = GXor;
+        break;
+    default:
+        iMode = GXcopy;
+    }
+
+    ((XGCValues*)pSystemContext)->function = iMode;
+
+    XChangeGC (XGCPARAM, GCFunction, (XGCValues*)pSystemContext);
+}
+
+//------------------------------------------------------------------------------
+void CDrawContext::setClipRect (const CRect &clip)
+{
+    CRect _clip (clip);
+    _clip.offset (offset.h, offset.v);
+
+    if (clipRect == _clip)
+        return;
+
+    clipRect = _clip;
+
+    XRectangle r;
+    r.x = 0;
+    r.y = 0;
+    r.width  = clipRect.right - clipRect.left + 1;
+    r.height = clipRect.bottom - clipRect.top + 1;
+
+    XSetClipRectangles (XGCPARAM, clipRect.left, clipRect.top, &r, 1, Unsorted);
+}
+
+//------------------------------------------------------------------------------
+void CDrawContext::resetClipRect ()
+{
+    CRect newClip;
+    if (pFrame)
+        pFrame->getViewSize (newClip);
+    else
+        newClip (0, 0, 1000, 1000);
+
+    setClipRect (newClip);
+
+    clipRect = newClip;
+}
+
+//-----------------------------------------------------------------------------
+void CDrawContext::moveTo (const CPoint &_point)
+{
+    CPoint point (_point);
+    point.offset (offset.h, offset.v);
+
+    penLoc = point;
+}
+
+//-----------------------------------------------------------------------------
+void CDrawContext::lineTo (const CPoint& _point)
+{
+    CPoint point (_point);
+    point.offset (offset.h, offset.v);
+
+    CPoint start (penLoc);
+    CPoint end (point);
+    if (start.h == end.h)
+    {
+        if (start.v < -5)
+            start.v = -5;
+        else if (start.v > 10000)
+            start.v = 10000;
+
+        if (end.v < -5)
+            end.v = -5;
+        else if (end.v > 10000)
+            end.v = 10000;
+    }
+    if (start.v == end.v)
+    {
+        if (start.h < -5)
+            start.h = -5;
+        else if (start.h > 10000)
+            start.h = 10000;
+
+        if (end.h < -5)
+            end.h = -5;
+        else if (end.h > 10000)
+            end.h = 10000;
+    }
+
+    XDrawLine (XDRAWPARAM, start.h, start.v, end.h, end.v);
+
+    // keep trace of the new position
+    penLoc = point;
+}
+
+//-----------------------------------------------------------------------------
+void CDrawContext::drawLines (const CPoint* points, const long& numLines)
+{
+    // default implementation, when no platform optimized code is implemented
+    for (long i = 0; i < numLines * 2; i+=2)
+    {
+        moveTo (points[i]);
+        lineTo (points[i+1]);
+    }
+}
+
+//-----------------------------------------------------------------------------
+void CDrawContext::drawPolygon (const CPoint *pPoints, long numberOfPoints, const CDrawStyle drawStyle)
+{
+    if (drawStyle == kDrawFilled || drawStyle == kDrawFilledAndStroked)
+        fillPolygon (pPoints, numberOfPoints);
+    if (drawStyle == kDrawStroked || drawStyle == kDrawFilledAndStroked)
+        polyLine (pPoints, numberOfPoints);
+}
+
+//-----------------------------------------------------------------------------
+void CDrawContext::polyLine (const CPoint *pPoints, long numberOfPoints)
+{
+    XPoint* pt = (XPoint*)malloc (numberOfPoints * sizeof (XPoint));
+    if (!pt)
+        return;
+    for (long i = 0; i < numberOfPoints; i++)
+    {
+        pt[i].x = (short)pPoints[i].h + offset.h;
+        pt[i].y = (short)pPoints[i].v + offset.v;
+    }
+
+    XDrawLines (XDRAWPARAM, pt, numberOfPoints, CoordModeOrigin);
+
+    free (pt);
+}
+
+//-----------------------------------------------------------------------------
+void CDrawContext::fillPolygon (const CPoint *pPoints, long numberOfPoints)
+{
+    // convert the points
+    XPoint* pt = (XPoint*)malloc (numberOfPoints * sizeof (XPoint));
+    if (!pt)
+        return;
+    for (long i = 0; i < numberOfPoints; i++)
+    {
+        pt[i].x = (short)pPoints[i].h + offset.h;
+        pt[i].y = (short)pPoints[i].v + offset.v;
+    }
+
+    XFillPolygon (XDRAWPARAM, pt, numberOfPoints, Convex, CoordModeOrigin);
+
+    free (pt);
+}
+
+//-----------------------------------------------------------------------------
+void CDrawContext::drawRect (const CRect &_rect, const CDrawStyle drawStyle)
+{
+    CRect rect (_rect);
+    rect.offset (offset.h, offset.v);
+
+    XDrawRectangle (XDRAWPARAM, rect.left, rect.top, rect.width (), rect.height ());
+}
+
+//-----------------------------------------------------------------------------
+void CDrawContext::fillRect (const CRect &_rect)
+{
+    CRect rect (_rect);
+    rect.offset (offset.h, offset.v);
+
+    // Don't draw boundary
+    XFillRectangle (XDRAWPARAM, rect.left + 1, rect.top + 1, rect.width () - 1, rect.height () - 1);
+}
+
+//-----------------------------------------------------------------------------
+void CDrawContext::drawEllipse (const CRect &_rect, const CDrawStyle drawStyle)
+{
+    CPoint point (_rect.left + (_rect.right - _rect.left) / 2, _rect.top);
+    drawArc (_rect, point, point);
+}
+
+//-----------------------------------------------------------------------------
+void CDrawContext::fillEllipse (const CRect &_rect)
+{
+    CRect rect (_rect);
+    rect.offset (offset.h, offset.v);
+
+    // Don't draw boundary
+    CPoint point (_rect.left + ((_rect.right - _rect.left) / 2), _rect.top);
+    fillArc (_rect, point, point);
+}
+
+//-----------------------------------------------------------------------------
+void CDrawContext::drawPoint (const CPoint &_point, CColor color)
+{
+    CPoint point (_point);
+
+    CColor oldframecolor = frameColor;
+    setFrameColor (color);
+
+    XDrawPoint (XDRAWPARAM, point.h, point.v);
+
+    setFrameColor (oldframecolor);
+}
+
+//-----------------------------------------------------------------------------
+CColor CDrawContext::getPoint (const CPoint& _point)
+{
+//    CPoint point (_point);
+//    point.offset (offset.h, offset.v);
+
+    assertfalse // not implemented !
+
+    CColor color = kBlackCColor;
+    return color;
+}
+
+//-----------------------------------------------------------------------------
+void CDrawContext::floodFill (const CPoint& _start)
+{
+//    CPoint start (_start);
+//    start.offset (offset.h, offset.v);
+
+    assertfalse // not implemented !
+}
+
+//-----------------------------------------------------------------------------
+void CDrawContext::drawArc (const CRect &_rect, const float _startAngle, const float _endAngle, const CDrawStyle drawStyle) // in degree
+{
+    CRect rect (_rect);
+    rect.offset (offset.h, offset.v);
+
+    XDrawArc (XDRAWPARAM, rect.left, rect.top, rect.width (), rect.height (),
+              (int) _startAngle * 64, (int) _endAngle * 64);
+}
+
+//-----------------------------------------------------------------------------
+void CDrawContext::drawArc (const CRect &_rect, const CPoint &_point1, const CPoint &_point2)
+{
+    CRect rect (_rect);
+    rect.offset (offset.h, offset.v);
+    CPoint point1 (_point1);
+    point1.offset (offset.h, offset.v);
+    CPoint point2 (_point2);
+    point2.offset (offset.h, offset.v);
+
+    int    angle1, angle2;
+    if ((point1.v == point2.v) && (point1.h == point2.h))
+    {
+        angle1 = 0;
+        angle2 = 23040; // 360 * 64
+    }
+    else
+    {
+        CPoint pm ((rect.left + rect.right) / 2, (rect.top + rect.bottom) / 2);
+        angle1 = convertPoint2Angle (pm, point1);
+        angle2 = convertPoint2Angle (pm, point2) - angle1;
+        if (angle2 < 0)
+            angle2 += 23040; // 360 * 64
+    }
+
+    XDrawArc (XDRAWPARAM, rect.left, rect.top, rect.width (), rect.height (),
+              angle1, angle2);
+}
+
+//-----------------------------------------------------------------------------
+void CDrawContext::fillArc (const CRect &_rect, const CPoint &_point1, const CPoint &_point2)
+{
+    CRect rect (_rect);
+    rect.offset (offset.h, offset.v);
+    CPoint point1 (_point1);
+    point1.offset (offset.h, offset.v);
+    CPoint point2 (_point2);
+    point2.offset (offset.h, offset.v);
+
+    // Don't draw boundary
+    int    angle1, angle2;
+    if ((point1.v == point2.v) && (point1.h == point2.h))
+    {
+        angle1 = 0;
+        angle2 = 23040; // 360 * 64
+    }
+    else
+    {
+        CPoint pm ((rect.left + rect.right) / 2, (rect.top + rect.bottom) / 2);
+        angle1 = convertPoint2Angle (pm, point1);
+        angle2 = convertPoint2Angle (pm, point2);
+    }
+
+    XFillArc (XDRAWPARAM, rect.left, rect.top, rect.width (), rect.height (),
+              angle1, angle2);
+}
+
+//-----------------------------------------------------------------------------
+void CDrawContext::setFontColor (const CColor color)
+{
+    fontColor = color;
+
+    setFrameColor (fontColor);
+}
+
+//-----------------------------------------------------------------------------
+void CDrawContext::setFrameColor (const CColor color)
+{
+    if (frameColor == color)
+        return;
+
+    frameColor = color;
+
+    XSetForeground (XGCPARAM, getIndexColor (frameColor));
+}
+
+//-----------------------------------------------------------------------------
+void CDrawContext::setFillColor (const CColor color)
+{
+    if (fillColor == color)
+        return;
+
+    fillColor = color;
+
+    // set the background for the text
+    //XSetBackground (XGCPARAM, getIndexColor (fillColor));
+    XSetBackground (display, pFrame->getGC(), getIndexColor (fillColor));
+
+    // set the foreground for the fill
+    setFrameColor (fillColor);
+}
+
+//-----------------------------------------------------------------------------
+void CDrawContext::setFont (CFont fontID, const long size, long style)
+{
+    if (fontID < 0 || fontID >= kNumStandardFonts)
+        fontID = kSystemFont;
+
+    if (fontId == fontID && fontSize == (size != 0 ? size : gStandardFontSize[fontID]) && fontStyle == style)
+        return;
+
+    fontStyle = style;
+    fontId = fontID;
+    if (size != 0)
+        fontSize = size;
+    else
+        fontSize = gStandardFontSize[fontID];
+
+	if (gFontStructs[fontID] != NULL)
+	    XSetFont (display, pFrame->getGC(), gFontStructs[fontID]->fid);
+	else
+		fprintf(stderr, "ERROR: Font not defined\n");
+
+    // keep trace of the current font
+    pFontInfoStruct = gFontStructs[fontID];
+
+#ifdef DEBUG
+//    if (!pFontInfoStruct) assert (false); // fonts have invalid pointers !
+#endif
+}
+
+//------------------------------------------------------------------------------
+CCoord CDrawContext::getStringWidth (const char *pStr)
+{
+    CCoord result = 0;
+
+    result = (long) XTextWidth (pFontInfoStruct, pStr, strlen (pStr));
+
+    return result;
+}
+
+//-----------------------------------------------------------------------------
+void CDrawContext::drawString (const char *string, const CRect &_rect,
+                               const short opaque, const CHoriTxtAlign hAlign)
+{
+    if (!string)
+        return;
+
+    CRect rect (_rect);
+    rect.offset (offset.h, offset.v);
+
+    int width;
+    int fontHeight = pFontInfoStruct->ascent + pFontInfoStruct->descent;
+    int xPos;
+    int yPos;
+    int rectHeight = rect.height ();
+
+    if (rectHeight >= fontHeight)
+        yPos = rect.bottom - (rectHeight - fontHeight) / 2;
+    else
+        yPos = rect.bottom;
+    yPos -= pFontInfoStruct->descent;
+
+    switch (hAlign)
+    {
+    case kCenterText:
+        width = XTextWidth (pFontInfoStruct, string, strlen (string));
+        xPos = (rect.right + rect.left - width) / 2;
+        break;
+
+    case kRightText:
+        width = XTextWidth (pFontInfoStruct, string, strlen (string));
+        xPos = rect.right - width;
+        break;
+
+    default: // left adjust
+        xPos = rect.left + 1;
+    }
+
+    if (opaque)
+        XDrawImageString (XDRAWPARAM, xPos, yPos, string, strlen (string));
+    else
+        XDrawString (XDRAWPARAM, xPos, yPos, string, strlen (string));
+}
+
+//-----------------------------------------------------------------------------
+long CDrawContext::getMouseButtons ()
+{
+    long buttons = 0;
+
+    Window root, child;
+    int rootX, rootY, childX, childY;
+    unsigned int mask;
+
+    XQueryPointer (XWINPARAM,
+                   &root,
+                   &child,
+                   &rootX,
+                   &rootY,
+                   &childX,
+                   &childY,
+                   &mask);
+
+    if (mask & Button1Mask)
+        buttons |= kLButton;
+    if (mask & Button2Mask)
+        buttons |= kMButton;
+    if (mask & Button3Mask)
+        buttons |= kRButton;
+
+    if (mask & ShiftMask)
+        buttons |= kShift;
+    if (mask & ControlMask)
+        buttons |= kControl;
+    if (mask & Mod1Mask)
+        buttons |= kAlt;
+
+    return buttons;
+}
+
+//-----------------------------------------------------------------------------
+void CDrawContext::getMouseLocation (CPoint &point)
+{
+    Window root, child;
+    int rootX, rootY, childX, childY;
+    unsigned int mask;
+
+    XQueryPointer (XWINPARAM,
+                   &root,
+                   &child,
+                   &rootX,
+                   &rootY,
+                   &childX,
+                   &childY,
+                   &mask);
+
+    point (childX, childY);
+
+    point.offset (-offsetScreen.h, -offsetScreen.v);
+}
+
+//-----------------------------------------------------------------------------
+bool CDrawContext::waitDoubleClick ()
+{
+    bool doubleClick = false;
+
+    long currentTime = _getTicks ();
+    long clickTime = currentTime + 200; // XtGetMultiClickTime (display);
+
+    XEvent e;
+    while (currentTime < clickTime)
+    {
+        if (XCheckTypedEvent (display, ButtonPress, &e))
+        {
+            doubleClick = true;
+            break;
+        }
+
+        currentTime = _getTicks ();
+    }
+
+    return doubleClick;
+}
+
+//-----------------------------------------------------------------------------
+bool CDrawContext::waitDrag ()
+{
+    if (!pFrame)
+        return false;
+
+    CPoint mouseLoc;
+    getMouseLocation (mouseLoc);
+    CRect observe (mouseLoc.h - 2, mouseLoc.v - 2, mouseLoc.h + 2, mouseLoc.v + 2);
+
+    long currentTime = pFrame->getTicks ();
+    bool wasOutside = false;
+
+    while (((getMouseButtons () & ~(kMButton|kRButton)) & kLButton) != 0)
+    {
+        pFrame->doIdleStuff ();
+        if (!wasOutside)
+        {
+            getMouseLocation (mouseLoc);
+            if (!observe.pointInside (mouseLoc))
+            {
+                if (kDragDelay <= 0)
+                    return true;
+                wasOutside = true;
+            }
+        }
+
+        if (wasOutside && (pFrame->getTicks () - currentTime > kDragDelay))
+            return true;
+    }
+    return false;
+}
+
+//-----------------------------------------------------------------------------
+void CDrawContext::forget ()
+{
+    CReferenceCounter::forget ();
+}
+
+//-----------------------------------------------------------------------------
+long CDrawContext::getIndexColor (CColor color)
+{
+    XColor xcol;
+    xcol.red = color.red << 8;
+    xcol.green = color.green << 8;
+    xcol.blue = color.blue << 8;
+    xcol.flags = (DoRed | DoGreen | DoBlue);
+    XAllocColor (display, XDefaultColormap (display, 0), &xcol);
+    return xcol.pixel;
+}
+
+//-----------------------------------------------------------------------------
+Colormap CDrawContext::getColormap ()
+{
+    if (pFrame)
+        return pFrame->getColormap ();
+    else
+        return None;
+}
+
+//-----------------------------------------------------------------------------
+Visual* CDrawContext::getVisual ()
+{
+    if (pFrame)
+        return pFrame->getVisual ();
+    else
+        return None;
+}
+
+//-----------------------------------------------------------------------------
+unsigned int CDrawContext::getDepth ()
+{
+    if (pFrame)
+        return pFrame->getDepth ();
+    else
+        return None;
+}
+
+
+//-----------------------------------------------------------------------------
+// COffscreenContext Implementation
+//-----------------------------------------------------------------------------
+COffscreenContext::COffscreenContext (CDrawContext *pContext, CBitmap *pBitmapBg, bool drawInBitmap)
+: CDrawContext (pContext->pFrame, NULL, NULL)
+, pBitmap (0)
+, pBitmapBg (pBitmapBg)
+, height (20)
+, width (20)
+{
+    std::cout << "COffscreenContext::COffscreenContext with bitmap" << std::endl;
+
+    if (pBitmapBg)
+    {
+        height = pBitmapBg->getHeight ();
+        width  = pBitmapBg->getWidth ();
+
+        clipRect (0, 0, width, height);
+    }
+
+#if DEBUG
+    gNbCOffscreenContext++;
+    gBitmapAllocation += (long)height * (long)width;
+#endif
+
+    bDestroyPixmap = false;
+
+//    Window root = RootWindow (display, DefaultScreen (display));
+
+     // if no bitmap handle => create one
+    if (! pWindow)
+    {
+        pWindow = (void*) XCreatePixmap (display, pFrame->getWindow(), width, height, pFrame->getDepth ());
+        bDestroyPixmap = true;
+    }
+
+    // set the current font
+    if (pSystemContext)
+        setFont (kNormalFont);
+
+    if (!drawInBitmap)
+    {
+        // draw bitmap to Offscreen
+        CRect r (0, 0, width, height);
+        if (pBitmapBg)
+            pBitmapBg->draw (this, r);
+        else
+        {
+            setFillColor (kBlackCColor);
+            fillRect (r);
+        }
+    }
+}
+
+//-----------------------------------------------------------------------------
+COffscreenContext::COffscreenContext (CFrame *pFrame, long width, long height, const CColor backgroundColor)
+: CDrawContext (pFrame, NULL, NULL)
+, pBitmap (0)
+, pBitmapBg (0)
+, height (height)
+, width (width)
+, backgroundColor (backgroundColor)
+{
+    std::cout << "COffscreenContext::COffscreenContext without bitmap" << std::endl;
+
+    clipRect (0, 0, width, height);
+
+#if DEBUG
+    gNbCOffscreenContext++;
+    gBitmapAllocation += height * width;
+#endif
+
+    bDestroyPixmap = true;
+
+    pWindow = (void*) XCreatePixmap (display,
+                                     pFrame->getWindow(),
+                                     width,
+                                     height,
+                                     pFrame->getDepth ());
+
+/*
+    // clear the pixmap
+    XGCValues values;
+    values.foreground = getIndexColor (backgroundColor);
+    GC gc = XCreateGC (display, (Window)pWindow, GCForeground, &values);
+    XFillRectangle (display, (Window)pWindow, gc, 0, 0, width, height);
+    XFreeGC (display, gc);
+*/
+
+    XGCValues values;
+    values.foreground = getIndexColor (backgroundColor);
+    pSystemContext = XCreateGC (display, (Window)pWindow, GCForeground, &values);
+    XFillRectangle (display, (Window)pWindow, (GC) pSystemContext, 0, 0, width, height);
+
+    // set the current font
+    if (pSystemContext)
+        setFont (kNormalFont);
+}
+
+//-----------------------------------------------------------------------------
+COffscreenContext::~COffscreenContext ()
+{
+#if DEBUG
+    gNbCOffscreenContext--;
+    gBitmapAllocation -= (long)height * (long)width;
+#endif
+
+    if (pBitmap)
+        pBitmap->forget ();
+
+    if (bDestroyPixmap && pWindow)
+        XFreePixmap (display, (Pixmap)pWindow);
+
+    if (pSystemContext)
+        XFreeGC (display, (GC) pSystemContext);
+}
+
+//-----------------------------------------------------------------------------
+void COffscreenContext::copyTo (CDrawContext* pContext, CRect& srcRect, CPoint destOffset)
+{
+    std::cout << "COffscreenContext::copyTo" << std::endl;
+
+    XCopyArea (display,
+               (Drawable) pContext->pWindow,
+               (Drawable) pWindow,
+               (GC) pSystemContext,
+               srcRect.left,
+               srcRect.top,
+               srcRect.width (),
+               srcRect.height (),
+               destOffset.h,
+               destOffset.v);
+}
+
+//-----------------------------------------------------------------------------
+void COffscreenContext::copyFrom (CDrawContext *pContext, CRect destRect, CPoint srcOffset)
+{
+    //std::cout << "COffscreenContext::copyFrom ";
+
+    XCopyArea (display,
+               (Drawable) pContext->pWindow,
+               (Drawable) pWindow,
+               (GC) pSystemContext,
+               srcOffset.h,
+               srcOffset.v,
+               destRect.width(),
+               destRect.height(),
+               destRect.left,
+               destRect.top);
+
+    pContext->setFrameColor (kRedCColor);
+    pContext->drawRect (destRect);
+}
+
+
+//-----------------------------------------------------------------------------
+class CAttributeListEntry
+{
+public:
+    CAttributeListEntry (long size, CViewAttributeID id)
+    : nextEntry (0)
+    , pointer (0)
+    , sizeOfPointer (size)
+    , id (id)
+    {
+        pointer = malloc (size);
+    }
+
+    ~CAttributeListEntry ()
+    {
+        if (pointer)
+            free (pointer);
+    }
+
+    CViewAttributeID getID () const { return id; }
+    long getSize () const { return sizeOfPointer; }
+    void* getPointer () const { return pointer; }
+    CAttributeListEntry* getNext () const { return nextEntry; }
+
+    void setNext (CAttributeListEntry* entry) { nextEntry = entry; }
+
+protected:
+    CAttributeListEntry () : nextEntry (0), pointer (0), sizeOfPointer (0), id (0) {}
+
+    CAttributeListEntry* nextEntry;
+    void* pointer;
+    long sizeOfPointer;
+    CViewAttributeID id;
+};
+
+//-----------------------------------------------------------------------------
+const char* kMsgCheckIfViewContainer    = "kMsgCheckIfViewContainer";
+
+//-----------------------------------------------------------------------------
+// CView
+//-----------------------------------------------------------------------------
+/*! @class CView
+base class of all view objects
+*/
+//-----------------------------------------------------------------------------
+CView::CView (const CRect& size)
+: size (size)
+, mouseableArea (size)
+, pParentFrame (0)
+, pParentView (0)
+, bDirty (false)
+, bMouseEnabled (true)
+, bTransparencyEnabled (false)
+, bWantsFocus (false)
+, bVisible (true)
+, pBackground (0)
+, pAttributeList (0)
+{
+#if DEBUG
+    gNbCView++;
+#endif
+}
+
+//-----------------------------------------------------------------------------
+CView::~CView ()
+{
+    if (pBackground)
+        pBackground->forget ();
+
+    if (pAttributeList)
+    {
+        CAttributeListEntry* entry = pAttributeList;
+        while (entry)
+        {
+            CAttributeListEntry* nextEntry = entry->getNext ();
+            delete entry;
+            entry = nextEntry;
+        }
+    }
+#if DEBUG
+    gNbCView--;
+#endif
+}
+
+//-----------------------------------------------------------------------------
+void CView::getMouseLocation (CDrawContext* context, CPoint &point)
+{
+    if (context)
+    {
+        if (pParentView && pParentView->notify (this, kMsgCheckIfViewContainer) == kMessageNotified)
+        {
+            CCoord save[4];
+            ((CViewContainer*)pParentView)->modifyDrawContext (save, context);
+            pParentView->getMouseLocation (context, point);
+            ((CViewContainer*)pParentView)->restoreDrawContext (context, save);
+        }
+        else
+            context->getMouseLocation (point);
+    }
+}
+
+//-----------------------------------------------------------------------------
+CPoint& CView::frameToLocal (CPoint& point) const
+{
+    if (pParentView && pParentView->isTypeOf ("CViewContainer"))
+        return pParentView->frameToLocal (point);
+    return point;
+}
+
+//-----------------------------------------------------------------------------
+CPoint& CView::localToFrame (CPoint& point) const
+{
+    if (pParentView && pParentView->isTypeOf ("CViewContainer"))
+        return pParentView->localToFrame (point);
+    return point;
+}
+
+//-----------------------------------------------------------------------------
+void CView::redraw ()
+{
+    if (pParentFrame)
+        pParentFrame->draw (this);
+}
+
+//-----------------------------------------------------------------------------
+void CView::redrawRect (CDrawContext* context, const CRect& rect)
+{
+    if (pParentView)
+        pParentView->redrawRect (context, rect);
+    else if (pParentFrame)
+        pParentFrame->drawRect (context, rect);
+}
+
+//-----------------------------------------------------------------------------
+void CView::draw (CDrawContext *pContext)
+{
+    if (pBackground)
+    {
+        if (bTransparencyEnabled)
+            pBackground->drawTransparent (pContext, size);
+        else
+            pBackground->draw (pContext, size);
+    }
+    setDirty (false);
+}
+
+//-----------------------------------------------------------------------------
+void CView::mouse (CDrawContext *pContext, CPoint &where, long buttons)
+{}
+
+//-----------------------------------------------------------------------------
+bool CView::onWheel (CDrawContext *pContext, const CPoint &where, float distance)
+{
+    return false;
+}
+
+//------------------------------------------------------------------------
+bool CView::onWheel (CDrawContext *pContext, const CPoint &where, const CMouseWheelAxis axis, float distance)
+{
+    return onWheel (pContext, where, distance);
+}
+
+//------------------------------------------------------------------------
+void CView::update (CDrawContext *pContext)
+{
+    if (isDirty ())
+    {
+#if NEW_UPDATE_MECHANISM
+        if (pContext)
+            redrawRect (pContext, size);
+        else
+            redraw ();
+#else
+    #if USE_ALPHA_BLEND
+        if (pContext)
+        {
+            if (bTransparencyEnabled)
+                getFrame ()->drawRect (pContext, size);
+            else
+                draw (pContext);
+        }
+    #else
+        if (pContext)
+            draw (pContext);
+    #endif
+        else
+            redraw ();
+#endif
+        setDirty (false);
+    }
+}
+
+//------------------------------------------------------------------------------
+long CView::onKeyDown (VstKeyCode& keyCode)
+{
+    return -1;
+}
+
+//------------------------------------------------------------------------------
+long CView::onKeyUp (VstKeyCode& keyCode)
+{
+    return -1;
+}
+
+//------------------------------------------------------------------------------
+long CView::notify (CView* sender, const char* message)
+{
+    return kMessageUnknown;
+}
+
+//------------------------------------------------------------------------------
+void CView::looseFocus (CDrawContext *pContext)
+{}
+
+//------------------------------------------------------------------------------
+void CView::takeFocus (CDrawContext *pContext)
+{}
+
+//------------------------------------------------------------------------------
+void CView::setViewSize (CRect &rect)
+{
+    size = rect;
+    setDirty ();
+}
+
+//-----------------------------------------------------------------------------
+void *CView::getEditor () const
+{
+    return pParentFrame ? pParentFrame->getEditor () : 0;
+}
+
+//-----------------------------------------------------------------------------
+void CView::setBackground (CBitmap *background)
+{
+    if (pBackground)
+        pBackground->forget ();
+    pBackground = background;
+    if (pBackground)
+        pBackground->remember ();
+    setDirty (true);
+}
+
+//-----------------------------------------------------------------------------
+const CViewAttributeID kCViewAttributeReferencePointer = (CViewAttributeID) "cvrp";
+
+//-----------------------------------------------------------------------------
+/**
+ * @param id the ID of the Attribute
+ * @param outSize on return the size of the attribute
+ */
+bool CView::getAttributeSize (const CViewAttributeID id, long& outSize) const
+{
+    if (pAttributeList)
+    {
+        CAttributeListEntry* entry = pAttributeList;
+        while (entry)
+        {
+            if (entry->getID () == id)
+                break;
+            entry = entry->getNext ();
+        }
+        if (entry)
+        {
+            outSize = entry->getSize ();
+            return true;
+        }
+    }
+    return false;
+}
+
+//-----------------------------------------------------------------------------
+/**
+ * @param id the ID of the Attribute
+ * @param inSize the size of the outData pointer
+ * @param outData a pointer where to copy the attribute data
+ * @param outSize the size in bytes which was copied into outData
+ */
+bool CView::getAttribute (const CViewAttributeID id, const long inSize, void* outData, long& outSize) const
+{
+    if (pAttributeList)
+    {
+        CAttributeListEntry* entry = pAttributeList;
+        while (entry)
+        {
+            if (entry->getID () == id)
+                break;
+            entry = entry->getNext ();
+        }
+        if (entry && inSize >= entry->getSize ())
+        {
+            outSize = entry->getSize ();
+            memcpy (outData, entry->getPointer (), outSize);
+            return true;
+        }
+    }
+    return false;
+}
+
+//-----------------------------------------------------------------------------
+/**
+ * copies data into the attribute. If it does not exist, creates a new attribute.
+ * @param id the ID of the Attribute
+ * @param inSize the size of the outData pointer
+ * @param inData a pointer to the data
+ */
+bool CView::setAttribute (const CViewAttributeID id, const long inSize, void* inData)
+{
+    CAttributeListEntry* lastEntry = 0;
+    if (pAttributeList)
+    {
+        CAttributeListEntry* entry = pAttributeList;
+        while (entry)
+        {
+            if (entry->getID () == id)
+                break;
+            if (entry->getNext () == 0)
+                lastEntry = entry;
+            entry = entry->getNext ();
+        }
+        if (entry)
+        {
+            if (entry->getSize () >= inSize)
+            {
+                memcpy (entry->getPointer (), inData, inSize);
+                return true;
+            }
+            else
+                return false;
+        }
+    }
+
+    // create a new attribute
+    CAttributeListEntry* newEntry = new CAttributeListEntry (inSize, id);
+    memcpy (newEntry->getPointer (), inData, inSize);
+    if (lastEntry)
+        lastEntry->setNext (newEntry);
+    else if (!pAttributeList)
+        pAttributeList = newEntry;
+    else
+    {
+        delete newEntry;
+        return false;
+    }
+    return true;
+}
+
+#if DEBUG
+//-----------------------------------------------------------------------------
+void CView::dumpInfo ()
+{
+    CRect viewRect = getViewSize (viewRect);
+    DebugPrint ("left:%4d, top:%4d, width:%4d, height:%4d ", viewRect.left, viewRect.top, viewRect.getWidth (), viewRect.getHeight ());
+    if (getMouseEnabled ())
+        DebugPrint ("(Mouse Enabled) ");
+    if (getTransparency ())
+        DebugPrint ("(Transparent) ");
+    CRect mouseRect = getMouseableArea (mouseRect);
+    if (mouseRect != viewRect)
+        DebugPrint (" (Mouseable Area: left:%4d, top:%4d, width:%4d, height:%4d ", mouseRect.left, mouseRect.top, mouseRect.getWidth (), mouseRect.getHeight ());
+}
+#endif
+
+#define FOREACHSUBVIEW for (CCView *pSv = pFirstView; pSv; pSv = pSv->pNext) {CView *pV = pSv->pView;
+#define FOREACHSUBVIEW_REVERSE(reverse) for (CCView *pSv = reverse ? pLastView : pFirstView; pSv; pSv = reverse ? pSv->pPrevious : pSv->pNext) {CView *pV = pSv->pView;
+#define ENDFOR }
+
+//-----------------------------------------------------------------------------
+// CFrame Implementation
+//-----------------------------------------------------------------------------
+/*! @class CFrame
+It creates a platform dependend view object.
+On classic Mac OS it just draws into the provided window.
+On Mac OS X it is a ControlRef.
+On Windows it's a WS_CHILD Window.
+*/
+CFrame::CFrame (const CRect &inSize, void *inSystemWindow, void *inEditor)
+: CViewContainer (inSize, 0, 0)
+, pEditor (inEditor)
+, pModalView (0)
+, pFocusView (0)
+, bFirstDraw (true)
+, bDropActive (false)
+, bUpdatesDisabled (false)
+, pSystemWindow ((Window)inSystemWindow)
+, pFrameContext (0)
+, bAddedWindow (false)
+, defaultCursor (0)
+{
+    setOpenFlag (true);
+
+    pParentFrame = this;
+
+    depth    = 0;
+    pVisual  = 0;
+    window   = 0;
+	gc       = 0;
+	
+	if (display == NULL)
+		display = XOpenDisplay(NULL);
+
+	initFrame ((void*)pSystemWindow);
+	backBuffer = XdbeAllocateBackBufferName(display, (Window)window, XdbeUndefined);
+
+	XGCValues values;
+	values.foreground = 1;
+	gc = XCreateGC (display, (Window)backBuffer, GCForeground, &values);
+
+    pFrameContext = new CDrawContext (this, gc, (void*)backBuffer);
+}
+
+//-----------------------------------------------------------------------------
+CFrame::~CFrame ()
+{
+    if (pModalView)
+        removeView (pModalView, false);
+
+    setCursor (kCursorDefault);
+
+    setDropActive (false);
+
+    if (pFrameContext)
+        pFrameContext->forget ();
+
+    if (getOpenFlag ())
+        close ();
+
+    if (window)
+        XDestroyWindow (display, (Window) window);
+    window = 0;
+
+    // remove callbacks to avoid undesirable update
+    if (gc)
+        freeGc ();
+}
+
+//-----------------------------------------------------------------------------
+bool CFrame::open ()
+{
+    if (! window)
+        return false;
+
+    XMapRaised (display, window);
+
+    return getOpenFlag ();
+}
+
+//-----------------------------------------------------------------------------
+bool CFrame::close ()
+{
+    if (!window || !getOpenFlag () || !pSystemWindow)
+        return false;
+
+    XUnmapWindow (display, window);
+
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+bool xerror;
+int errorHandler (Display *dp, XErrorEvent *e)
+{
+    xerror = true;
+	return 0;
+}
+int getProperty (Window handle, Atom atom)
+{
+    int result = 0, userSize;
+    unsigned long bytes, userCount;
+    unsigned char *data;
+    Atom userType;
+    xerror = false;
+    XErrorHandler olderrorhandler = XSetErrorHandler (errorHandler);
+    XGetWindowProperty (display, handle, atom, 0, 1, false, AnyPropertyType,
+                        &userType,  &userSize, &userCount, &bytes, &data);
+    if (xerror == false && userCount == 1)
+        result = *(int*)data;
+    XSetErrorHandler (olderrorhandler);
+    return result;
+}
+
+void eventProc (XEvent* ev)
+{
+    CFrame* frame = (CFrame*) getProperty (ev->xany.window, XInternAtom (display, "_this", false));
+    if (frame == 0)
+        return;
+
+    switch (ev->type)
+    {
+        case ButtonPress:
+        {
+            CPoint where (ev->xbutton.x, ev->xbutton.y);
+            frame->mouse (frame->createDrawContext(), where);
+            break;
+        }
+
+        case MotionNotify:
+        {
+            CPoint where (ev->xbutton.x, ev->xbutton.y);
+            frame->mouse (frame->createDrawContext(), where);
+            break;
+        }
+
+        case ButtonRelease:
+        {
+            break;
+        }
+
+        case Expose:
+        {
+            CRect rc (ev->xexpose.x, ev->xexpose.y,
+                      ev->xexpose.x + ev->xexpose.width, ev->xexpose.y + ev->xexpose.height);
+
+            while (XCheckTypedWindowEvent (display, ev->xexpose.window, Expose, ev))
+            {
+                rc.left = std::min ((int) rc.left, ev->xexpose.x);
+                rc.top = std::min ((int) rc.top, ev->xexpose.y);
+                rc.right = std::max ((int) rc.right, ev->xexpose.x + ev->xexpose.width);
+                rc.bottom = std::max ((int) rc.bottom, ev->xexpose.y + ev->xexpose.height);
+            }
+
+            frame->drawRect (0, rc);
+            break;
+        }
+
+        case EnterNotify:
+            break;
+
+        case LeaveNotify:
+        {
+            XCrossingEvent *xevent = (XCrossingEvent*) ev;
+            if (frame->getFocusView ())
+            {
+                if (xevent->x < 0 || xevent->x >= frame->getWidth ()
+                    || xevent->y < 0 || xevent->y >= frame->getHeight ())
+                {
+                    // if button pressed => don't defocus
+                    if (xevent->state & (Button1Mask | Button2Mask | Button3Mask))
+                        break;
+
+                    frame->getFocusView ()->looseFocus ();
+                    frame->setFocusView (0);
+                }
+            }
+            break;
+        }
+
+        case ConfigureNotify:
+        {
+            frame->draw (); // @XXX - keep out ?
+            break;
+        }
+    }
+}
+
+//-----------------------------------------------------------------------------
+bool CFrame::initFrame (void *systemWin)
+{
+    if (!systemWin)
+        return false;
+
+    // window attributes
+    XSetWindowAttributes swa;
+    swa.override_redirect = false;
+    swa.background_pixmap = None;
+    swa.colormap = 0;
+    swa.event_mask =
+        StructureNotifyMask | ExposureMask | KeyPressMask | KeyReleaseMask |
+        ButtonPressMask | ButtonReleaseMask | FocusChangeMask | PointerMotionMask |
+        EnterWindowMask | LeaveWindowMask | PropertyChangeMask;
+
+	// create child window of host supplied window
+	window = XCreateWindow (display, (Window)systemWin,
+                            0, 0, size.width(), size.height(),
+                            0, CopyFromParent, InputOutput, (Visual*) CopyFromParent,
+                            CWEventMask | CWOverrideRedirect | CWColormap | CWBackPixmap | CWEventMask, &swa);
+
+    XGrabButton (display, AnyButton, AnyModifier, window, False,
+                    ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask,
+                    GrabModeAsync, GrabModeAsync, None, None);
+
+#if 0
+    // remove window caption/frame
+    #define MWM_HINTS_DECORATIONS (1L << 1)
+    #define PROP_MOTIF_WM_HINTS_ELEMENTS 5
+    typedef struct
+    {
+        unsigned long flags;
+        unsigned long functions;
+        unsigned long decorations;
+        long          inputMode;
+        unsigned long status;
+    }
+    PropMotifWmHints;
+
+    PropMotifWmHints motif_hints;
+    motif_hints.flags = MWM_HINTS_DECORATIONS;
+    motif_hints.decorations = 0;
+    Atom prop = XInternAtom (display, "_MOTIF_WM_HINTS", True );
+    XChangeProperty (display, window, prop, prop, 32, PropModeReplace,
+                     (unsigned char *) &motif_hints, PROP_MOTIF_WM_HINTS_ELEMENTS);
+#endif
+
+    Atom atom;
+    void* data = this;
+    atom = XInternAtom (display, "_this", false);
+    XChangeProperty (display, (Window)window, atom, atom, 32,
+                     PropModeReplace, (unsigned char*)&data, 1);
+
+    data = (void*)&eventProc;
+    atom = XInternAtom (display, "_XEventProc", false);
+    XChangeProperty (display, (Window)window, atom, atom, 32,
+                     PropModeReplace, (unsigned char*)&data, 1);
+	
+    XGCValues values;
+    values.foreground = 1;
+    gc = XCreateGC (display, (Window)window, GCForeground, &values);
+	
+    // get the std colormap
+    XWindowAttributes attr;
+    XGetWindowAttributes (display, (Window) window, &attr);
+    colormap = attr.colormap;
+    pVisual  = attr.visual;
+    depth    = attr.depth;
+	
+    // init and load the fonts
+    if (! gFontInit) {
+        for (long i = 0; i < kNumStandardFonts; i++) {
+            DBG (gFontTable[i].string);
+            gFontStructs[i] = XLoadQueryFont (display, gFontTable[i].string);
+            assert (gFontStructs[i] != 0);
+        }
+        gFontInit = true;
+    }
+
+    setDropActive (true);
+    bAddedWindow = true;
+
+    //XReparentWindow (display, window, (Window) systemWin, 0, 0);
+    //XMapRaised (display, window);
+
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+bool CFrame::setDropActive (bool val)
+{
+    if (!bDropActive && !val)
+        return true;
+
+    bDropActive = val;
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+void CFrame::freeGc ()
+{
+	XFreeGC (display, gc);
+}
+
+//-----------------------------------------------------------------------------
+CDrawContext* CFrame::createDrawContext ()
+{
+    if (pFrameContext)
+    {
+        pFrameContext->remember ();
+        return pFrameContext;
+    }
+
+    pFrameContext = new CDrawContext (this, gc, (void*)window);
+
+    return pFrameContext;
+}
+
+//-----------------------------------------------------------------------------
+void CFrame::draw (CDrawContext *pContext)
+{
+    if (bFirstDraw)
+        bFirstDraw = false;
+
+    bool localContext = false;
+    if (! pContext)
+    {
+        localContext = true;
+        pContext = createDrawContext ();
+    }
+
+    // draw the background and the children
+    CViewContainer::draw (pContext);
+
+    if (localContext)
+        pContext->forget ();
+}
+
+//-----------------------------------------------------------------------------
+void CFrame::drawRect (CDrawContext *pContext, const CRect& updateRect)
+{
+    if (bFirstDraw)
+        bFirstDraw = false;
+
+    bool localContext = false;
+    if (! pContext)
+    {
+        localContext = true;
+        pContext = createDrawContext ();
+    }
+
+#if USE_CLIPPING_DRAWRECT
+    CRect oldClip;
+    pContext->getClipRect (oldClip);
+    CRect newClip (updateRect);
+    newClip.bound (oldClip);
+    pContext->setClipRect (newClip);
+#endif
+
+    // draw the background and the children
+    if (updateRect.getWidth () > 0 && updateRect.getHeight () > 0)
+        CViewContainer::drawRect (pContext, updateRect);
+
+#if USE_CLIPPING_DRAWRECT
+    pContext->setClipRect (oldClip);
+#endif
+
+    if (localContext)
+        pContext->forget ();
+}
+
+//-----------------------------------------------------------------------------
+void CFrame::draw (CView *pView)
+{
+    CView *pViewToDraw = 0;
+
+        // Search it in the view list
+    if (pView && isChild(pView))
+        pViewToDraw = pView;
+
+    CDrawContext *pContext = createDrawContext ();
+    if (pContext)
+    {
+        if (pViewToDraw && pViewToDraw->isVisible())
+            pViewToDraw->draw (pContext);
+        else
+            draw (pContext);
+
+        pContext->forget ();
+    }
+}
+
+//-----------------------------------------------------------------------------
+void CFrame::mouse (CDrawContext *pContext, CPoint &where, long buttons)
+{
+/*
+    XGrabPointer (display,
+                  window,
+                  False,
+                  ButtonPressMask | ButtonReleaseMask |
+                  EnterWindowMask | LeaveWindowMask |
+                  PointerMotionMask | Button1MotionMask |
+                  Button2MotionMask | Button3MotionMask |
+                  Button4MotionMask | Button5MotionMask,
+                  GrabModeAsync,
+                  GrabModeAsync,
+                  None,
+                  None,
+                  CurrentTime);
+*/
+
+    if (!pContext)
+        pContext = pFrameContext;
+
+    if (pFocusView)
+        setFocusView (NULL);
+
+    if (buttons == -1 && pContext)
+        buttons = pContext->getMouseButtons ();
+
+    if (pModalView && pModalView->isVisible())
+    {
+        if (pModalView->hitTest (where, buttons))
+            pModalView->mouse (pContext, where, buttons);
+    }
+    else
+    {
+        CViewContainer::mouse (pContext, where, buttons);
+    }
+
+//    XUngrabPointer (display, CurrentTime);
+}
+
+//-----------------------------------------------------------------------------
+long CFrame::onKeyDown (VstKeyCode& keyCode)
+{
+    long result = -1;
+
+    if (pFocusView && pFocusView->isVisible())
+        result = pFocusView->onKeyDown (keyCode);
+
+    if (result == -1 && pModalView && pModalView->isVisible())
+        result = pModalView->onKeyDown (keyCode);
+
+    if (result == -1 && keyCode.virt == VKEY_TAB)
+        result = advanceNextFocusView (pFocusView, (keyCode.modifier & MODIFIER_SHIFT) ? true : false) ? 1 : -1;
+
+    return result;
+}
+
+//-----------------------------------------------------------------------------
+long CFrame::onKeyUp (VstKeyCode& keyCode)
+{
+    long result = -1;
+
+    if (pFocusView && pFocusView->isVisible())
+        result = pFocusView->onKeyUp (keyCode);
+
+    if (result == -1 && pModalView && pModalView->isVisible())
+        result = pModalView->onKeyUp (keyCode);
+
+    return result;
+}
+
+//------------------------------------------------------------------------
+bool CFrame::onWheel (CDrawContext *pContext, const CPoint &where, const CMouseWheelAxis axis, float distance)
+{
+    bool result = false;
+
+    CView *view = pModalView ? pModalView : getViewAt (where);
+    if (view && view->isVisible())
+    {
+        bool localContext = false;
+        if (!pContext)
+        {
+            localContext = true;
+            pContext = createDrawContext ();
+        }
+
+        result = view->onWheel (pContext, where, axis, distance);
+
+        if (localContext)
+            pContext->forget ();
+    }
+    return result;
+}
+
+//-----------------------------------------------------------------------------
+bool CFrame::onWheel (CDrawContext *pContext, const CPoint &where, float distance)
+{
+    return onWheel (pContext, where, kMouseWheelAxisY, distance);
+}
+
+//-----------------------------------------------------------------------------
+void CFrame::update (CDrawContext *pContext)
+{
+    if (!getOpenFlag () || updatesDisabled ())
+        return;
+
+    CDrawContext* dc = pContext;
+
+    if (bDirty)
+    {
+        draw (dc);
+        setDirty (false);
+    }
+    else
+    {
+#if USE_CLIPPING_DRAWRECT
+        CRect oldClipRect;
+        dc->getClipRect (oldClipRect);
+#endif
+#if NEW_UPDATE_MECHANISM
+        if (pModalView && pModalView->isVisible () && pModalView->isDirty ())
+            pModalView->update (dc);
+#endif
+        FOREACHSUBVIEW
+#if USE_CLIPPING_DRAWRECT
+            CRect viewSize (pV->size);
+            viewSize.bound (oldClipRect);
+            dc->setClipRect (viewSize);
+#endif
+            pV->update (dc);
+        ENDFOR
+#if USE_CLIPPING_DRAWRECT
+        dc->setClipRect (oldClipRect);
+#endif
+    }
+}
+
+//-----------------------------------------------------------------------------
+void CFrame::idle ()
+{
+    if (!getOpenFlag ())
+        return;
+
+    // don't do an idle before a draw
+    if (bFirstDraw)
+        return;
+
+    if (!isDirty ())
+        return;
+	
+	XdbeBeginIdiom(display);
+	XdbeSwapInfo swap_info;
+	swap_info.swap_window = window;
+	swap_info.swap_action = XdbeUndefined;
+	XdbeSwapBuffers(display, &swap_info, 1);
+
+    CDrawContext *pContext = createDrawContext ();
+
+    update (pContext);
+
+    pContext->forget ();
+	
+	XdbeEndIdiom(display);
+}
+
+//-----------------------------------------------------------------------------
+void CFrame::doIdleStuff ()
+{
+    if (pEditor)
+        ((AEffGUIEditor*)pEditor)->doIdleStuff ();
+}
+
+//-----------------------------------------------------------------------------
+unsigned long CFrame::getTicks () const
+{
+    if (pEditor)
+        return ((AEffGUIEditor*)pEditor)->getTicks ();
+    return 0;
+}
+
+//-----------------------------------------------------------------------------
+long CFrame::getKnobMode () const
+{
+    return AEffGUIEditor::getKnobMode ();
+}
+
+//-----------------------------------------------------------------------------
+bool CFrame::setPosition (CCoord x, CCoord y)
+{
+    size.left = 0;
+    size.top = 0;
+
+    XWindowChanges attr;
+    attr.x = x;
+    attr.y = y;
+
+    XConfigureWindow (display, window, CWX | CWY, &attr);
+
+    return false;
+}
+
+//-----------------------------------------------------------------------------
+bool CFrame::getPosition (CCoord &x, CCoord &y) const
+{
+    x = size.left;
+    y = size.top;
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+void CFrame::setViewSize (CRect& inRect)
+{
+    setSize (inRect.width (), inRect.height ());
+}
+
+//-----------------------------------------------------------------------------
+bool CFrame::setSize (CCoord width, CCoord height)
+{
+    if ((width == size.width ()) && (height == size.height ()))
+        return false;
+
+    // set the new size
+    size.right  = size.left + width;
+    size.bottom = size.top  + height;
+
+    XResizeWindow (display, window, size.width (), size.height ());
+
+    CRect myViewSize (0, 0, size.width (), size.height ());
+    CViewContainer::setViewSize (myViewSize);
+
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+bool CFrame::getSize (CRect *pRect) const
+{
+//    if (!getOpenFlag ())
+//        return false;
+
+    pRect->left   = 0;
+    pRect->top    = 0;
+    pRect->right  = size.width () + pRect->left;
+    pRect->bottom = size.height () + pRect->top;
+
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+bool CFrame::getSize (CRect& outSize) const
+{
+    return getSize (&outSize);
+}
+
+//-----------------------------------------------------------------------------
+long CFrame::setModalView (CView *pView)
+{
+    // There's already a modal view so we get out
+    if (pView && pModalView)
+        return 0;
+
+    if (pModalView)
+        removeView (pModalView, false);
+
+    pModalView = pView;
+    if (pModalView)
+        addView (pModalView);
+
+    return 1;
+}
+
+//-----------------------------------------------------------------------------
+void CFrame::beginEdit (long index)
+{
+    if (pEditor)
+        ((AEffGUIEditor*)pEditor)->beginEdit (index);
+}
+
+//-----------------------------------------------------------------------------
+void CFrame::endEdit (long index)
+{
+    if (pEditor)
+        ((AEffGUIEditor*)pEditor)->endEdit (index);
+}
+
+//-----------------------------------------------------------------------------
+CView *CFrame::getCurrentView () const
+{
+    if (pModalView)
+        return pModalView;
+
+    return CViewContainer::getCurrentView ();
+}
+
+//-----------------------------------------------------------------------------
+bool CFrame::getCurrentLocation (CPoint &where)
+{
+    // create a local context
+    CDrawContext *pContext = createDrawContext ();
+    if (pContext)
+    {
+    // get the current position
+        pContext->getMouseLocation (where);
+        pContext->forget ();
+    }
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+void CFrame::setCursor (CCursorType type)
+{
+}
+
+//-----------------------------------------------------------------------------
+void CFrame::setFocusView (CView *pView)
+{
+    if (pView && ! pView->isVisible())
+        return;
+
+    CView *pOldFocusView = pFocusView;
+    pFocusView = pView;
+
+    if (pFocusView && pFocusView->wantsFocus ())
+        pFocusView->setDirty ();
+
+    if (pOldFocusView)
+    {
+        pOldFocusView->looseFocus ();
+        if (pOldFocusView->wantsFocus ())
+            pOldFocusView->setDirty ();
+    }
+}
+
+//-----------------------------------------------------------------------------
+bool CFrame::advanceNextFocusView (CView* oldFocus, bool reverse)
+{
+    if (pModalView)
+        return false; // currently not supported, but should be done sometime
+    if (oldFocus == 0)
+    {
+        if (pFocusView == 0)
+            return CViewContainer::advanceNextFocusView (0, reverse);
+        oldFocus = pFocusView;
+    }
+    if (isChild (oldFocus))
+    {
+        if (CViewContainer::advanceNextFocusView (oldFocus, reverse))
+            return true;
+        else
+        {
+            setFocusView (NULL);
+            return false;
+        }
+    }
+    CView* parentView = oldFocus->getParentView ();
+    if (parentView && parentView->isTypeOf ("CViewContainer"))
+    {
+        CView* tempOldFocus = oldFocus;
+        CViewContainer* vc = (CViewContainer*)parentView;
+        while (vc)
+        {
+            if (vc->advanceNextFocusView (tempOldFocus, reverse))
+                return true;
+            else
+            {
+                tempOldFocus = vc;
+                if (vc->getParentView () && vc->getParentView ()->isTypeOf ("CViewContainer"))
+                    vc = (CViewContainer*)vc->getParentView ();
+                else
+                    vc = 0;
+            }
+        }
+    }
+    return CViewContainer::advanceNextFocusView (oldFocus, reverse);
+}
+
+//-----------------------------------------------------------------------------
+void CFrame::invalidate (const CRect &rect)
+{
+    CRect rectView;
+    FOREACHSUBVIEW
+    if (pV)
+    {
+        pV->getViewSize (rectView);
+        if (rect.rectOverlap (rectView))
+            pV->setDirty (true);
+    }
+    ENDFOR
+
+    XClearArea (display,
+                window,
+                rect.left,
+                rect.top,
+                rect.right - rect.left,
+                rect.bottom - rect.top,
+                true);
+
+    XSync (display, false);
+
+/*
+    XEvent ev;
+    memset (&ev, 0, sizeof (XEvent));
+    ev.xexpose.type = Expose;
+    ev.xexpose.display = display;
+    ev.xexpose.window = (Window) window;
+
+    ev.xexpose.x = rect.left;
+    ev.xexpose.y = rect.top;
+    ev.xexpose.width = rect.right - rect.left;
+    ev.xexpose.height = rect.bottom - rect.top;
+
+    XSendEvent (display, (Window) window, False, 0L, &ev);
+    XFlush (display);
+*/
+}
+
+#if DEBUG
+//-----------------------------------------------------------------------------
+void CFrame::dumpHierarchy ()
+{
+    dumpInfo ();
+    DebugPrint ("\n");
+    CViewContainer::dumpHierarchy ();
+}
+#endif
+
+//-----------------------------------------------------------------------------
+// CCView Implementation
+//-----------------------------------------------------------------------------
+CCView::CCView (CView *pView)
+ :  pView (pView), pNext (0), pPrevious (0)
+{
+    if (pView)
+        pView->remember ();
+}
+
+//-----------------------------------------------------------------------------
+CCView::~CCView ()
+{
+    if (pView)
+        pView->forget ();
+}
+
+//-----------------------------------------------------------------------------
+// CViewContainer Implementation
+//-----------------------------------------------------------------------------
+/**
+ * CViewContainer constructor.
+ * @param rect the size of the container
+ * @param pParent the parent CFrame
+ * @param pBackground the background bitmap, can be NULL
+ */
+CViewContainer::CViewContainer (const CRect &rect, CFrame *pParent, CBitmap *pBackground)
+  : CView (rect),
+    pFirstView (0),
+    pLastView (0),
+    mode (kNormalUpdate),
+    pOffscreenContext (0),
+    bDrawInOffscreen (false),
+    currentDragView (0)
+{
+    pParentFrame = pParent;
+
+    backgroundOffset (0, 0);
+
+    setBackground (pBackground);
+    backgroundColor = kBlackCColor;
+
+#if NEW_UPDATE_MECHANISM
+    mode = kOnlyDirtyUpdate;
+#endif
+}
+
+//-----------------------------------------------------------------------------
+CViewContainer::~CViewContainer ()
+{
+    // remove all views
+    removeAll (true);
+
+     if (pOffscreenContext)
+        pOffscreenContext->forget ();
+    pOffscreenContext = 0;
+}
+
+//-----------------------------------------------------------------------------
+/**
+ * @param rect the new size of the container
+ */
+void CViewContainer::setViewSize (CRect &rect)
+{
+    CView::setViewSize (rect);
+
+    if (pOffscreenContext && bDrawInOffscreen)
+    {
+        pOffscreenContext->forget ();
+        pOffscreenContext = new COffscreenContext (pParentFrame, (long)size.width (), (long)size.height (), kBlackCColor);
+    }
+}
+
+//-----------------------------------------------------------------------------
+/**
+ * @param color the new background color of the container
+ */
+void CViewContainer::setBackgroundColor (CColor color)
+{
+    backgroundColor = color;
+    setDirty (true);
+}
+
+//------------------------------------------------------------------------------
+long CViewContainer::notify (CView* sender, const char* message)
+{
+    if (message == kMsgCheckIfViewContainer)
+        return kMessageNotified;
+    return kMessageUnknown;
+}
+
+//-----------------------------------------------------------------------------
+/**
+ * @param pView the view object to add to this container
+ */
+void CViewContainer::addView (CView *pView)
+{
+    if (!pView)
+        return;
+
+    CCView *pSv = new CCView (pView);
+
+    pView->pParentFrame = pParentFrame;
+    pView->pParentView = this;
+
+    CCView *pV = pFirstView;
+    if (!pV)
+    {
+        pLastView = pFirstView = pSv;
+    }
+    else
+    {
+        while (pV->pNext)
+            pV = pV->pNext;
+        pV->pNext = pSv;
+        pSv->pPrevious = pV;
+        pLastView = pSv;
+    }
+    pView->attached (this);
+    pView->setDirty ();
+}
+
+//-----------------------------------------------------------------------------
+/**
+ * @param pView the view object to add to this container
+ * @param mouseableArea the view area in where the view will get mouse events
+ * @param mouseEnabled bool to set if view will get mouse events
+ */
+void CViewContainer::addView (CView *pView, CRect &mouseableArea, bool mouseEnabled)
+{
+    if (!pView)
+        return;
+
+    pView->setMouseEnabled (mouseEnabled);
+    pView->setMouseableArea (mouseableArea);
+
+    addView (pView);
+}
+
+//-----------------------------------------------------------------------------
+/**
+ * @param withForget bool to indicate if the view's reference counter should be decreased after removed from the container
+ */
+void CViewContainer::removeAll (const bool &withForget)
+{
+    CCView *pV = pFirstView;
+    while (pV)
+    {
+        CCView *pNext = pV->pNext;
+        if (pV->pView)
+        {
+            pV->pView->removed (this);
+            if (withForget)
+                pV->pView->forget ();
+        }
+
+        delete pV;
+
+        pV = pNext;
+    }
+    pFirstView = 0;
+    pLastView = 0;
+}
+
+//-----------------------------------------------------------------------------
+/**
+ * @param pView the view which should be removed from the container
+ * @param withForget bool to indicate if the view's reference counter should be decreased after removed from the container
+ */
+void CViewContainer::removeView (CView *pView, const bool &withForget)
+{
+    if (pParentFrame && pParentFrame->getFocusView () == pView)
+        pParentFrame->setFocusView (0);
+    CCView *pV = pFirstView;
+    while (pV)
+    {
+        if (pView == pV->pView)
+        {
+            CCView *pNext = pV->pNext;
+            CCView *pPrevious = pV->pPrevious;
+            if (pV->pView)
+            {
+                pV->pView->removed (this);
+                if (withForget)
+                    pV->pView->forget ();
+            }
+            delete pV;
+            if (pPrevious)
+            {
+                pPrevious->pNext = pNext;
+                if (pNext)
+                    pNext->pPrevious = pPrevious;
+                else
+                    pLastView = pPrevious;
+            }
+            else
+            {
+                pFirstView = pNext;
+                if (pNext)
+                    pNext->pPrevious = 0;
+                else
+                    pLastView = 0;
+            }
+            break;
+        }
+        else
+            pV = pV->pNext;
+    }
+}
+
+//-----------------------------------------------------------------------------
+/**
+ * @param pView the view which should be checked if it is a child of this container
+ */
+bool CViewContainer::isChild (CView *pView) const
+{
+    bool found = false;
+
+    CCView *pV = pFirstView;
+    while (pV)
+    {
+        if (pView == pV->pView)
+        {
+            found = true;
+            break;
+        }
+        pV = pV->pNext;
+    }
+    return found;
+}
+
+//-----------------------------------------------------------------------------
+long CViewContainer::getNbViews () const
+{
+    long nb = 0;
+    CCView *pV = pFirstView;
+    while (pV)
+    {
+        pV = pV->pNext;
+        nb++;
+    }
+    return nb;
+}
+
+//-----------------------------------------------------------------------------
+/**
+ * @param index the index of the view to return
+ */
+CView *CViewContainer::getView (long index) const
+{
+    long nb = 0;
+    CCView *pV = pFirstView;
+    while (pV)
+    {
+        if (nb == index)
+            return pV->pView;
+        pV = pV->pNext;
+        nb++;
+    }
+    return 0;
+}
+
+//-----------------------------------------------------------------------------
+/**
+ * @param pContext the context which to use to draw this container and its subviews
+ */
+void CViewContainer::draw (CDrawContext *pContext)
+{
+    CDrawContext *pC;
+    CCoord save[4];
+
+    if (!pOffscreenContext && bDrawInOffscreen)
+        pOffscreenContext = new COffscreenContext (pParentFrame, (long)size.width (), (long)size.height (), kBlackCColor);
+
+#if USE_ALPHA_BLEND
+    if (pOffscreenContext && bTransparencyEnabled)
+        pOffscreenContext->copyTo (pContext, size);
+#endif
+
+    if (bDrawInOffscreen)
+        pC = pOffscreenContext;
+    else
+    {
+        pC = pContext;
+        modifyDrawContext (save, pContext);
+    }
+
+    CRect r (0, 0, size.width (), size.height ());
+
+#if USE_CLIPPING_DRAWRECT
+    CRect oldClip;
+    pContext->getClipRect (oldClip);
+    CRect oldClip2 (oldClip);
+    if (bDrawInOffscreen && getFrame () != this)
+        oldClip.offset (-oldClip.left, -oldClip.top);
+
+    CRect newClip (r);
+    newClip.bound (oldClip);
+    pC->setClipRect (newClip);
+#endif
+
+    // draw the background
+    if (pBackground)
+    {
+        if (bTransparencyEnabled)
+            pBackground->drawTransparent (pC, r, backgroundOffset);
+        else
+            pBackground->draw (pC, r, backgroundOffset);
+    }
+    else if (!bTransparencyEnabled)
+    {
+        pC->setFillColor (backgroundColor);
+        pC->fillRect (r);
+    }
+
+    // draw each view
+    FOREACHSUBVIEW
+#if USE_CLIPPING_DRAWRECT
+        CRect vSize (pV->size);
+        vSize.bound (oldClip);
+        pC->setClipRect (vSize);
+#endif
+        if (pV->isVisible())
+            pV->draw (pC);
+    ENDFOR
+
+#if USE_CLIPPING_DRAWRECT
+    pC->setClipRect (oldClip2);
+#endif
+
+    // transfert offscreen
+    if (bDrawInOffscreen)
+        ((COffscreenContext*)pC)->copyFrom (pContext, size);
+    else
+        restoreDrawContext (pContext, save);
+
+    setDirty (false);
+}
+
+//-----------------------------------------------------------------------------
+/**
+ * @param pContext the context which to use to draw the background
+ * @param _updateRect the area which to draw
+ */
+void CViewContainer::drawBackgroundRect (CDrawContext *pContext, CRect& _updateRect)
+{
+    if (pBackground)
+    {
+        CRect oldClip;
+        pContext->getClipRect (oldClip);
+        CRect newClip (_updateRect);
+        newClip.bound (oldClip);
+        pContext->setClipRect (newClip);
+        CRect tr (0, 0, pBackground->getWidth (), pBackground->getHeight ());
+        if (bTransparencyEnabled)
+            pBackground->drawTransparent (pContext, tr, backgroundOffset);
+        else
+            pBackground->draw (pContext, tr, backgroundOffset);
+        pContext->setClipRect (oldClip);
+    }
+    else if (!bTransparencyEnabled)
+    {
+        pContext->setFillColor (backgroundColor);
+        pContext->fillRect (_updateRect);
+    }
+}
+
+//-----------------------------------------------------------------------------
+/**
+ * @param pContext the context which to use to draw
+ * @param _updateRect the area which to draw
+ */
+void CViewContainer::drawRect (CDrawContext *pContext, const CRect& _updateRect)
+{
+    CDrawContext *pC;
+    CCoord save[4];
+
+    if (!pOffscreenContext && bDrawInOffscreen)
+        pOffscreenContext = new COffscreenContext (pParentFrame, (long)size.width (), (long)size.height (), kBlackCColor);
+
+#if USE_ALPHA_BLEND
+    if (pOffscreenContext && bTransparencyEnabled)
+        pOffscreenContext->copyTo (pContext, size);
+#endif
+
+    if (bDrawInOffscreen)
+        pC = pOffscreenContext;
+    else
+    {
+        pC = pContext;
+        modifyDrawContext (save, pContext);
+    }
+
+    CRect updateRect (_updateRect);
+    updateRect.bound (size);
+
+    CRect clientRect (updateRect);
+    clientRect.offset (-size.left, -size.top);
+
+#if USE_CLIPPING_DRAWRECT
+    CRect oldClip;
+    pContext->getClipRect (oldClip);
+    CRect oldClip2 (oldClip);
+    if (bDrawInOffscreen && getFrame () != this)
+        oldClip.offset (-oldClip.left, -oldClip.top);
+
+    CRect newClip (clientRect);
+    newClip.bound (oldClip);
+    pC->setClipRect (newClip);
+#endif
+
+    // draw the background
+    drawBackgroundRect (pC, clientRect);
+
+    // draw each view
+    FOREACHSUBVIEW
+        if (pV->isVisible() && pV->checkUpdate (clientRect))
+        {
+#if USE_CLIPPING_DRAWRECT
+            CRect viewSize (pV->size);
+            viewSize.bound (newClip);
+            if (viewSize.getWidth () == 0 || viewSize.getHeight () == 0)
+                continue;
+            pC->setClipRect (viewSize);
+#endif
+
+            bool wasDirty = pV->isDirty ();
+            pV->drawRect (pC, clientRect);
+
+#if DEBUG_FOCUS_DRAWING
+            if (getFrame ()->getFocusView() == pV && pV->wantsFocus ())
+            {
+                pC->setDrawMode (kCopyMode);
+                pC->setFrameColor (kRedCColor);
+                pC->drawRect (pV->size);
+            }
+#endif
+            if (wasDirty && /* pV->size != viewSize &&*/ !isTypeOf ("CScrollContainer"))
+            {
+                pV->setDirty (true);
+            }
+        }
+    ENDFOR
+
+#if USE_CLIPPING_DRAWRECT
+    pC->setClipRect (oldClip2);
+#endif
+
+    // transfer offscreen
+    if (bDrawInOffscreen)
+        ((COffscreenContext*)pC)->copyFrom (pContext, updateRect, CPoint (clientRect.left, clientRect.top));
+    else
+        restoreDrawContext (pContext, save);
+
+#if EVENT_DRAW_FIX
+    if (bDirty && newClip == size)
+#endif
+        setDirty (false);
+}
+
+//-----------------------------------------------------------------------------
+/**
+ * @param context the context which to use to redraw this container
+ * @param rect the area which to redraw
+ */
+void CViewContainer::redrawRect (CDrawContext* context, const CRect& rect)
+{
+    CRect _rect (rect);
+    _rect.offset (size.left, size.top);
+    if (bTransparencyEnabled)
+    {
+        // as this is transparent, we call the parentview to redraw this area.
+        if (pParentView)
+            pParentView->redrawRect (context, _rect);
+        else if (pParentFrame)
+            pParentFrame->drawRect (context, _rect);
+    }
+    else
+    {
+        CCoord save[4];
+        if (pParentView)
+        {
+            CPoint off;
+            pParentView->localToFrame (off);
+            // store
+            save[0] = context->offsetScreen.h;
+            save[1] = context->offsetScreen.v;
+            save[2] = context->offset.h;
+            save[3] = context->offset.v;
+
+            context->offsetScreen.h += off.x;
+            context->offsetScreen.v += off.y;
+            context->offset.h += off.x;
+            context->offset.v += off.y;
+
+        	drawRect (context, _rect);
+            
+			// restore
+            context->offsetScreen.h = save[0];
+            context->offsetScreen.v = save[1];
+            context->offset.h = save[2];
+            context->offset.v = save[3];
+        }
+		else
+		{
+        	drawRect (context, _rect);
+		}
+    }
+}
+
+//-----------------------------------------------------------------------------
+bool CViewContainer::hitTestSubViews (const CPoint& where, const long buttons)
+{
+    CPoint where2 (where);
+    where2.offset (-size.left, -size.top);
+
+    CCView *pSv = pLastView;
+    while (pSv)
+    {
+        CView *pV = pSv->pView;
+        if (pV && pV->getMouseEnabled () && pV->hitTest (where2, buttons))
+            return true;
+        pSv = pSv->pPrevious;
+    }
+    return false;
+}
+
+//-----------------------------------------------------------------------------
+bool CViewContainer::hitTest (const CPoint& where, const long buttons)
+{
+    //return hitTestSubViews (where); would change default behavior
+    return CView::hitTest (where, buttons);
+}
+
+//-----------------------------------------------------------------------------
+void CViewContainer::mouse (CDrawContext *pContext, CPoint &where, long buttons)
+{
+    // convert to relativ pos
+    CPoint where2 (where);
+    where2.offset (-size.left, -size.top);
+
+    if (buttons == -1 && pContext)
+        buttons = pContext->getMouseButtons ();
+
+    CCView *pSv = pLastView;
+    while (pSv)
+    {
+        CView *pV = pSv->pView;
+        if (pV && pV->getMouseEnabled () && pV->hitTest (where2, buttons))
+        {
+            pV->mouse (pContext, where2, buttons);
+            break;
+        }
+        pSv = pSv->pPrevious;
+    }
+}
+
+//-----------------------------------------------------------------------------
+long CViewContainer::onKeyDown (VstKeyCode& keyCode)
+{
+    long result = -1;
+
+    CCView* pSv = pLastView;
+    while (pSv)
+    {
+        long result = pSv->pView->onKeyDown (keyCode);
+        if (result != -1)
+            break;
+
+        pSv = pSv->pPrevious;
+    }
+
+    return result;
+}
+
+//-----------------------------------------------------------------------------
+long CViewContainer::onKeyUp (VstKeyCode& keyCode)
+{
+    long result = -1;
+
+    CCView* pSv = pLastView;
+    while (pSv)
+    {
+        long result = pSv->pView->onKeyUp (keyCode);
+        if (result != -1)
+            break;
+
+        pSv = pSv->pPrevious;
+    }
+
+    return result;
+}
+
+//-----------------------------------------------------------------------------
+bool CViewContainer::onWheel (CDrawContext *pContext, const CPoint &where, const CMouseWheelAxis axis, float distance)
+{
+    bool result = false;
+    CView *view = getViewAt (where);
+    if (view)
+    {
+        // convert to relativ pos
+        CPoint where2 (where);
+        where2.offset (-size.left, -size.top);
+
+        CCoord save[4];
+        modifyDrawContext (save, pContext);
+
+        result = view->onWheel (pContext, where2, axis, distance);
+
+        restoreDrawContext (pContext, save);
+    }
+    return result;
+}
+
+//-----------------------------------------------------------------------------
+bool CViewContainer::onWheel (CDrawContext *pContext, const CPoint &where, float distance)
+{
+    return onWheel (pContext, where, kMouseWheelAxisY, distance);
+}
+
+//-----------------------------------------------------------------------------
+bool CViewContainer::onDrop (CDrawContext* context, CDragContainer* drag, const CPoint& where)
+{
+    if (!pParentFrame)
+        return false;
+
+    bool result = false;
+
+    CCoord save[4];
+    modifyDrawContext (save, context);
+
+    // convert to relativ pos
+    CPoint where2 (where);
+    where2.offset (-size.left, -size.top);
+
+    CView* view = getViewAt (where);
+    if (view != currentDragView)
+    {
+        if (currentDragView)
+            currentDragView->onDragLeave (context, drag, where2);
+        currentDragView = view;
+    }
+    if (currentDragView)
+    {
+        result = currentDragView->onDrop (context, drag, where2);
+        currentDragView->onDragLeave (context, drag, where2);
+    }
+    currentDragView = 0;
+
+    restoreDrawContext (context, save);
+
+    return result;
+}
+
+//-----------------------------------------------------------------------------
+void CViewContainer::onDragEnter (CDrawContext* context, CDragContainer* drag, const CPoint& where)
+{
+    if (!pParentFrame)
+        return;
+
+    CCoord save[4];
+    modifyDrawContext (save, context);
+
+    // convert to relativ pos
+    CPoint where2 (where);
+    where2.offset (-size.left, -size.top);
+
+    if (currentDragView)
+        currentDragView->onDragLeave (context, drag, where2);
+    CView* view = getViewAt (where);
+    currentDragView = view;
+    if (view)
+        view->onDragEnter (context, drag, where2);
+
+    restoreDrawContext (context, save);
+}
+
+//-----------------------------------------------------------------------------
+void CViewContainer::onDragLeave (CDrawContext* context, CDragContainer* drag, const CPoint& where)
+{
+    if (!pParentFrame)
+        return;
+
+    CCoord save[4];
+    modifyDrawContext (save, context);
+
+    // convert to relativ pos
+    CPoint where2 (where);
+    where2.offset (-size.left, -size.top);
+
+    if (currentDragView)
+        currentDragView->onDragLeave (context, drag, where2);
+    currentDragView = 0;
+
+    restoreDrawContext (context, save);
+}
+
+//-----------------------------------------------------------------------------
+void CViewContainer::onDragMove (CDrawContext* context, CDragContainer* drag, const CPoint& where)
+{
+    if (!pParentFrame)
+        return;
+
+    CCoord save[4];
+    modifyDrawContext (save, context);
+
+    // convert to relativ pos
+    CPoint where2 (where);
+    where2.offset (-size.left, -size.top);
+
+    CView* view = getViewAt (where);
+    if (view != currentDragView)
+    {
+        if (currentDragView)
+            currentDragView->onDragLeave (context, drag, where2);
+        if (view)
+            view->onDragEnter (context, drag, where2);
+        currentDragView = view;
+    }
+    else if (currentDragView)
+        currentDragView->onDragMove (context, drag, where2);
+
+    restoreDrawContext (context, save);
+}
+
+//-----------------------------------------------------------------------------
+void CViewContainer::update (CDrawContext *pContext)
+{
+    switch (mode)
+    {
+        //---Normal : redraw all...
+        case kNormalUpdate:
+            if (isDirty ())
+            {
+#if NEW_UPDATE_MECHANISM
+                CRect ur (0, 0, size.width (), size.height ());
+                redrawRect (pContext, ur);
+#else
+    #if USE_ALPHA_BLEND
+                if (bTransparencyEnabled)
+                {
+                    CRect updateRect (size);
+                    CPoint offset (0,0);
+                    localToFrame (offset);
+                    updateRect.offset (offset.x, offset.y);
+                    getFrame ()->drawRect (pContext, updateRect);
+                }
+                else
+    #endif
+                draw (pContext);
+    #endif
+                setDirty (false);
+            }
+        break;
+
+        //---Redraw only dirty controls-----
+        case kOnlyDirtyUpdate:
+        {
+#if NEW_UPDATE_MECHANISM
+            if (bDirty)
+            {
+                CRect ur (0, 0, size.width (), size.height ());
+                redrawRect (pContext, ur);
+            }
+            else
+            {
+                CRect updateRect (size);
+                updateRect.offset (-size.left, -size.top);
+                FOREACHSUBVIEW
+                    if (pV->isDirty () && pV->checkUpdate (updateRect))
+                    {
+                        if (pV->notify (this, kMsgCheckIfViewContainer))
+                            pV->update (pContext);
+                        else
+                        {
+                            CRect drawSize (pV->size);
+                            drawSize.bound (updateRect);
+                            pV->redrawRect (pContext, drawSize);
+                        }
+                    }
+                ENDFOR
+            }
+#else
+    #if USE_ALPHA_BLEND
+            if (bTransparencyEnabled)
+            {
+                if (bDirty)
+                {
+                    CRect updateRect (size);
+                    CPoint offset (0,0);
+                    localToFrame (offset);
+                    updateRect.offset (offset.x, offset.y);
+                    getFrame ()->drawRect (pContext, updateRect);
+                }
+                else
+                {
+                    CRect updateRect (size);
+                    updateRect.offset (-size.left, -size.top);
+                    FOREACHSUBVIEW
+                        if (pV->isDirty () && pV->checkUpdate (updateRect))
+                        {
+                            if (pV->notify (this, kMsgCheckIfViewContainer))
+                            {
+                                pV->update (pContext);
+                            }
+                            else
+                            {
+                                CPoint offset;
+                                CRect viewSize (pV->size);
+                                pV->localToFrame (offset);
+                                viewSize.offset (offset.x, offset.y);
+                                getFrame ()->drawRect (pContext, viewSize);
+                            }
+                        }
+                    ENDFOR
+                }
+                setDirty (false);
+                return;
+            }
+    #endif
+            if (bDirty)
+                draw (pContext);
+            else if (bDrawInOffscreen && pOffscreenContext)
+            {
+                bool doCopy = false;
+                if (isDirty ())
+                    doCopy = true;
+
+                FOREACHSUBVIEW
+                    pV->update (pOffscreenContext);
+                ENDFOR
+
+                // transfert offscreen
+                if (doCopy)
+                    pOffscreenContext->copyFrom (pContext, size);
+            }
+            else
+            {
+                long save[4];
+                modifyDrawContext (save, pContext);
+
+                FOREACHSUBVIEW
+                    if (pV->isDirty ())
+                    {
+                        long oldMode = 0;
+                        CViewContainer* child = 0;
+                        if (pV->notify (this, kMsgCheckIfViewContainer))
+                        {
+                            child = (CViewContainer*)pV;
+                            oldMode = child->getMode ();
+                            child->setMode (kNormalUpdate);
+                        }
+                        CRect viewSize (pV->size);
+                        drawBackgroundRect (pContext, viewSize);
+                        pV->update (pContext);
+                        if (child)
+                            child->setMode (oldMode);
+                    }
+                ENDFOR
+
+                restoreDrawContext (pContext, save);
+            }
+#endif
+            setDirty (false);
+        break;
+        }
+    }
+}
+
+//-----------------------------------------------------------------------------
+void CViewContainer::looseFocus (CDrawContext *pContext)
+{
+    FOREACHSUBVIEW
+        pV->looseFocus (pContext);
+    ENDFOR
+}
+
+//-----------------------------------------------------------------------------
+void CViewContainer::takeFocus (CDrawContext *pContext)
+{
+    FOREACHSUBVIEW
+        pV->takeFocus (pContext);
+    ENDFOR
+}
+
+//-----------------------------------------------------------------------------
+bool CViewContainer::advanceNextFocusView (CView* oldFocus, bool reverse)
+{
+    bool foundOld = false;
+    FOREACHSUBVIEW_REVERSE(reverse)
+        if (oldFocus && !foundOld)
+        {
+            if (oldFocus == pV)
+            {
+                foundOld = true;
+                continue;
+            }
+        }
+        else
+        {
+            if (pV->wantsFocus ())
+            {
+                getFrame ()->setFocusView (pV);
+                return true;
+            }
+            else if (pV->isTypeOf ("CViewContainer"))
+            {
+                if (((CViewContainer*)pV)->advanceNextFocusView (0, reverse))
+                    return true;
+            }
+        }
+    ENDFOR
+    return false;
+}
+
+//-----------------------------------------------------------------------------
+bool CViewContainer::isDirty () const
+{
+    if (bDirty)
+        return true;
+
+    CRect viewSize (size);
+    viewSize.offset (-size.left, -size.top);
+
+    FOREACHSUBVIEW
+        if (pV->isDirty ())
+        {
+            CRect r (pV->size);
+            r.bound (viewSize);
+            if (r.getWidth () > 0 && r.getHeight () > 0)
+                return true;
+        }
+    ENDFOR
+    return false;
+}
+
+//-----------------------------------------------------------------------------
+CView *CViewContainer::getCurrentView () const
+{
+    if (!pParentFrame)
+        return 0;
+
+    // get the current position
+    CPoint where;
+    pParentFrame->getCurrentLocation (where);
+
+    frameToLocal (where);
+
+    CCView *pSv = pLastView;
+    while (pSv)
+    {
+        CView *pV = pSv->pView;
+        if (pV && where.isInside (pV->mouseableArea))
+            return pV;
+        pSv = pSv->pPrevious;
+    }
+
+    return 0;
+}
+
+//-----------------------------------------------------------------------------
+CView *CViewContainer::getViewAt (const CPoint& p, bool deep) const
+{
+    if (!pParentFrame)
+        return 0;
+
+    CPoint where (p);
+
+    // convert to relativ pos
+    where.offset (-size.left, -size.top);
+
+    CCView *pSv = pLastView;
+    while (pSv)
+    {
+        CView *pV = pSv->pView;
+        if (pV && where.isInside (pV->mouseableArea))
+        {
+            if (deep)
+            {
+                if (pV->isTypeOf ("CViewContainer"))
+                    return ((CViewContainer*)pV)->getViewAt (where, deep);
+            }
+            return pV;
+        }
+        pSv = pSv->pPrevious;
+    }
+
+    return 0;
+}
+
+//-----------------------------------------------------------------------------
+CPoint& CViewContainer::frameToLocal (CPoint& point) const
+{
+    point.offset (-size.left, -size.top);
+    if (pParentView && pParentView->isTypeOf ("CViewContainer"))
+        return pParentView->frameToLocal (point);
+    return point;
+}
+
+//-----------------------------------------------------------------------------
+CPoint& CViewContainer::localToFrame (CPoint& point) const
+{
+    point.offset (size.left, size.top);
+    if (pParentView && pParentView->isTypeOf ("CViewContainer"))
+        return pParentView->localToFrame (point);
+    return point;
+}
+
+//-----------------------------------------------------------------------------
+bool CViewContainer::removed (CView* parent)
+{
+     if (pOffscreenContext)
+        pOffscreenContext->forget ();
+    pOffscreenContext = 0;
+
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+bool CViewContainer::attached (CView* view)
+{
+    // create offscreen bitmap
+    if (!pOffscreenContext && bDrawInOffscreen)
+        pOffscreenContext = new COffscreenContext (pParentFrame, (long)size.width (), (long)size.height (), kBlackCColor);
+
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+void CViewContainer::useOffscreen (bool b)
+{
+    bDrawInOffscreen = b;
+
+    if (!bDrawInOffscreen && pOffscreenContext)
+    {
+        pOffscreenContext->forget ();
+        pOffscreenContext = 0;
+    }
+}
+
+//-----------------------------------------------------------------------------
+void CViewContainer::modifyDrawContext (CCoord save[4], CDrawContext* pContext)
+{
+    // store
+    save[0] = pContext->offsetScreen.h;
+    save[1] = pContext->offsetScreen.v;
+    save[2] = pContext->offset.h;
+    save[3] = pContext->offset.v;
+
+    pContext->offsetScreen.h += size.left;
+    pContext->offsetScreen.v += size.top;
+    pContext->offset.h += size.left;
+    pContext->offset.v += size.top;
+}
+
+//-----------------------------------------------------------------------------
+void CViewContainer::restoreDrawContext (CDrawContext* pContext, CCoord save[4])
+{
+    // restore
+    pContext->offsetScreen.h = save[0];
+    pContext->offsetScreen.v = save[1];
+    pContext->offset.h = save[2];
+    pContext->offset.v = save[3];
+}
+
+#if DEBUG
+static long _debugDumpLevel = 0;
+//-----------------------------------------------------------------------------
+void CViewContainer::dumpInfo ()
+{
+    static const char* modeString[] = { "Normal Update Mode", "Only Dirty Update Mode"};
+    DebugPrint ("CViewContainer: Mode: %s, Offscreen:%s ", modeString[mode], bDrawInOffscreen ? "Yes" : "No");
+    CView::dumpInfo ();
+}
+
+//-----------------------------------------------------------------------------
+void CViewContainer::dumpHierarchy ()
+{
+    _debugDumpLevel++;
+    FOREACHSUBVIEW
+        for (long i = 0; i < _debugDumpLevel; i++)
+            DebugPrint ("\t");
+        pV->dumpInfo ();
+        DebugPrint ("\n");
+        if (pV->isTypeOf ("CViewContainer"))
+            ((CViewContainer*)pV)->dumpHierarchy ();
+    ENDFOR
+    _debugDumpLevel--;
+}
+
+#endif
+
+
+//-----------------------------------------------------------------------------
+// CBitmap Implementation
+//-----------------------------------------------------------------------------
+/*! @class CBitmap
+@section cbitmap_alphablend Alpha Blend and Transparency
+With Version 3.0 of VSTGUI it is possible to use alpha blended bitmaps. This comes free on Mac OS X and with Windows you need to include libpng.
+Per default PNG images will be rendered alpha blended. If you want to use a transparency color with PNG Bitmaps, you need to call setNoAlpha(true) on the bitmap and set the transparency color.
+@section cbitmap_macos Classic Apple Mac OS
+The Bitmaps are PICTs and stored inside the resource fork.
+@section cbitmap_macosx Apple Mac OS X
+The Bitmaps can be of type PNG, JPEG, PICT, BMP and are stored in the Resources folder of the plugin bundle.
+They must be named bmp00100.png (or bmp00100.jpg, etc). The number is the resource id.
+@section cbitmap_windows Microsoft Windows
+The Bitmaps are .bmp files and must be included in the plug (usually using a .rc file).
+It's also possible to use png as of version 3.0 if you define the macro USE_LIBPNG and include the libpng and zlib libraries/sources to your project.
+*/
+CBitmap::CBitmap (AEffGUIEditor& editor, const char* filename)
+    : resourceID (resourceID), width (0), height (0), noAlpha (true)
+{
+#if DEBUG
+    gNbCBitmap++;
+#endif
+
+    bool found = false;
+    long  i = 0;
+    long  ncolors, cpp;
+
+    pHandle = 0;
+    pMask  = 0;
+    
+	if (editor.getBundlePath() == NULL) {
+		std::cerr << "ERROR: No bundle path set, unable to load images" << std::endl;
+	} else {
+		std::string path = std::string(editor.getBundlePath()) + filename;
+		if (openPng(path.c_str())) // reads width, height
+			closePng();
+	}
+
+    setTransparentColor (kTransparentCColor);
+
+#if DEBUG
+    gBitmapAllocation += (long)height * (long)width;
+#endif
+}
+
+//-----------------------------------------------------------------------------
+CBitmap::CBitmap (CFrame &frame, CCoord width, CCoord height)
+    : width (width), height (height), noAlpha (true), pMask (0)
+{
+#if DEBUG
+    gNbCBitmap++;
+#endif
+
+    pHandle = (void*) XCreatePixmap (display,
+                                     frame.getBackBuffer (),
+                                     width,
+                                     height,
+                                     frame.getDepth ());
+
+    setTransparentColor (kTransparentCColor);
+}
+
+//-----------------------------------------------------------------------------
+CBitmap::CBitmap ()
+	: resourceID (0)
+	, width (0)
+	, height (0)
+	, noAlpha (true)
+{
+    pMask = 0;
+    pHandle = 0;
+}
+
+//-----------------------------------------------------------------------------
+CBitmap::~CBitmap ()
+{
+    dispose ();
+}
+
+//-----------------------------------------------------------------------------
+void CBitmap::dispose ()
+{
+#if DEBUG
+    gNbCBitmap--;
+    gBitmapAllocation -= (long)height * (long)width;
+#endif
+
+    if (pHandle)
+        XFreePixmap (display, (Pixmap)pHandle);
+    if (pMask)
+        XFreePixmap (display, (Pixmap)pMask);
+
+    pHandle = 0;
+    pMask = 0;
+
+    width = 0;
+    height = 0;
+
+}
+
+//-----------------------------------------------------------------------------
+void *CBitmap::getHandle () const
+{
+    return pHandle;
+}
+
+//-----------------------------------------------------------------------------
+bool CBitmap::loadFromResource (long resourceID)
+{
+    dispose ();
+	fprintf (stderr, "CBitmap::loadFromResource not implemented\n");
+    return false;
+}
+
+//-----------------------------------------------------------------------------
+bool CBitmap::loadFromPath (const void* platformPath)
+{
+	if (pHandle != NULL) {
+		dispose ();
+		closePng ();
+	}
+
+	bool success = openPng ((char*)platformPath);
+	if (success)
+		closePng ();
+
+	return success;
+}
+
+//-----------------------------------------------------------------------------
+bool CBitmap::isLoaded () const
+{
+    return (pHandle != NULL);
+}
+
+//-----------------------------------------------------------------------------
+void CBitmap::draw (CDrawContext *pContext, CRect &rect, const CPoint &offset)
+{
+    if (!pHandle)
+    {
+        // the first time try to decode the pixmap
+        pHandle = createPixmapFromPng (pContext);
+        if (!pHandle)
+            return;
+    }
+
+    CFrame* frame = pContext->pFrame;
+
+    XCopyArea (display,
+               (Drawable) pHandle,
+               (Drawable) frame->getBackBuffer(),
+               (GC) frame->getGC(),
+               offset.h,
+               offset.v,
+               std::min (rect.width (), getWidth()),
+               std::min (rect.height (), getHeight()),
+               rect.left + pContext->offset.h,
+               rect.top + pContext->offset.v);
+}
+
+//-----------------------------------------------------------------------------
+void CBitmap::drawTransparent (CDrawContext *pContext, CRect &rect, const CPoint &offset)
+{
+    if (!pHandle)
+    {
+        // the first time try to decode the pixmap
+        pHandle = createPixmapFromPng (pContext);
+        if (!pHandle)
+            return;
+    }
+
+    CFrame* frame = pContext->pFrame;
+
+    if (pMask == 0)
+    {
+        // get image from the pixmap
+        XImage* image = XGetImage (display, (Drawable)pHandle,
+                                   0, 0, width, height, AllPlanes, ZPixmap);
+        assert (image);
+
+        // create the bitmap mask
+        pMask = (void*) XCreatePixmap (display, (Drawable)frame->getWindow(),
+                                       width, height, 1);
+        assert (pMask);
+
+        // create a associated GC
+        XGCValues values;
+        values.foreground = 1;
+        GC gc = XCreateGC (display, (Drawable)pMask, GCForeground, &values);
+
+        // clear the mask
+        XFillRectangle (display, (Drawable)pMask, gc, 0, 0, width, height);
+
+        // get the transparent color index
+        int color = pContext->getIndexColor (transparentCColor);
+
+        // inverse the color
+        values.foreground = 0;
+        XChangeGC (display, gc, GCForeground, &values);
+
+        // compute the mask
+        XPoint *points = new XPoint [height * width];
+        int x, y, nbPoints = 0;
+        switch (image->depth)
+        {
+        case 8:
+            for (y = 0; y < height; y++)
+            {
+                char* src = image->data + (y * image->bytes_per_line);
+
+                for (x = 0; x < width; x++)
+                {
+                    if (src[x] == color)
+                    {
+                        points[nbPoints].x = x;
+                        points[nbPoints].y = y;
+                        nbPoints++;
+                    }
+                }
+            }
+            break;
+
+        case 24: {
+            int bytesPerPixel = image->bits_per_pixel >> 3;
+            char *lp = image->data;
+            for (y = 0; y < height; y++)
+            {
+                char* cp = lp;
+                for (x = 0; x < width; x++)
+                {
+                    if (*(int*)cp == color)
+                    {
+                        points[nbPoints].x = x;
+                        points[nbPoints].y = y;
+                        nbPoints++;
+                    }
+                    cp += bytesPerPixel;
+                }
+                lp += image->bytes_per_line;
+            }
+        } break;
+
+        default :
+            break;
+        }
+
+        XDrawPoints (display, (Drawable)pMask, gc,
+                     points, nbPoints, CoordModeOrigin);
+
+        // free
+        XFreeGC (display, gc);
+        delete []points;
+
+        // delete
+        XDestroyImage (image);
+    }
+
+    // set the new clipmask
+    XGCValues value;
+    value.clip_mask = (Pixmap)pMask;
+    value.clip_x_origin = (rect.left + pContext->offset.h) - offset.h;
+    value.clip_y_origin = (rect.top + pContext->offset.v) - offset.v;
+
+    XChangeGC (display,
+               (GC) /*frame->getGC(),*/ pContext->pSystemContext,
+               GCClipMask | GCClipXOrigin | GCClipYOrigin,
+               &value);
+
+    XCopyArea (display,
+               (Drawable) pHandle,
+               (Drawable) frame->getBackBuffer(),
+               (GC) frame->getGC(),
+               offset.h,
+               offset.v,
+               rect.width (),
+               rect.height (),
+               rect.left + pContext->offset.h,
+               rect.top + pContext->offset.v);
+
+    // unset the clipmask
+    XSetClipMask (display, (GC)frame->getGC(), None);
+}
+
+//-----------------------------------------------------------------------------
+void CBitmap::drawAlphaBlend (CDrawContext *pContext, CRect &rect, const CPoint &offset, unsigned char alpha)
+{
+    std::cout << "CBitmap::drawAlphaBlend (not implemented!)" << std::endl;
+}
+
+//-----------------------------------------------------------------------------
+void CBitmap::setTransparentColor (const CColor color)
+{
+    transparentCColor = color;
+}
+
+//-----------------------------------------------------------------------------
+void CBitmap::setTransparencyMask (CDrawContext* pContext, const CPoint& offset)
+{
+    // todo: implement me!
+}
+
+
+//-----------------------------------------------------------------------------
+bool CBitmap::openPng (const char* path)
+{
+	assert(path);
+
+	FILE* fp = fopen(path, "rb");
+	if (!fp) {
+		fprintf(stderr, "Unable to open file %s\n", path);
+		return false;
+	}
+	
+	png_byte header[8];
+	fread(header, 1, 8, fp);
+	if (png_sig_cmp(header, 0, 8)) {
+		fprintf(stderr, "File not recognized as a PNG image");
+		return false;
+	}
+
+	pngRead = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+    if (!pngRead) {
+		fprintf(stderr, "Unable to initialize libpng\n");
+		return false;
+	}
+    
+	pngInfo = png_create_info_struct(pngRead);
+    if (!pngInfo) {
+        png_destroy_read_struct(&pngRead, NULL, NULL);
+        return false;
+    }
+
+	png_init_io(pngRead, fp);
+	png_set_sig_bytes(pngRead, 8);
+	
+	png_read_info(pngRead, pngInfo);
+
+	width = pngInfo->width;
+	height = pngInfo->height;
+
+	pngFp = fp;
+	pngRead = pngRead;
+	pngPath = path;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+bool CBitmap::closePng ()
+{
+	png_destroy_read_struct(&pngRead, &pngInfo, NULL);
+	fclose(pngFp);
+	pngFp = NULL;
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+void* CBitmap::createPixmapFromPng (CDrawContext *pContext)
+{
+	if (!openPng(pngPath.c_str()))
+        return NULL;
+
+	assert(width > 0 && height > 0);
+	
+	png_byte** rows = (png_byte**)malloc(height * sizeof(png_byte*));
+	for (int i = 0; i < height; ++i)
+		rows[i] = (png_byte*)(malloc(pngInfo->width * sizeof(uint32_t)));
+	
+	png_read_image(pngRead, rows);
+
+	CFrame* frame = pContext->pFrame;
+
+	Pixmap p = XCreatePixmap(display, frame->getBackBuffer(),
+			pngInfo->width, pngInfo->height, 24);
+    
+	XGCValues values;
+    values.foreground = 0xFFFFFFFF;
+    
+	// Draw
+	GC gc = XCreateGC (display, p, GCForeground, &values);
+	for (unsigned y = 0; y < pngInfo->height; y++) {
+		for (unsigned x = 0; x < pngInfo->width; ++x) {
+			char r = rows[y][(x*3)];
+			char g = rows[y][(x*3)+1];
+			char b = rows[y][(x*3)+2];
+			uint32_t color = (r << 16) + (g << 8) + b;
+			XSetForeground(display, gc, color);
+			XDrawPoint(display, p, gc, x, y);
+		}
+	}
+    XFreeGC (display, gc);
+	
+	closePng();
+
+	return (void*)p;
+}
+
+//-----------------------------------------------------------------------------
+// CDragContainer Implementation
+//-----------------------------------------------------------------------------
+CDragContainer::CDragContainer (void* platformDrag)
+: platformDrag (platformDrag)
+, nbItems (0)
+, iterator (0)
+, lastItem (0)
+{
+}
+
+//-----------------------------------------------------------------------------
+CDragContainer::~CDragContainer ()
+{
+    if (lastItem)
+    {
+        free (lastItem);
+        lastItem = 0;
+    }
+}
+
+//-----------------------------------------------------------------------------
+long CDragContainer::getType (long idx) const
+{
+    // not implemented
+    return kUnknown;
+}
+
+//-----------------------------------------------------------------------------
+void* CDragContainer::first (long& size, long& type)
+{
+    iterator = 0;
+    return next (size, type);
+}
+
+//-----------------------------------------------------------------------------
+void* CDragContainer::next (long& size, long& type)
+{
+    if (lastItem)
+    {
+        free (lastItem);
+        lastItem = 0;
+    }
+    size = 0;
+    type = kUnknown;
+
+    // not implemented
+
+    return NULL;
+}
+
+} // namespace VSTGUI
+
+//-----------------------------------------------------------------------------
+// return a degre value between [0, 360 * 64[
+static long convertPoint2Angle (CPoint &pm, CPoint &pt)
+{
+    long angle;
+    if (pt.h == pm.h)
+    {
+        if (pt.v < pm.v)
+            angle = 5760;    // 90 * 64
+        else
+            angle = 17280; // 270 * 64
+    }
+    else if (pt.v == pm.v)
+    {
+        if (pt.h < pm.h)
+            angle = 11520;    // 180 * 64
+        else
+            angle = 0;
+    }
+    else
+    {
+        // 3666.9299 = 180 * 64 / pi
+        angle = (long)(3666.9298 * atan ((double)(pm.v - pt.v) / (double)(pt.h - pm.h)));
+
+        if (pt.v < pm.v)
+        {
+            if (pt.h < pm.h)
+                angle += 11520; // 180 * 64
+        }
+        else
+        {
+            if (pt.h < pm.h)
+                angle += 11520; // 180 * 64
+            else
+                angle += 23040; // 360 * 64
+        }
+    }
+    return angle;
+}
+
+
+
+#if !PLUGGUI
+//-----------------------------------------------------------------------------
+// CFileSelector Implementation
+//-----------------------------------------------------------------------------
+#define stringAnyType  "Any Type (*.*)"
+#define stringAllTypes "All Types: ("
+#define stringSelect   "Select"
+#define stringCancel   "Cancel"
+#define stringLookIn   "Look in"
+#define kPathMax        1024
+
+namespace VSTGUI {
+
+//-----------------------------------------------------------------------------
+CFileSelector::CFileSelector (AudioEffectX* effect)
+: effect (effect), vstFileSelect (0)
+{}
+
+//-----------------------------------------------------------------------------
+CFileSelector::~CFileSelector ()
+{
+    if (vstFileSelect)
+    {
+        if (effect && effect->canHostDo ("closeFileSelector"))
+            effect->closeFileSelector (vstFileSelect);
+        else
+        {
+            if (vstFileSelect->reserved == 1 && vstFileSelect->returnPath)
+            {
+                delete []vstFileSelect->returnPath;
+                vstFileSelect->returnPath = 0;
+                vstFileSelect->sizeReturnPath = 0;
+            }
+            if (vstFileSelect->returnMultiplePaths)
+            {
+                for (long i = 0; i < vstFileSelect->nbReturnPath; i++)
+                {
+                    delete []vstFileSelect->returnMultiplePaths[i];
+                    vstFileSelect->returnMultiplePaths[i] = 0;
+                }
+                delete[] vstFileSelect->returnMultiplePaths;
+                vstFileSelect->returnMultiplePaths = 0;
+            }
+        }
+    }
+}
+
+//-----------------------------------------------------------------------------
+long CFileSelector::run (VstFileSelect *vstFileSelect_)
+{
+    vstFileSelect = vstFileSelect_;
+    vstFileSelect->nbReturnPath = 0;
+    vstFileSelect->returnPath[0] = 0;
+
+    if (effect
+        && effect->canHostDo ("openFileSelector")
+        && effect->canHostDo ("closeFileSelector"))
+    {
+        if (effect->openFileSelector (vstFileSelect))
+            return vstFileSelect->nbReturnPath;
+    }
+    return 0;
+}
+
+} // namespace VSTGUI
+
+//-----------------------------------------------------------------------------
+#endif // !PLUGGUI
+//-----------------------------------------------------------------------------
+
diff --git a/vstgui/vstgui.h b/vstgui/vstgui.h
new file mode 100644
index 0000000..2ab0e7d
--- /dev/null
+++ b/vstgui/vstgui.h
@@ -0,0 +1,1105 @@
+/* ----------------------------------------------------------------------------
+ * VSTGUI for X11/LV2/PNG
+ * Author: Dave Robillard
+ * Released under the revised BSD license, as below
+ * ----------------------------------------------------------------------------
+ *
+ * Based on:
+ * ----------------------------------------------------------------------------
+ * VSTGUIL: Graphical User Interface Framework for VST plugins on LINUX
+ * Version: 0.1, Date: 2007/01/21
+ * Author: kRAkEn/gORe
+ *
+ * Which was based on:
+ * ----------------------------------------------------------------------------
+ * VSTGUI: Graphical User Interface Framework for VST plugins
+ * Version 3.0       $Date: 2005/08/12 12:45:00 $
+ * ----------------------------------------------------------------------------
+ * VSTGUI LICENSE
+ * 2004, Steinberg Media Technologies, All Rights Reserved
+ * ----------------------------------------------------------------------------
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of the Steinberg Media Technologies nor the names of
+ *     its contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A  PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+ * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ * ----------------------------------------------------------------------------
+ */
+
+#ifndef __vstgui__
+#define __vstgui__
+
+// define global defines
+#define MOTIF 1
+#define PNG 1
+#define DEBUG 1
+
+#include "audioeffectx.h"
+#include <X11/Xlib.h>
+#include <X11/extensions/Xdbe.h>
+#include <png.h>
+#include <string>
+
+// VSTGUI Version
+#define VSTGUI_VERSION_MAJOR  3
+#define VSTGUI_VERSION_MINOR  0
+
+struct ERect {
+	VstInt16 left;
+	VstInt16 top;
+	VstInt16 right;
+	VstInt16 bottom;
+};
+
+//----------------------------------------------------
+//----------------------------------------------------
+namespace VSTGUI {
+
+class CFrame;
+class CDrawContext;
+class COffscreenContext;
+class CControl;
+class CBitmap;
+
+} // namespace VSTGUI
+
+class AudioEffect;
+
+#ifndef __aeffeditor__
+#include "AEffEditor.hpp"
+#endif
+
+//-----------------------------------------------------------------------------
+// AEffGUIEditor Declaration
+//-----------------------------------------------------------------------------
+class AEffGUIEditor : public AEffEditor
+{
+public:
+//-----------------------------------------------------------------------------
+    AEffGUIEditor (AudioEffect* effect);
+    ~AEffGUIEditor ();
+
+    // get the CFrame object
+    VSTGUI::CFrame* getFrame () { return frame; }
+
+    virtual void setParameter (VstInt32 index, float value);
+    virtual void beginEdit (VstInt32 index);
+    virtual void endEdit (VstInt32 index);
+
+    // feedback to application
+    virtual void doIdleStuff ();
+
+    // wait (in ms)
+    void wait (unsigned int ms);
+
+    // get the current time (in ms)
+    unsigned int getTicks ();
+
+    // get version of this VSTGUI
+    static int getVstGuiVersion () { return (VSTGUI_VERSION_MAJOR << 16) + VSTGUI_VERSION_MINOR; }
+
+    // get the knob mode
+    static VstInt32 getKnobMode () { return knobMode; }
+
+    long getRect (ERect** rect);
+    void idle ();
+    void update ();
+
+	void setBundlePath(const char* path) { bundlePath = strdup(path); }
+	const char* getBundlePath() { return bundlePath; }
+
+#if VST_2_1_EXTENSIONS
+    long onKeyDown (VstKeyCode& keyCode);
+    long onKeyUp (VstKeyCode& keyCode);
+    bool onWheel (float distance);
+    long setKnobMode (VstInt32 val);
+#endif
+//-----------------------------------------------------------------------------
+protected:
+    ERect rect;
+    unsigned int lLastTicks;
+    bool inIdleStuff;
+    static VstInt32 knobMode;
+	char* bundlePath;
+    friend class VSTGUI::CFrame;
+    VSTGUI::CFrame* frame;
+};
+
+//----------------------------------------------------
+#include <sys/time.h>
+#include <unistd.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Intrinsic.h>
+
+inline unsigned int _getTicks ()
+{
+    // gettimeofday is not what we need here, checkout API for hw time
+    struct timeval tv;
+    struct timezone tz;
+    gettimeofday (&tv, &tz);
+    return tv.tv_sec * 1000 + tv.tv_usec / 1000;
+}
+
+struct VstKeyCode;
+
+namespace VSTGUI {
+
+struct CPoint;
+
+#define CLASS_METHODS(name, parent)             \
+    virtual bool isTypeOf (const char* s) const \
+        { return (!strcmp (s, (#name))) ? true : parent::isTypeOf (s); }\
+
+#ifdef VSTGUI_FLOAT_COORDINATES
+    typedef float CCoord;
+#else
+    typedef long CCoord;
+#endif
+
+//-----------------------------------------------------------------------------
+// Structure CRect
+//-----------------------------------------------------------------------------
+struct CRect
+{
+    CRect (CCoord l = 0, CCoord t = 0, CCoord r = 0, CCoord b = 0)
+    :    left (l), top (t), right (r), bottom (b) {}
+    CRect (const CRect& r)
+    :    left (r.left), top (r.top), right (r.right), bottom (r.bottom) {}
+    CRect& operator () (CCoord l, CCoord t, CCoord r, CCoord b)
+    {
+        if (l < r)
+            this->left = l, this->right = r;
+        else
+            this->left = r, this->right = l;
+        if (top < bottom)
+            this->top = t, this->bottom = b;
+        else
+            this->top = b, this->bottom = t;
+        return *this;
+    }
+
+    bool operator != (const CRect& other) const
+    { return (left != other.left || right != other.right ||
+                top != other.top || bottom != other.bottom); }
+
+    bool operator == (const CRect& other) const
+    { return (left == other.left && right == other.right &&
+                top == other.top && bottom == other.bottom); }
+
+    inline CCoord width () const  { return right - left; }
+    inline CCoord height () const { return bottom - top; }
+
+    inline CCoord getWidth () const  { return right - left; }
+    inline CCoord getHeight () const { return bottom - top; }
+
+    inline void setWidth (CCoord w) { right = left + w; }
+    inline void setHeight (CCoord h) { bottom = top + h; }
+
+    CRect &offset (CCoord off_x, CCoord off_y)
+    { left += off_x; right += off_x; top += off_y; bottom += off_y; return *this; }
+
+    CRect &inset (CCoord deltaX, CCoord deltaY)
+    { left += deltaX; right -= deltaX; top += deltaY; bottom -= deltaY;
+    return *this; }
+
+    CRect &moveTo (CCoord dest_x, CCoord dest_y)
+    { CCoord vDiff = dest_y - top; CCoord hDiff = dest_x - left;
+    top += vDiff; bottom += vDiff; left += hDiff; right += hDiff;
+    return *this; }
+
+    bool pointInside (const CPoint& where) const;    // Checks if point is inside this rect
+    bool isEmpty () const;
+
+    bool rectOverlap (const CRect& rect) const
+    {
+        if (right < rect.left) return false;
+        if (left > rect.right) return false;
+        if (bottom < rect.top) return false;
+        if (top > rect.bottom) return false;
+        return true;
+    }
+
+    void bound (const CRect& rect);
+
+    union
+    { CCoord left; CCoord x;};
+
+    union
+    { CCoord top; CCoord y;};
+
+    union
+    { CCoord right; CCoord x2;};
+
+    union
+    { CCoord bottom; CCoord y2;};
+};
+
+//-----------------------------------------------------------------------------
+// Structure CPoint
+//-----------------------------------------------------------------------------
+struct CPoint
+{
+    CPoint (CCoord a_h = 0, CCoord a_v = 0) : h (a_h), v (a_v) {}
+    CPoint& operator () (CCoord a_h, CCoord a_v)
+    { this->h = a_h; this->v = a_v; return *this; }
+
+    bool isInside (CRect& r) const
+    { return h >= r.left && h <= r.right && v >= r.top && v <= r.bottom; }
+
+    bool operator != (const CPoint &other) const
+    { return (h != other.h || v != other.v); }
+
+    bool operator == (const CPoint &other) const
+    { return (h == other.h && v == other.v); }
+
+    CPoint &offset (CCoord off_h, CCoord off_v)
+    { this->h += off_h; this->v += off_v; return *this; }
+
+    union
+    { CCoord h; CCoord x;};
+
+    union
+    { CCoord v; CCoord y;};
+};
+
+//-----------------------------------------------------------------------------
+// Structure CColor
+//-----------------------------------------------------------------------------
+struct CColor
+{
+    CColor& operator () (unsigned char red,
+                        unsigned char green,
+                        unsigned char blue,
+                        unsigned char alpha)
+    {
+        this->red   = red;
+        this->green = green;
+        this->blue  = blue;
+        this->alpha = alpha;
+        return *this;
+    }
+
+    CColor& operator = (const CColor& newColor)
+    {
+        red   = newColor.red;
+        green = newColor.green;
+        blue  = newColor.blue;
+        alpha = newColor.alpha;
+        return *this;
+    }
+
+    CColor operator ~ ()
+    {
+        CColor c;
+        c.red   = ~red;
+        c.green = ~green;
+        c.blue  = ~blue;
+        c.alpha = ~alpha;
+        return c;
+    }
+
+    bool operator != (const CColor &other) const
+    { return (red != other.red || green != other.green || blue  != other.blue || alpha != other.alpha); }
+
+    bool operator == (const CColor &other) const
+    { return (red == other.red && green == other.green && blue  == other.blue && alpha == other.alpha); }
+
+    unsigned char red;
+    unsigned char green;
+    unsigned char blue;
+    unsigned char alpha;
+};
+
+// define some basic colors
+extern CColor kTransparentCColor;
+extern CColor kBlackCColor;
+extern CColor kWhiteCColor;
+extern CColor kGreyCColor;
+extern CColor kRedCColor;
+extern CColor kGreenCColor;
+extern CColor kBlueCColor;
+extern CColor kYellowCColor;
+extern CColor kCyanCColor;
+extern CColor kMagentaCColor;
+
+
+//-----------------------------------------------------------------------------
+// Definitions of special characters in a platform independent way
+
+#define kDegreeSymbol      "\xB0"
+#define kInfiniteSymbol    "oo"
+#define kCopyrightSymbol   "\xA9"
+#define kTrademarkSymbol   "\x99"
+#define kRegisteredSymbol  "\xAE"
+#define kMicroSymbol       "\x85"
+#define kPerthousandSymbol "\x89"
+
+class CDragContainer;
+class CCView;
+class CAttributeListEntry;
+
+//-----------------------------------------------------------------------------
+typedef intptr_t CViewAttributeID;
+//-----------------------------------------------------------------------------
+// Attributes
+//        all attributes where the first letter is lowercase are reserved for the vstgui lib
+
+extern const CViewAttributeID kCViewAttributeReferencePointer;    // 'cvrp'
+
+//-----------------------------------------------------------------------------
+//-----------
+// Font Type
+//-----------
+enum CFont
+{
+    kSystemFont = 0,
+    kNormalFontVeryBig,
+    kNormalFontBig,
+    kNormalFont,
+    kNormalFontSmall,
+    kNormalFontSmaller,
+    kNormalFontVerySmall,
+    kSymbolFont,
+
+    kNumStandardFonts
+};
+
+//-----------
+// Text Face
+//-----------
+enum CTxtFace
+{
+    kNormalFace    = 0,
+    kBoldFace      = 1,
+    kItalicFace    = 2,
+    kUnderlineFace = 4
+};
+
+//-----------
+// Line Style
+//-----------
+enum CLineStyle
+{
+    kLineSolid = 0,
+    kLineOnOffDash
+};
+
+//-----------
+// Draw Mode
+//-----------
+enum CDrawMode
+{
+    kCopyMode = 0,
+    kOrMode,
+    kXorMode,
+    kAntialias
+};
+
+//----------------------------
+// Text Alignment (Horizontal)
+//----------------------------
+enum CHoriTxtAlign
+{
+    kLeftText = 0,
+    kCenterText,
+    kRightText
+};
+
+//----------------------------
+// Buttons Type (+modifiers)
+//----------------------------
+enum CButton
+{
+    kLButton =  1,
+    kMButton =  2,
+    kRButton =  4,
+    kShift   =  8,
+    kControl = 16,
+    kAlt     = 32,
+    kApple   = 64
+};
+
+//----------------------------
+// Cursor Type
+//----------------------------
+enum CCursorType
+{
+    kCursorDefault = 0,
+    kCursorWait,
+    kCursorHSize,
+    kCursorVSize,
+    kCursorSizeAll,
+    kCursorNESWSize,
+    kCursorNWSESize,
+    kCursorCopy,
+    kCursorNotAllowed,
+    kCursorHand
+};
+
+//----------------------------
+// Knob Mode
+//----------------------------
+enum CKnobMode
+{
+    kCircularMode = 0,
+    kRelativCircularMode,
+    kLinearMode
+};
+
+//----------------------------
+// Draw Style
+//----------------------------
+enum CDrawStyle
+{
+    kDrawStroked = 0,
+    kDrawFilled,
+    kDrawFilledAndStroked
+};
+
+enum CMouseWheelAxis
+{
+    kMouseWheelAxisX = 0,
+    kMouseWheelAxisY
+};
+
+//-----------------------------------------------------------------------------
+// CReferenceCounter Declaration (Reference Counting)
+//-----------------------------------------------------------------------------
+class CReferenceCounter
+{
+public:
+    CReferenceCounter () : nbReference (1) {}
+    virtual ~CReferenceCounter () {}
+
+    virtual void forget () { nbReference--; if (nbReference == 0) delete this; }
+    virtual void remember () { nbReference++; }
+    long getNbReference () const { return nbReference; }
+
+private:
+    long nbReference;
+};
+
+//-----------------------------------------------------------------------------
+// CDrawContext Declaration
+//! A drawing context encapsulates the drawing context of the underlying OS. It implements the drawing functions.
+//-----------------------------------------------------------------------------
+class CDrawContext : public CReferenceCounter
+{
+public:
+    CDrawContext (CFrame *pFrame, void *pSystemContext, void *pWindow = 0);
+    virtual ~CDrawContext ();
+
+    void moveTo (const CPoint &point);    ///< move line position to point
+    void lineTo (const CPoint &point);    ///< draw a line from current position to point
+    void drawLines (const CPoint* points, const long& numberOfLines);    ///< draw multiple lines at once
+
+    void drawPolygon (const CPoint *pPoints, long numberOfPoints, const CDrawStyle drawStyle = kDrawStroked); ///< draw a polygon
+    void polyLine (const CPoint *pPoint, long numberOfPoints);    ///< draw a stroked polygon
+    void fillPolygon (const CPoint *pPoint, long numberOfPoints);    ///< draw a filled polygon
+
+    void drawRect (const CRect &rect, const CDrawStyle drawStyle = kDrawStroked);    ///< draw a stroked rect
+    void fillRect (const CRect &rect);    ///< draw a filled rect
+
+    void drawArc (const CRect &rect, const float startAngle1, const float endAngle2, const CDrawStyle drawStyle = kDrawStroked);    ///< draw a stroked arc, where the angles are in degree
+    void drawArc (const CRect &rect, const CPoint &point1, const CPoint &point2);        ///< draw a stroked arc between point1 and point2
+    void fillArc (const CRect &rect, const CPoint &point1, const CPoint &point2);        ///< draw a filled arc between point1 and point2
+
+    void drawEllipse (const CRect &rect, const CDrawStyle drawStyle = kDrawStroked);    ///< draw an ellipse
+    void fillEllipse (const CRect &rect);    ///< draw a filled ellipse
+
+    void drawPoint (const CPoint &point, CColor color);    ///< draw a point
+    CColor getPoint (const CPoint& point); ///< \deprecated
+
+    void floodFill (const CPoint& start); ///< \deprecated
+
+    void       setLineStyle (CLineStyle style);                ///< set the current line style
+    CLineStyle getLineStyle () const { return lineStyle; }    ///< get the current line style
+
+    void   setLineWidth (CCoord width);                        ///< set the current line width
+    CCoord getLineWidth () const { return frameWidth; }        ///< get the current line width
+
+    void      setDrawMode (CDrawMode mode);                    ///< set the current draw mode, see CDrawMode
+    CDrawMode getDrawMode () const { return drawMode; }        ///< get the current draw mode, see CDrawMode
+
+    void   setClipRect (const CRect &clip);                    ///< set the current clip
+    CRect &getClipRect (CRect &clip) const { clip = clipRect; clip.offset (-offset.h, -offset.v); return clip; }    ///< get the current clip
+    void   resetClipRect ();    ///< reset the clip to the default state
+
+    void   setFillColor  (const CColor color);            ///< set current fill color
+    CColor getFillColor () const { return fillColor; }    ///< get current fill color
+
+    void   setFrameColor (const CColor color);                ///< set current stroke color
+    CColor getFrameColor () const { return frameColor; }    ///< get current stroke color
+
+    void   setFontColor (const CColor color);            ///< set current font color
+    CColor getFontColor () const { return fontColor; }    ///< get current font color
+    void   setFont (CFont fontID, const long size = 0, long style = 0);    ///< set current font
+    CFont  getFont () const { return fontId; }                            ///< get current font
+    long   getFontSize () const { return fontSize; }    ///< get current font size
+
+    CCoord getStringWidth (const char* pStr);    ///< get the width of a string
+
+    void drawString (const char *pString, const CRect &rect, const short opaque = false,
+                     const CHoriTxtAlign hAlign = kCenterText);    ///< draw a string
+
+    long getMouseButtons ();    ///< get current mouse buttons
+    void getMouseLocation (CPoint &point);    ///< get current mouse location. should not be used, see CView::getMouseLocation
+    bool waitDoubleClick ();    ///< check if another mouse click occurs in the near future
+    bool waitDrag ();            ///< check if the mouse will be dragged
+
+#if MOTIF
+    long getIndexColor (CColor color);
+    Colormap  getColormap ();
+    Visual   *getVisual ();
+    unsigned int getDepth ();
+    static long nbNewColor;
+#endif
+
+    void *getWindow () { return pWindow; }
+    void setWindow (void *ptr)  { pWindow = ptr; }
+    void getLoc (CPoint &where) const { where = penLoc; }
+    CFrame* getFrame () const { return pFrame; }
+
+    CPoint offsetScreen;
+    CPoint offset;
+
+    void   *getSystemContext () const { return pSystemContext; }
+
+    virtual void forget ();
+
+    //-------------------------------------------
+protected:
+
+    friend class CBitmap;
+    friend class COffscreenContext;
+
+    void   *pSystemContext;
+    void   *pWindow;
+    CFrame *pFrame;
+
+    long   fontSize;
+    long   fontStyle;
+    CFont  fontId;
+    CColor fontColor;
+    CPoint penLoc;
+
+    CCoord   frameWidth;
+    CColor frameColor;
+    CColor fillColor;
+    CLineStyle lineStyle;
+    CDrawMode  drawMode;
+    CRect  clipRect;
+
+#if MOTIF
+    XFontStruct *pFontInfoStruct;
+#endif
+};
+
+
+//-----------------------------------------------------------------------------
+// COffscreenContext Declaration
+//! A drawing device which uses a pixmap as its drawing surface.
+//-----------------------------------------------------------------------------
+class COffscreenContext : public CDrawContext
+{
+public:
+    COffscreenContext (CDrawContext *pContext, CBitmap *pBitmap, bool drawInBitmap = false);
+    COffscreenContext (CFrame *pFrame, long width, long height, const CColor backgroundColor = kBlackCColor);
+
+    virtual ~COffscreenContext ();
+
+    void copyFrom (CDrawContext *pContext, CRect destRect, CPoint srcOffset = CPoint (0, 0));    ///< copy from offscreen to pContext
+    void copyTo (CDrawContext* pContext, CRect& srcRect, CPoint destOffset = CPoint (0, 0));    ///< copy to offscreen from pContext
+
+    inline CCoord getWidth () const { return width; }
+    inline CCoord getHeight () const { return height; }
+
+    //-------------------------------------------
+protected:
+    CBitmap *pBitmap;
+    CBitmap *pBitmapBg;
+    CCoord    height;
+    CCoord    width;
+    bool    bDestroyPixmap;
+
+    CColor  backgroundColor;
+
+#if MOTIF
+    Display *pXdisplay;
+#endif
+};
+
+
+//-----------------------------------------------------------------------------
+// CBitmap Declaration
+//! Encapsulates various platform depended kinds of bitmaps.
+//-----------------------------------------------------------------------------
+class CBitmap : public CReferenceCounter
+{
+public:
+    CBitmap (AEffGUIEditor& editor, const char* img_name); ///< Create from a filename
+    CBitmap (CFrame &frame, CCoord width, CCoord height); ///< Create a pixmap with a given size.
+    virtual ~CBitmap ();
+
+    virtual void draw (CDrawContext *pContext, CRect &rect, const CPoint &offset = CPoint (0, 0));    ///< Draw the pixmap using a given rect as output position and a given offset of its source pixmap.
+    virtual void drawTransparent (CDrawContext *pContext, CRect &rect, const CPoint &offset = CPoint (0, 0));
+    virtual void drawAlphaBlend  (CDrawContext *pContext, CRect &rect, const CPoint &offset = CPoint (0, 0), unsigned char alpha = 128);    ///< Same as CBitmap::draw except that it uses the alpha value to draw the bitmap alpha blended.
+
+    inline CCoord getWidth () const { return width; }
+    inline CCoord getHeight () const { return height; }
+
+    bool isLoaded () const;
+    void *getHandle () const;
+
+    void setTransparentColor (const CColor color);
+    CColor getTransparentColor () const { return transparentCColor; }
+    void setTransparencyMask (CDrawContext* pContext, const CPoint& offset = CPoint (0, 0));
+
+    void setNoAlpha (bool state) { noAlpha = state; }
+    bool getNoAlpha () const { return noAlpha; }
+
+    //-------------------------------------------
+protected:
+    CBitmap ();
+
+    virtual void dispose ();
+    virtual bool loadFromResource (long resourceID);
+    virtual bool loadFromPath (const void* platformPath); // platformPath is a C string
+
+    long resourceID;
+    CCoord width;
+    CCoord height;
+
+    CColor transparentCColor;
+    bool noAlpha;
+
+#if PNG
+	void *createPixmapFromPng (CDrawContext *pContext);
+	bool openPng (const char* path);
+	bool closePng ();
+	std::string pngPath;
+	png_structp pngRead;
+	png_infop   pngInfo;
+	FILE*       pngFp;
+#endif
+#if MOTIF
+    void *createPixmapFromXpm (CDrawContext *pContext);
+
+    char **ppDataXpm;
+    void *pHandle;
+    void *pMask;
+#endif
+};
+
+enum {
+    kMessageUnknown = 0,
+    kMessageNotified = 1
+};
+
+//-----------------------------------------------------------------------------
+// CView Declaration
+//-----------------------------------------------------------------------------
+class CView : public CReferenceCounter
+{
+public:
+    CView (const CRect &size);
+    virtual ~CView ();
+
+    virtual void draw (CDrawContext *pContext);    ///< called if the view should draw itself
+    virtual void drawRect (CDrawContext *pContext, const CRect& updateRect) { draw (pContext); }    ///< called if the view should draw itself
+    virtual bool checkUpdate (CRect& updateRect) const { return updateRect.rectOverlap (size); }
+    virtual void mouse (CDrawContext *pContext, CPoint &where, long buttons = -1);    ///< called if a mouse click event occurs
+
+    virtual void setBackground (CBitmap *background);                ///< set the background image of this view
+    virtual CBitmap *getBackground () const { return pBackground; }    ///< get the background image of this view
+
+    virtual long onKeyDown (VstKeyCode& keyCode);    ///< called if a key down event occurs and this view has focus
+    virtual long onKeyUp (VstKeyCode& keyCode);        ///< called if a key up event occurs and this view has focus
+
+    virtual bool onWheel (CDrawContext *pContext, const CPoint &where, float distance);    ///< called if a mouse wheel event is happening over this view
+    virtual bool onWheel (CDrawContext *pContext, const CPoint &where, const CMouseWheelAxis axis, float distance);    ///< called if a mouse wheel event is happening over this view
+
+    virtual bool onDrop (CDrawContext* context, CDragContainer* drag, const CPoint& where) { return false; }    ///< called if a drag is dropped onto this view
+    virtual void onDragEnter (CDrawContext* context, CDragContainer* drag, const CPoint& where) {}                ///< called if a drag is entering this view
+    virtual void onDragLeave (CDrawContext* context, CDragContainer* drag, const CPoint& where) {}                ///< called if a drag is leaving this view
+    virtual void onDragMove (CDrawContext* context, CDragContainer* drag, const CPoint& where) {}                ///< called if a drag is current moved over this view
+
+    virtual void looseFocus (CDrawContext *pContext = 0);                                        ///< called if view should loose focus
+    virtual void takeFocus (CDrawContext *pContext = 0);                                        ///< called if view should take focus
+
+    virtual bool isDirty () const { return bDirty; }                                            ///< check if view is dirty
+    virtual void setDirty (const bool val = true) { bDirty = val; }                                ///< set the view to dirty so that it is redrawn in the next idle. Thread Safe !
+
+    virtual bool isVisible () const { return bVisible; }                                            ///< check if view is dirty
+    virtual void setVisible (const bool val = true) { bVisible = val; }                                ///< set the view to dirty so that it is redrawn in the next idle. Thread Safe !
+
+    virtual void setMouseEnabled (const bool bEnable = true) { bMouseEnabled = bEnable; }        ///< turn on/off mouse usage for this view
+    virtual bool getMouseEnabled () const { return bMouseEnabled; }                                ///< get the state of wheather this view uses the mouse or not
+
+    virtual void setMouseableArea (const CRect &rect)  { mouseableArea = rect; }                ///< set the area in which the view reacts to the mouse
+    virtual CRect &getMouseableArea (CRect &rect) const { rect = mouseableArea; return rect;}    ///< get the area in which the view reacts to the mouse
+
+    virtual bool hitTest (const CPoint& where, const long buttons = -1) { return where.isInside (mouseableArea); }    ///< check if where hits this view
+
+    virtual void setTransparency (bool val) { bTransparencyEnabled = val; }            ///< set views transparent state
+    virtual bool getTransparency () const { return bTransparencyEnabled; }            ///< is view transparent ?
+
+    CCoord getHeight () const { return size.height (); }                                ///< get the height of the view
+    CCoord getWidth ()  const { return size.width (); }                                ///< get the width of the view
+
+    virtual void setViewSize (CRect &rect);                                            ///< set views size
+    virtual CRect &getViewSize (CRect &rect) const { rect = size; return rect; }    ///< returns the current view size
+    virtual const CRect &getViewSize () const { return size; }    ///< returns the current view size
+
+    virtual bool removed (CView* parent) { return true; }   ///< view is removed from parent view
+    virtual bool attached (CView* view) { return true; }    ///< view is attached to a parent view
+
+    virtual void getMouseLocation (CDrawContext* context, CPoint &point);    ///< get current mouse location in local view coordinates
+
+    virtual CPoint& frameToLocal (CPoint& point) const;        ///< conversion from frame coordinates to local view coordinates
+    virtual CPoint& localToFrame (CPoint& point) const;        ///< conversion from local view coordinates to frame coordinates
+
+    bool getAttributeSize (const CViewAttributeID id, long& outSize) const;                                    ///< get the size of an attribute
+    bool getAttribute (const CViewAttributeID id, const long inSize, void* outData, long& outSize) const;    ///< get an attribute
+    bool setAttribute (const CViewAttributeID id, const long inSize, void* inData);                            ///< set an attribute
+
+    CView  *getParentView () const { return pParentView; }
+    CFrame *getParent () const { return pParentFrame; }
+    CFrame *getFrame () const { return pParentFrame; }
+    virtual void *getEditor () const;
+
+    virtual long notify (CView* sender, const char* message);
+    void redraw ();
+    virtual void redrawRect (CDrawContext* context, const CRect& rect);
+
+    virtual bool wantsFocus () const { return bWantsFocus; }            ///< check if view supports focus
+    virtual void setWantsFocus (bool state) { bWantsFocus = state; }    ///< set focus support on/off
+
+#if DEBUG
+    virtual void dumpInfo ();
+#endif
+
+    virtual bool isTypeOf (const char* s) const
+        { return (!strcmp (s, "CView")); }
+
+    virtual void update (CDrawContext *pContext); // don't call this !!!
+
+    //-------------------------------------------
+protected:
+    friend class CControl;
+    friend class CFrame;
+    friend class CViewContainer;
+
+    CRect  size;
+    CRect  mouseableArea;
+
+    CFrame *pParentFrame;
+    CView  *pParentView;
+
+    bool  bDirty;
+    bool  bMouseEnabled;
+    bool  bTransparencyEnabled;
+    bool  bWantsFocus;
+    bool  bVisible;
+
+    CBitmap* pBackground;
+    CAttributeListEntry* pAttributeList;
+};
+
+// Message to check if View is a CViewContainer
+const extern char* kMsgCheckIfViewContainer;
+
+//-----------------------------------------------------------------------------
+// CViewContainer Declaration
+//! Container Class of CView objects.
+//-----------------------------------------------------------------------------
+class CViewContainer : public CView
+{
+public:
+    CViewContainer (const CRect &size, CFrame *pParent, CBitmap *pBackground = 0);
+    virtual ~CViewContainer ();
+
+    virtual void addView (CView *pView);    ///< add a child view
+    virtual void addView (CView *pView, CRect &mouseableArea, bool mouseEnabled = true);    ///< add a child view
+    virtual void removeView (CView *pView, const bool &withForget = true);    ///< remove a child view
+    virtual void removeAll (const bool &withForget = true);    ///< remove all child views
+    virtual bool isChild (CView *pView) const;    ///< check if pView is a child view of this container
+    virtual long getNbViews () const;            ///< get the number of child views
+    virtual CView *getView (long index) const;    ///< get the child view at index
+
+    virtual void setBackgroundColor (const CColor color);    ///< set the background color (will only be drawn if this container is not set to transparent and does not have a background bitmap)
+    virtual CColor getBackgroundColor () const { return backgroundColor; }    ///< get the background color
+    virtual void setBackgroundOffset (const CPoint &p) { backgroundOffset = p; }    ///< set the offset of the background bitmap
+    virtual const CPoint& getBackgroundOffset () const { return backgroundOffset; }    ///< get the offset of the background bitmap
+
+    virtual void drawBackgroundRect (CDrawContext *pContext, CRect& _updateRect);    ///< draw the background
+
+    enum {
+        kNormalUpdate = 0,        ///< this mode redraws the whole container if something is dirty
+        kOnlyDirtyUpdate        ///< this mode only redraws the views which are dirty
+    };
+
+    virtual void setMode (long val) { mode = val; }    ///< set the update mode
+    virtual long getMode () const { return mode; }    ///< get the update mode
+
+    virtual void useOffscreen (bool b);    ///< turn on/off using an offscreen
+
+    virtual CView *getCurrentView () const;    ///< get the current view under the mouse
+    virtual CView *getViewAt (const CPoint& where, bool deep = false) const;    ///< get the view at point where
+
+    void modifyDrawContext (CCoord save[4], CDrawContext* pContext);
+    void restoreDrawContext (CDrawContext* pContext, CCoord save[4]);
+
+    // CView
+    virtual void draw (CDrawContext *pContext);
+    virtual void drawRect (CDrawContext *pContext, const CRect& updateRect);
+    virtual void mouse (CDrawContext *pContext, CPoint &where, long buttons = -1);
+    virtual bool onWheel (CDrawContext *pContext, const CPoint &where, float distance);
+    virtual bool onWheel (CDrawContext *pContext, const CPoint &where, const CMouseWheelAxis axis, float distance);
+    virtual void update (CDrawContext *pContext);
+    virtual bool hitTest (const CPoint& where, const long buttons = -1);
+    virtual long onKeyDown (VstKeyCode& keyCode);
+    virtual long onKeyUp (VstKeyCode& keyCode);
+    virtual long notify (CView* sender, const char* message);
+
+    virtual bool onDrop (CDrawContext* context, CDragContainer* drag, const CPoint& where);
+    virtual void onDragEnter (CDrawContext* context, CDragContainer* drag, const CPoint& where);
+    virtual void onDragLeave (CDrawContext* context, CDragContainer* drag, const CPoint& where);
+    virtual void onDragMove (CDrawContext* context, CDragContainer* drag, const CPoint& where);
+
+    virtual void looseFocus (CDrawContext *pContext = 0);
+    virtual void takeFocus (CDrawContext *pContext = 0);
+    virtual bool advanceNextFocusView (CView* oldFocus, bool reverse = false);
+
+    virtual bool isDirty () const;
+
+    virtual void setViewSize (CRect &rect);
+
+    virtual bool removed (CView* parent);
+    virtual bool attached (CView* view);
+
+    virtual CPoint& frameToLocal (CPoint& point) const;
+    virtual CPoint& localToFrame (CPoint& point) const;
+
+    virtual void redrawRect (CDrawContext* context, const CRect& rect);
+
+    CLASS_METHODS(CViewContainer, CView)
+
+#if DEBUG
+    virtual void dumpInfo ();
+    virtual void dumpHierarchy ();
+#endif
+
+    //-------------------------------------------
+protected:
+    bool hitTestSubViews (const CPoint& where, const long buttons = -1);
+
+    CCView  *pFirstView;
+    CCView  *pLastView;
+    long mode;
+    COffscreenContext *pOffscreenContext;
+    CColor backgroundColor;
+    CPoint backgroundOffset;
+    bool bDrawInOffscreen;
+
+    CView* currentDragView;
+};
+
+//-----------------------------------------------------------------------------
+// CFrame Declaration
+//! The CFrame is the parent container of all views.
+//-----------------------------------------------------------------------------
+class CFrame : public CViewContainer
+{
+public:
+    CFrame (const CRect &size, void *pSystemWindow, void *pEditor);
+
+    virtual ~CFrame ();
+
+    virtual bool open ();
+    virtual bool close ();
+    virtual bool isOpen () const { return bOpenFlag; }
+
+    virtual void idle ();
+    virtual void doIdleStuff ();
+
+    virtual unsigned long getTicks () const;    ///< get the current time (in ms)
+    virtual long getKnobMode () const;            ///< get hosts knob mode
+
+    virtual bool setPosition (CCoord x, CCoord y);
+    virtual bool getPosition (CCoord &x, CCoord &y) const;
+
+    virtual bool setSize (CCoord width, CCoord height);
+    virtual bool getSize (CRect *pSize) const;
+    virtual bool getSize (CRect &pSize) const;
+
+    virtual long   setModalView (CView *pView);
+    virtual CView *getModalView () const { return pModalView; }
+
+    virtual void  beginEdit (long index);
+    virtual void  endEdit (long index);
+
+    virtual bool  getCurrentLocation (CPoint &where);
+    virtual void  setCursor (CCursorType type);
+
+    virtual void   setFocusView (CView *pView);
+    virtual CView *getFocusView () const { return pFocusView; }
+    virtual bool advanceNextFocusView (CView* oldFocus, bool reverse = false);
+
+    virtual bool setDropActive (bool val);
+    virtual bool isDropActive () const { return bDropActive; };
+
+    CDrawContext* createDrawContext ();
+
+    virtual void setOpenFlag (bool val) { bOpenFlag = val;};
+    virtual bool getOpenFlag () const { return bOpenFlag; };
+
+    virtual void invalidate (const CRect &rect);
+
+    virtual bool updatesDisabled () const { return bUpdatesDisabled; }
+    virtual bool updatesDisabled (bool state) { bool before = bUpdatesDisabled; bUpdatesDisabled = state; return before; }
+
+    void *getSystemWindow () const { return (void*)pSystemWindow; }
+    void *getParentSystemWindow () const { return (void*)pSystemWindow; }
+    void setParentSystemWindow (void *val) { pSystemWindow = (XdbeBackBuffer)val; }
+
+    // CView
+    virtual void draw (CDrawContext *pContext);
+    virtual void drawRect (CDrawContext *pContext, const CRect& updateRect);
+    virtual void draw (CView *pView = 0);
+    virtual void mouse (CDrawContext *pContext, CPoint &where, long buttons = -1);
+    virtual bool onWheel (CDrawContext *pContext, const CPoint &where, float distance);
+    virtual bool onWheel (CDrawContext *pContext, const CPoint &where, const CMouseWheelAxis axis, float distance);
+    virtual long onKeyDown (VstKeyCode& keyCode);
+    virtual long onKeyUp (VstKeyCode& keyCode);
+    virtual void update (CDrawContext *pContext);
+    virtual void setViewSize (CRect& inRect);
+    virtual CView *getCurrentView () const;
+
+    virtual void *getEditor () const { return pEditor; }
+
+#if MOTIF
+    Colormap getColormap ()   const { return colormap; }
+    Visual  *getVisual ()     const { return pVisual; }
+    unsigned int getDepth ()  const { return depth; }
+    Window   getWindow ()     const { return window; }
+    Drawable getBackBuffer () const { return backBuffer; }
+    void     freeGc ();
+
+    Region   region;
+
+    GC       gc;
+    GC       getGC ()         const { return gc; }
+#endif
+
+#if DEBUG
+    virtual void dumpHierarchy ();
+#endif
+
+    CLASS_METHODS(CFrame, CViewContainer)
+
+    //-------------------------------------------
+protected:
+    bool   initFrame (void *pSystemWin);
+
+    void   *pEditor;
+
+    CView   *pModalView;
+    CView   *pFocusView;
+
+    bool    bFirstDraw;
+    bool    bOpenFlag;
+    bool    bDropActive;
+    bool    bUpdatesDisabled;
+
+#if MOTIF
+    Colormap  colormap;
+    Visual   *pVisual;
+    Window    window;
+    unsigned int depth;
+	XdbeBackBuffer backBuffer;
+	Window pSystemWindow;
+#endif
+
+    //-------------------------------------------
+private:
+    CDrawContext *pFrameContext;
+    bool     bAddedWindow;
+    void     *defaultCursor;
+};
+
+//-----------------------------------------------------------------------------
+// CDragContainer Declaration
+//-----------------------------------------------------------------------------
+class CDragContainer : public CReferenceCounter
+{
+public:
+    CDragContainer (void* platformDrag);
+    ~CDragContainer ();
+
+    void* first (long& size, long& type);        ///< returns pointer on a char array if type is known
+    void* next (long& size, long& type);        ///< returns pointer on a char array if type is known
+
+    long getType (long idx) const;
+    long getCount () const { return nbItems; }
+
+    enum {
+        kFile = 0,
+        kText,
+
+        kUnknown = -1
+    };
+
+protected:
+    void* platformDrag;
+    long nbItems;
+
+    long iterator;
+    void* lastItem;
+};
+
+//-----------------------------------------------------------------------------
+// CCView Declaration
+//-----------------------------------------------------------------------------
+class CCView
+{
+public:
+    CCView (CView *pView);
+    ~CCView ();
+
+    CView    *pView;
+    CCView   *pNext;
+    CCView   *pPrevious;
+};
+
+} // namespace VSTGUI
+
+// include the control objects
+#ifndef __vstcontrols__
+#include "vstcontrols.h"
+#endif
+
+#ifndef USE_NAMESPACE
+using namespace VSTGUI;
+#endif
+
+#endif    // __vstgui__
diff --git a/vstgui/vstkeycode.h b/vstgui/vstkeycode.h
new file mode 100644
index 0000000..1eba98c
--- /dev/null
+++ b/vstgui/vstkeycode.h
@@ -0,0 +1,104 @@
+/* ----------------------------------------------------------------------------
+ * VSTGUI for X11/LV2/PNG
+ * Author: Dave Robillard
+ * Released under the revised BSD license, as below
+ * ----------------------------------------------------------------------------
+ *
+ * Based on:
+ * ----------------------------------------------------------------------------
+ * VST Plug-Ins SDK Linux ONLY Port
+ * VSTGUIL: Graphical User Interface Framework for VST plugins on LINUX
+ * Version: 0.1, Date: 2007/01/21
+ * Author: kRAkEn/gORe
+ * ----------------------------------------------------------------------------
+ */
+
+#ifndef __vstkeycode__
+#define __vstkeycode__
+
+
+/** Structure and enum used for keyUp/keyDown */
+struct VstKeyCode
+{
+    long character;
+    unsigned char virt;     ///< see enum VstVirtualKey
+    unsigned char modifier; ///< see enum VstModifierKey
+};
+
+
+/** Used by member virt of VstKeyCode */
+enum VstVirtualKey
+{
+    VKEY_BACK = 1,
+    VKEY_TAB,
+    VKEY_CLEAR,
+    VKEY_RETURN,
+    VKEY_PAUSE,
+    VKEY_ESCAPE,
+    VKEY_SPACE,
+    VKEY_NEXT,
+    VKEY_END,
+    VKEY_HOME,
+
+    VKEY_LEFT,
+    VKEY_UP,
+    VKEY_RIGHT,
+    VKEY_DOWN,
+    VKEY_PAGEUP,
+    VKEY_PAGEDOWN,
+
+    VKEY_SELECT,
+    VKEY_PRINT,
+    VKEY_ENTER,
+    VKEY_SNAPSHOT,
+    VKEY_INSERT,
+    VKEY_DELETE,
+    VKEY_HELP,
+    VKEY_NUMPAD0,
+    VKEY_NUMPAD1,
+    VKEY_NUMPAD2,
+    VKEY_NUMPAD3,
+    VKEY_NUMPAD4,
+    VKEY_NUMPAD5,
+    VKEY_NUMPAD6,
+    VKEY_NUMPAD7,
+    VKEY_NUMPAD8,
+    VKEY_NUMPAD9,
+    VKEY_MULTIPLY,
+    VKEY_ADD,
+    VKEY_SEPARATOR,
+    VKEY_SUBTRACT,
+    VKEY_DECIMAL,
+    VKEY_DIVIDE,
+    VKEY_F1,
+    VKEY_F2,
+    VKEY_F3,
+    VKEY_F4,
+    VKEY_F5,
+    VKEY_F6,
+    VKEY_F7,
+    VKEY_F8,
+    VKEY_F9,
+    VKEY_F10,
+    VKEY_F11,
+    VKEY_F12,
+    VKEY_NUMLOCK,
+    VKEY_SCROLL,
+
+    VKEY_SHIFT,
+    VKEY_CONTROL,
+    VKEY_ALT,
+
+    VKEY_EQUALS
+};
+
+/** Used by member modifier of VstKeyCode */
+enum VstModifierKey
+{
+    MODIFIER_SHIFT     = 1<<0, ///< Shift
+    MODIFIER_ALTERNATE = 1<<1, ///< Alt
+    MODIFIER_COMMAND   = 1<<2, ///< Control on Mac
+    MODIFIER_CONTROL   = 1<<3  ///< Ctrl on PC, Apple on Mac
+};
+
+#endif