Remove GUI stuff.

git-svn-id: http://svn.drobilla.net/lad/trunk/plugins/mdala.lv2@3074 a436a847-0d15-0410-975c-d299462d15a1

10 files changed, 25 insertions, 10130 deletions

diff --git a/lvz/AEffEditor.hpp b/lvz/AEffEditor.hpp
deleted file mode 100644
index d118a9a..0000000
--- a/lvz/AEffEditor.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#ifndef __LVZ_AUDIOEFFECT_HPP
-#define __LVZ_AUDIOEFFECT_HPP
-
-class AudioEffect;
-
-class AEffEditor {
-public:
-	AEffEditor (AudioEffect* eff)
-		: effect(eff)
-		, URI("NULL")
-		, pluginURI("NULL")
-	{}
-
-	virtual long open(void* ptr) { return true; }
-	virtual void close() {}
-
-	virtual void idle() {}
-	virtual void postUpdate() {}
-
-	virtual const char* getURI()       { return URI; }
-	virtual void setURI(const char* u) { URI = u; }
-
-	virtual const char* getPluginURI()              { return pluginURI; }
-	virtual void        setPluginURI(const char* u) { pluginURI = u; }
-
-protected:
-	AudioEffect* effect;
-	const char*  URI;
-	const char*  pluginURI;
-};
-
-#endif // __LVZ_AUDIOEFFECT_HPP
diff --git a/lvz/AEffect.h b/lvz/AEffect.h
index 8d46cde..f547083 100644
--- a/lvz/AEffect.h
+++ b/lvz/AEffect.h
@@ -1,5 +1,23 @@
-#ifndef __LVZ_AEFFECT_H
-#define __LVZ_AEFFECT_H
+/* LVZ - A C++ interface for writing LV2 plugins.
+ * Copyright 2008-2011 David Robillard <http://drobilla.net>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef LVZ_AEFFECT_H
+#define LVZ_AEFFECT_H
 
 class AudioEffect;
 
@@ -11,4 +29,4 @@ struct AEffect {
 	int flags;
 };
 
-#endif // __LVZ_AFFECT_H
+#endif // LVZ_AFFECT_H
diff --git a/lvz/audioeffectx.h b/lvz/audioeffectx.h
index 28058bf..607bd33 100644
--- a/lvz/audioeffectx.h
+++ b/lvz/audioeffectx.h
@@ -1,5 +1,5 @@
 /* LVZ - A C++ interface for writing LV2 plugins.
- * Copyright (C) 2008-2009 David Robillard <http://drobilla.net>
+ * Copyright 2008-2011 David Robillard <http://drobilla.net>
  *
  * This library is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the Free
@@ -16,8 +16,8 @@
  * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
-#ifndef __LVZ_AUDIOEFFECTX_H
-#define __LVZ_AUDIOEFFECTX_H
+#ifndef LVZ_AUDIOEFFECTX_H
+#define LVZ_AUDIOEFFECTX_H
 
 #include <stdint.h>
 #include <string.h>
@@ -163,5 +163,5 @@ protected:
 	AEffect     cEffect;
 };
 
-#endif // __LVZ_AUDIOEFFECTX_H
+#endif // LVZ_AUDIOEFFECTX_H
 
diff --git a/lvz/gui_wrapper.cpp b/lvz/gui_wrapper.cpp
deleted file mode 100644
index 9d3a627..0000000
--- a/lvz/gui_wrapper.cpp
+++ /dev/null
@@ -1,198 +0,0 @@
-/* LVZ - A C++ interface for writing LV2 plugins.
- * Copyright (C) 2008-2009 David Robillard <http://drobilla.net>
- *
- * This library is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation; either version 2 of the License, or (at your option)
- * any later version.
- *
- * This library is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- */
-
-#ifndef UI_CLASS
-#error "This file requires UI_CLASS to be defined"
-#endif
-#ifndef URI_PREFIX
-#error "This file requires URI_PREFIX to be defined"
-#endif
-#ifndef UI_URI_SUFFIX
-#error "This file requires UI_URI_SUFFIX to be defined"
-#endif
-
-#include <stdlib.h>
-#include <glib.h>
-#include <gtk/gtk.h>
-#include <cassert>
-#include "AEffEditor.hpp"
-#include "lv2_ui.h"
-#include UI_HEADER
-#include PLUGIN_HEADER
-
-extern "C" {
-
-/* UI */
-
-typedef struct {
-	bool          stolen;
-	UI_CLASS*     ui;
-	GtkSocket*    socket;
-	Window        x_window;
-	AudioEffectX* effect;
-} MDAPluginUI;
-
-
-static gboolean
-mda_ui_idle(void* data)
-{
-	MDAPluginUI* ui = (MDAPluginUI*)data;
-	if (!ui->stolen) {
-		//gtk_socket_add_id(GTK_SOCKET(ui->socket), ui->x_window);
-		ui->x_window = (Window)gtk_socket_get_id(GTK_SOCKET(ui->socket));
-		bool success = ui->ui->open((void*)ui->x_window);
-		if (!success)
-			fprintf(stderr, "FAILED TO OPEN GUI\n");
-		ui->ui->getFrame()->draw();
-		ui->stolen = true;
-	}
-
-	ui->ui->idle();
-	return true;
-}
-
-
-static LV2UI_Handle
-mda_ui_instantiate(const struct _LV2UI_Descriptor* descriptor,
-                   const char*                     plugin_uri,
-                   const char*                     bundle_path,
-                   LV2UI_Write_Function            write_function,
-                   LV2UI_Controller                controller,
-                   LV2UI_Widget*                   widget,
-                   const LV2_Feature* const*       features)
-{
-	VSTGUI::setBundlePath(bundle_path);
-
-	MDAPluginUI* ui = (MDAPluginUI*)malloc(sizeof(MDAPluginUI));
-	ui->effect = NULL;
-
-	typedef struct { const void* (*extension_data)(const char* uri); } LV2_DataAccess;
-
-	typedef const void*         (*extension_data_func)(const char* uri);
-	typedef const AudioEffectX* (*get_effect_func)(LV2_Handle instance);
-
-	LV2_Handle      instance = NULL;
-	get_effect_func get_effect = NULL;
-
-
-	if (features != NULL) {
-		const LV2_Feature* feature = features[0];
-		for (size_t i = 0; (feature = features[i]) != NULL; ++i) {
-			if (!strcmp(feature->URI, "http://lv2plug.in/ns/ext/instance-access")) {
-				instance = (LV2_Handle)feature->data;
-			} else if (!strcmp(feature->URI, "http://lv2plug.in/ns/ext/data-access")) {
-				LV2_DataAccess* ext_data = (LV2_DataAccess*)feature->data;
-				extension_data_func func = (extension_data_func)feature->data;
-				get_effect = (get_effect_func)ext_data->extension_data(
-						"http://drobilla.net/ns/ext/vstgui");
-			}
-		}
-	}
-
-	if (instance && get_effect) {
-		ui->effect = (AudioEffectX*)get_effect(instance);
-	} else {
-		fprintf(stderr, "Host does not support required features, aborting.\n");
-		return NULL;
-	}
-
-	ui->ui = new UI_CLASS(ui->effect);
-	ui->stolen = false;
-
-	ui->socket = GTK_SOCKET(gtk_socket_new());
-	gtk_widget_show_all(GTK_WIDGET(ui->socket));
-
-	*widget = ui->socket;
-	g_timeout_add(30, mda_ui_idle, ui);
-
-	return ui;
-}
-
-
-static void
-mda_ui_cleanup(LV2UI_Handle instance)
-{
-	g_idle_remove_by_data(instance);
-}
-
-
-static void
-mda_ui_port_event(LV2UI_Handle ui,
-                  uint32_t     port_index,
-                  uint32_t     buffer_size,
-                  uint32_t     format,
-                  const void*  buffer)
-{
-	// VST UIs seem to not use this at all, it's all polling
-	// The shit the proprietary people come up (and get away) with...
-}
-
-
-static const void*
-mda_ui_extension_data(const char* uri)
-{
-	return NULL;
-}
-
-
-/* Library */
-
-static LV2UI_Descriptor *mda_ui_descriptor = NULL;
-
-static void
-init_ui_descriptor()
-{
-	mda_ui_descriptor = (LV2UI_Descriptor*)malloc(sizeof(LV2UI_Descriptor));
-
-	mda_ui_descriptor->URI = URI_PREFIX UI_URI_SUFFIX;
-	mda_ui_descriptor->instantiate = mda_ui_instantiate;
-	mda_ui_descriptor->cleanup = mda_ui_cleanup;
-	mda_ui_descriptor->port_event = mda_ui_port_event;
-	mda_ui_descriptor->extension_data = mda_ui_extension_data;
-}
-
-
-LV2_SYMBOL_EXPORT
-const LV2UI_Descriptor*
-lv2ui_descriptor(uint32_t index)
-{
-	if (!mda_ui_descriptor)
-		init_ui_descriptor();
-
-	switch (index) {
-	case 0:
-		return mda_ui_descriptor;
-	default:
-		return NULL;
-	}
-}
-
-
-LV2_SYMBOL_EXPORT
-AEffEditor*
-lvz_new_aeffeditor(AudioEffect* effect)
-{
-	UI_CLASS* ui = new UI_CLASS(effect);
-	ui->setURI(URI_PREFIX UI_URI_SUFFIX);
-	ui->setPluginURI(URI_PREFIX PLUGIN_URI_SUFFIX);
-	return ui;
-}
-
-
-} // extern "C"
-
diff --git a/vstgui/TODO b/vstgui/TODO
deleted file mode 100644
index 27096e5..0000000
--- a/vstgui/TODO
+++ /dev/null
@@ -1,19 +0,0 @@
-//-----------------------------------------------------------------------------
-// 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
deleted file mode 100644
index ac85d2b..0000000
--- a/vstgui/vstcontrols.cpp
+++ /dev/null
@@ -1,3651 +0,0 @@
-/* ----------------------------------------------------------------------------
- * VSTGUI for X11/LV2/PNG
- * Author: David 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
deleted file mode 100644
index bef6319..0000000
--- a/vstgui/vstcontrols.h
+++ /dev/null
@@ -1,994 +0,0 @@
-/* ----------------------------------------------------------------------------
- * VSTGUI for X11/LV2/PNG
- * Author: David 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
deleted file mode 100644
index 6757b5e..0000000
--- a/vstgui/vstgui.cpp
+++ /dev/null
@@ -1,4008 +0,0 @@
-/* ----------------------------------------------------------------------------
- * VSTGUI for X11/LV2/PNG
- * Author: David 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),
-  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 {
-
-char* bundlePath = NULL;
-void setBundlePath(const char* path) {
-	VSTGUI::bundlePath = strdup(path);
-}
-
-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, getColormap(), &xcol);
-    return xcol.pixel;*/
-	return (color.red << 16) + (color.green << 8) + color.blue;
-}
-
-//-----------------------------------------------------------------------------
-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
- * Image resources must be in PNG format.
- * Filenames are specified by the pngResources table defined in the GUI.
- */
-CBitmap::CBitmap (long ID)
-    : resourceID (ID), width (0), height (0), noAlpha (true)
-{
-#if DEBUG
-    gNbCBitmap++;
-#endif
-
-	pHandle = 0;
-	pngRead = NULL;
-	pngInfo = NULL;
-
-	bool found = false;
-    long i = 0;
-
-	const char* p = NULL;
-	while (pngResources[i].id != 0) {
-        if (pngResources[i].id == resourceID) {
-            if (pngResources[i].path != NULL) {
-				found = true;
-				p = pngResources[i].path;
-				break;
-			}
-		}
-		++i;
-	}
-
-	if (VSTGUI::bundlePath == NULL) {
-		std::cerr << "ERROR: No bundle path set, unable to load images" << std::endl;
-	} else {
-		std::string path = std::string(VSTGUI::bundlePath) + p;
-		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 ();
-
-	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");
-		fclose(fp);
-		return false;
-	}
-
-	pngRead = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
-	if (!pngRead) {
-		fprintf(stderr, "Unable to initialize libpng\n");
-		fclose(fp);
-		return false;
-	}
-
-	pngInfo = png_create_info_struct(pngRead);
-	if (!pngInfo) {
-		png_destroy_read_struct(&pngRead, NULL, NULL);
-		pngRead = NULL;
-		fclose(fp);
-		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;
-	pngRead = NULL;
-	pngInfo = 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
deleted file mode 100644
index 43789e4..0000000
--- a/vstgui/vstgui.h
+++ /dev/null
@@ -1,1117 +0,0 @@
-/* ----------------------------------------------------------------------------
- * VSTGUI for X11/LV2/PNG
- * Author: David 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
-
-#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;
-};
-
-/** Table of PNG resources (by filename).
- * This is ugly and weird, but designed to allow for easy porting
- * from "motif" ported plugins (via simple search/replacing).
- */
-struct CResTableEntry {
-    int         id;   ///< Resource ID (same as motif)
-    const char* path; ///< Filename (was char** xpmdata for motif)
-};
-
-typedef CResTableEntry CResTable[];
-extern CResTable pngResources;
-
-//----------------------------------------------------
-//----------------------------------------------------
-namespace VSTGUI {
-
-extern char* bundlePath;
-void setBundlePath(const char* path);
-
-
-
-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 ();
-
-#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;
-    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 (long resourceID); ///< 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
deleted file mode 100644
index c4565db..0000000
--- a/vstgui/vstkeycode.h
+++ /dev/null
@@ -1,104 +0,0 @@
-/* ----------------------------------------------------------------------------
- * VSTGUI for X11/LV2/PNG
- * Author: David 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