//-----------------------------------------------------------------------------
// VST Plug-Ins SDK
// User interface framework for VST plugins
//
// Version 1.0
//
// First version       : Wolfgang Kundrus
// Added Motif/Windows version : Yvan Grabit      01.98
// Added Mac version   : Charlie Steinberg        02.98
// Added BeOS version  : Georges-Edouard Berenger 05.99
//
// (c)1999 Steinberg Soft+Hardware GmbH
//-----------------------------------------------------------------------------

#ifndef __vstgui__
#define __vstgui__

// define global defines
#if WIN32
	#define WINDOWS 1
#elif SGI | SUN
	#define MOTIF 1
#elif __MWERKS__
	#define MAC 1
#endif

#ifndef __AEffEditor__
#include "AEffEditor.hpp"
#endif

//----------------------------------------------------
#if WINDOWS
	#include <windows.h>

//----------------------------------------------------
#elif MOTIF
	#include <X11/Xlib.h>
	#include <X11/Intrinsic.h>
	#ifdef NOBOOL
		#ifndef bool
			typedef short bool;
		#endif
		#ifndef false
			static const bool false = 0; 
		#endif
		#ifndef true
			static const bool true = 1;
		#endif
	#endif

// definition of struct for XPixmap resources
	struct CResTableEntry {
		int id;
  		char **xpm;
	};

	typedef CResTableEntry CResTable[];
	extern CResTable xpmResources;

//----------------------------------------------------
#elif MAC
	#include <Quickdraw.h>
	class CCashedPict;

//----------------------------------------------------
#elif BEOS
	#include <View.h>
	class PlugView;
	class BBitmap;
	class BResources;

#endif

//----------------------------------------------------
//----------------------------------------------------
class CFrame;
class CDrawContext;
class COffscreenContext;
class CControl;
class CBitmap;


//-----------------------------------------------------------------------------
// AEffGUIEditor Declaration
//-----------------------------------------------------------------------------
class AEffGUIEditor : public AEffEditor
{
public :

	AEffGUIEditor (AudioEffect *effect);

	virtual ~AEffGUIEditor ();

	virtual void setParameter (long index, float value) { postUpdate (); } 
	virtual long getRect (ERect **rect);
	virtual long open (void *ptr);
	virtual void idle ();
	virtual void draw (ERect *rect);
#if MAC
	virtual long mouse (long x, long y);
#endif

	// get the current time (in ms)
	long getTicks ();

	// feedback to appli.
	void doIdleStuff ();

	// get the effect attached to this editor
	AudioEffect *getEffect () { return effect; }

//---------------------------------------
protected:
	ERect   rect;
	CFrame *frame;

	unsigned long lLastTicks;
																
private:
	short sInControlLoop;
};


//-----------------------------------------------------------------------------
// Structure CRect
//-----------------------------------------------------------------------------
struct CRect
{
	CRect (long left = 0, long top = 0, long right = 0, long bottom = 0)
	:	left (left), top (top), right (right), bottom (bottom) {}
	CRect (const CRect& r)
	:	left (r.left), top (r.top), right (r.right), bottom (r.bottom) {}
	CRect& operator () (long left, long top, long right, long bottom)
	{
		if (left < right)
			this->left = left, this->right = right;
		else
			this->left = right, this->right = left;
		if (top < bottom)
			this->top = top, this->bottom = bottom;
		else
			this->top = bottom, this->bottom = top;
		return *this;
	}

	long left;
	long top;
	long right;
	long bottom;
	inline long width ()  { return right - left; }
	inline long height () { return bottom - top; }

	void offset (long x, long y) { left += x; right += x;
                                 top += y; bottom += y; }
};

//-----------------------------------------------------------------------------
// Structure CPoint
//-----------------------------------------------------------------------------
struct CPoint
{
	CPoint (long h = 0, long v = 0) : h (h), v (v) {}
	CPoint& operator () (long h, long v) 
	{ this->h = h; this->v = v;
		return *this; }

	bool isInside (CRect& r)
	{ return h >= r.left && h <= r.right && v >= r.top && v <= r.bottom; } 

	long h;
	long v;
};

//-----------------------------------------------------------------------------
// Structure CColor
//-----------------------------------------------------------------------------
struct CColor
{
	CColor& operator () (unsigned char red,
						unsigned char green,
						unsigned char blue,
						unsigned char unused)
	{
		this->red   = red;
		this->green = green;
		this->blue  = blue;
		this->unused = unused;
		return *this; 
	}

	CColor& operator = (CColor newColor)
	{
		red   = newColor.red;
		green = newColor.green;
		blue  = newColor.blue;
		unused = newColor.unused;
		return *this; 
	}

	bool operator != (CColor newColor)
	{
		return (red != newColor.red ||
						green != newColor.green ||
						blue  != newColor.blue);
	}

	bool operator == (CColor newColor)
	{
		return (red == newColor.red &&
						green == newColor.green &&
						blue  == newColor.blue);
	}
	
	unsigned char red;
	unsigned char green;
	unsigned char blue;
	unsigned char unused;
};

// define some basic colors
static CColor kTransparentCColor = {255, 255, 255, 0};
static CColor kBlackCColor  = {0,     0,   0, 0};
static CColor kWhiteCColor  = {255, 255, 255, 0};
static CColor kGreyCColor   = {127, 127, 127, 0};
static CColor kRedCColor    = {255,   0,   0, 0};
static CColor kGreenCColor  = {0  , 255,   0, 0};
static CColor kBlueCColor   = {0  ,   0, 255, 0};
static CColor kYellowCColor = {255, 255,   0, 0};
static CColor kCyanCColor   = {255,   0, 255, 0};
static CColor kMagentaCColor= {0  , 255, 255, 0};

//-----------------------------------------------------------------------------
//-----------
// Font type
//-----------
enum CFont
{
	kSystemFont = 0,
	kNormalFontVeryBig,
	kNormalFontBig,
	kNormalFont,
	kNormalFontSmall,
	kNormalFontVerySmall,
	kSymbolFont,

	kNumStandardFonts
};

//-----------
// Line style
//-----------
enum CLineStyle
{
	kLineSolid = 0,
	kLineOnOffDash
};

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

//-----------------------------------------------------------------------------
// CDrawContext Declaration
//-----------------------------------------------------------------------------
class CDrawContext
{
public:
	CDrawContext (CFrame *frame, void *systemContext, void *window = 0);
	virtual ~CDrawContext ();	

	void moveTo (CPoint &point);
	void lineTo (CPoint &point);

	void polyLine (CPoint *point, int numberOfPoints);
	void fillPolygon (CPoint *point, int numberOfPoints);

	void drawRect (CRect &rect);
	void fillRect (CRect &rect);

	void drawArc (CRect &rect, CPoint &point1, CPoint &point2);
	void fillArc (CRect &rect, CPoint &point1, CPoint &point2);

	void drawEllipse (CRect &rect);
	void fillEllipse (CRect &rect);
	
	void drawPoint (CPoint &point, CColor color);
	
	void       setLineStyle (CLineStyle style);
	CLineStyle getLineStyle () { return lineStyle; }

	void   setLineWidth (int width);
	int    getLineWidth () { return frameWidth; }

	void   setFillColor  (CColor color);
	CColor getFillColor () { return fillColor; }

	void   setFrameColor (CColor color);
	CColor getFrameColor () { return frameColor; }

	void   setFontColor (CColor color);
	CColor getFontColor () { return fontColor; }
	void   setFont (CFont fontID, const int size = 0);

	void drawString (const char *string, CRect &rect, const short opaque = false,
					 const CHoriTxtAlign hAlign = kCenterText);

	int  getMouseButtons ();
	void getMouseLocation (CPoint &point);

#if MOTIF
	int getIndexColor (CColor color);
	Colormap getColormap ();
	Visual   *getVisual ();
	unsigned int getDepth ();

	static int nbNewColor;
#endif

	void *getWindow () { return window; }
	void setWindow (void *ptr)  { window = ptr; }
	void getLoc (CPoint &where) { where = penLoc; }

	//-------------------------------------------
protected:

	friend class CBitmap;
	friend class COffscreenContext;

	void   *getSystemContext () { return systemContext; }

	void   *systemContext;
	void   *window;
	CFrame *frame;

	int    fontSize;
	CColor fontColor;
	CPoint penLoc;

	int    frameWidth;
	CColor frameColor;
	CColor fillColor;
	CLineStyle lineStyle;

#if WINDOWS
	void *brush;
	void *pen;
	void *font;
	void *oldbrush;
	void *oldpen;
	void *oldfont;
	int  iPenStyle;

#elif MAC
	FontInfo fontInfoStruct;
	Pattern  fillPattern;

#elif MOTIF
	Display *display;

	XFontStruct *fontInfoStruct;
	CFont fontInfoId;

#elif BEOS
	BView*	plugView;
	BFont	font;
	void lineFromTo (CPoint& cstart, CPoint& cend);

#endif
};

//-----------------------------------------------------------------------------
// COffscreenContext Declaration
//-----------------------------------------------------------------------------
class COffscreenContext : public CDrawContext
{
public:
	COffscreenContext (CDrawContext *context, CBitmap *bitmap);
	COffscreenContext (CFrame *frame, long width, long height, const CColor backgroundColor = kBlackCColor);

	virtual ~COffscreenContext ();

	void transfert (CDrawContext *context, CRect destRect, CPoint srcOffset = CPoint (0, 0));
	inline int getWidth ()  { return width; }
	inline int getHeight () { return height; }

	//-------------------------------------------
protected:
	bool    destroyPixmap;
	CBitmap *bitmap;

	long    height;
	long    width;

	CColor  backgroundColor;

#if MOTIF
	Display *xdisplay;

#elif BEOS
	BBitmap *offscreenBitmap;
#endif
};


//-----------------------------------------------------------------------------
// CBitmap Declaration
//-----------------------------------------------------------------------------
class CBitmap
{
public:
	CBitmap (int resourceID);
	CBitmap (CFrame &frame, int width, int height);
	~CBitmap ();

	void draw (CDrawContext*, CRect &rect, const CPoint &offset = CPoint (0, 0));
	void drawTransparent (CDrawContext *context, CRect &rect, const CPoint &offset = CPoint (0, 0));

	inline int getWidth ()  { return width; }
	inline int getHeight () { return height; }

	void forget ();
	void remember ();

	void *getHandle () { return handle; }
	
#if BEOS
	static void closeResource ();
#endif

	//-------------------------------------------
protected:
	int  resourceID;
	void *handle;
	void *mask;
	int  width;
	int  height;

	int  nbReference;

#if MOTIF
	void *createPixmapFromXpm (CDrawContext *context);

	char    **dataXpm;
	Display *xdisplay;

#elif MAC
	CCashedPict	*pPict;

#elif BEOS
	static BResources *resourceFile;
	BBitmap    *bbitmap;
	bool				transparencySet;
#endif
};

//-----------------------------------------------------------------------------
// CView Declaration
//-----------------------------------------------------------------------------
class CView
{
public:
	CView (CRect &size);
	virtual ~CView ();

	void redraw ();
	virtual void draw (CDrawContext *context);
	virtual void mouse (CDrawContext *context, CPoint &where);
	virtual void update (CDrawContext *context);

	virtual void looseFocus ();
	virtual void takeFocus ();

	virtual void setTempOffscreen (COffscreenContext *tempOffscr);

	int getHeight () { return size.height (); }
	int getWidth ()  { return size.width (); }

	CFrame *getParent () { return parent; }

	//-------------------------------------------
protected:
	friend class CControl;
	friend class CFrame;
	CRect  size;
	CFrame *parent;
	COffscreenContext *tempOffscreen;
};

//-----------------------------------------------------------------------------
// CFrame Declaration
//-----------------------------------------------------------------------------
class CFrame : public CView
{
public:
	CFrame (CRect &size, void *systemWindow, AEffGUIEditor *editor);
	CFrame (CRect &size, char *title, AEffGUIEditor *editor, const int style = 0);
	
	~CFrame ();

	bool open (CPoint *point = 0);
	bool close ();
	bool isOpen () { return openFlag; }

	void draw (CDrawContext *context);
	void draw (CView *view = 0);
	void mouse (CDrawContext *context, CPoint &where);

	void update (CDrawContext *context);
	void idle ();
	void doIdleStuff () { if (editor) editor->doIdleStuff (); }

	bool getPosition (int &x, int &y);
	bool setSize (int width, int height);
	bool getSize (CRect *size);

	void     setBackground (CBitmap *background);
	CBitmap *getBackground () { return background; }

	virtual bool addView (CView *view);
	virtual bool removeView (CView *view);

	int   setModalView (CView *view);
 
#if WINDOWS
	void *getSystemWindow () { return hwnd;}
#elif BEOS
	void *getSystemWindow () { return plugView;}
#else
	void *getSystemWindow () { return systemWindow;}
#endif

	AEffGUIEditor *getEditor () { return editor; }

	void   setEditView (CView *view) { editView = view; }
	CView *getEditView () { return editView; }

#if MOTIF
	Colormap getColormap ()   { return colormap; }
	Visual  *getVisual ()     { return visual; }
	unsigned int getDepth ()  { return depth; }
	Display *getDisplay ()    { return display; }
	Window   getWindow ()     { return window; }
	void     freeGc ();

	Region   region;

	GC       gc;
	GC       getGC ()         { return gc; }
#else
	void    *getGC ()         { return 0; }
#endif

	//-------------------------------------------
protected:
	bool   initFrame (void *systemWin);

	AEffGUIEditor *editor;
	
	void    *systemWindow;
	CBitmap *background;
	int      viewCount;
	int      maxViews;
	CView   **views;
	CView   *modalView;
	CView   *editView;

	bool    firstDraw;
	bool    openFlag;

#if WINDOWS
	void    *hwnd;
	friend LONG WINAPI WindowProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam);

#elif MOTIF
	Colormap  colormap;
	Display  *display;
	Visual   *visual;
	Window    window;
	unsigned int depth;

	friend void _destroyCallback (Widget, XtPointer, XtPointer);

#elif BEOS
	PlugView *plugView;
#endif

	//-------------------------------------------
private:
	bool      addedWindow;
	void     *vstWindow;
};


// include the control object
#ifndef __vstcontrols__
#include "vstcontrols.h"
#endif


//-End--------------------------------------
#endif