[wxWidgets.git] / contrib / src / stc / scintilla / include / Platform.h

// Scintilla source code edit control
/** @file Platform.h
 ** Interface to platform facilities. Also includes some basic utilities.
 ** Implemented in PlatGTK.cxx for GTK+/Linux, PlatWin.cxx for Windows, and PlatWX.cxx for wxWindows.
 **/
// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#ifndef PLATFORM_H
#define PLATFORM_H

// PLAT_GTK = GTK+ on Linux or Win32
// PLAT_GTK_WIN32 is defined additionally when running PLAT_GTK under Win32
// PLAT_WIN = Win32 API on Win32 OS
// PLAT_WX is wxWindows on any supported platform

#define PLAT_GTK 0
#define PLAT_GTK_WIN32 0
#define PLAT_WIN 0
#define PLAT_WX  0

#if defined(__WX__)
#undef PLAT_WX
#define PLAT_WX  1

#elif defined(GTK)
#undef PLAT_GTK
#define PLAT_GTK 1

#ifdef _MSC_VER
#undef PLAT_GTK_WIN32
#define PLAT_GTK_WIN32 1
#endif

#else
#undef PLAT_WIN
#define PLAT_WIN 1

#endif


// Include the main header for each platform

#if PLAT_GTK
#ifdef _MSC_VER
#pragma warning(disable: 4505 4514 4710 4800)
#endif
#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
#endif

#if PLAT_WIN
#define _WIN32_WINNT  0x0400 // Otherwise some required stuff gets ifdef'd out
// Vassili Bourdo: shut up annoying Visual C++ warnings:
#ifdef _MSC_VER
#pragma warning(disable: 4244 4309 4710 4800)
#endif
#include <windows.h>
#include <commctrl.h>
#include <richedit.h>
#endif

#if PLAT_WX
#include <wx/wx.h>
#endif

#define ColourID        scColourID
#define FontID          scFontID
#define SurfaceID       scSurfaceID
#define WindowID        scWindowID
#define MenuID          scMenuID
#define Point           scPoint
#define PRectangle      scPRectangle
#define Colour          scColour
#define ColourPair      scColourPair
#define Window          scWindow
#define Palette         scPalette
#define Font            scFont
#define Surface         scSurface
#define Window          scWindow
#define ListBox         scListBox
#define Menu            scMenu
#define Platform        scPlatform
#define TextRange       scTextRange
#define KeyMap          scKeyMap
#define Style           scStyle


// Underlying the implementation of the platform classes are platform specific types.
// Sometimes these need to be passed around by client code so they are defined here

#if PLAT_GTK
typedef GdkColor ColourID;
typedef GdkFont* FontID;
typedef GdkDrawable* SurfaceID;
typedef GtkWidget* WindowID;
typedef GtkItemFactory* MenuID;
#endif

#if PLAT_WIN
typedef COLORREF ColourID;
typedef HFONT FontID;
typedef HDC SurfaceID;
typedef HWND WindowID;
typedef HMENU MenuID;
#endif

#if PLAT_WX
typedef wxColour ColourID;
typedef wxFont* FontID;
typedef wxDC* SurfaceID;
typedef wxWindow* WindowID;
typedef wxMenu* MenuID;
#endif

/**
 * A geometric point class.
 * Point is exactly the same as the Win32 POINT and GTK+ GdkPoint so can be used interchangeably.
 */
class Point {
public:
	int x;
	int y;

	Point(int x_=0, int y_=0) : x(x_), y(y_) {
	}

	// Other automatically defined methods (assignment, copy constructor, destructor) are fine

	static Point FromLong(long lpoint);
};

/**
 * A geometric rectangle class.
 * PRectangle is exactly the same as the Win32 RECT so can be used interchangeably.
 * PRectangles contain their top and left sides, but not their right and bottom sides.
 */
class PRectangle {
public:
	int left;
	int top;
	int right;
	int bottom;

	PRectangle(int left_=0, int top_=0, int right_=0, int bottom_ = 0) :
		left(left_), top(top_), right(right_), bottom(bottom_) {
	}

	// Other automatically defined methods (assignment, copy constructor, destructor) are fine

	bool operator==(PRectangle &rc) {
		return (rc.left == left) && (rc.right == right) &&
			(rc.top == top) && (rc.bottom == bottom);
	}
	bool Contains(Point pt) {
		return (pt.x >= left) && (pt.x <= right) &&
			(pt.y >= top) && (pt.y <= bottom);
	}
	bool Contains(PRectangle rc) {
		return (rc.left >= left) && (rc.right <= right) &&
			(rc.top >= top) && (rc.bottom <= bottom);
	}
	bool Intersects(PRectangle other) {
		return (right >= other.left) && (left <= other.right) &&
			(bottom >= other.top) && (top <= other.bottom);
	}
	int Width() { return right - left; }
	int Height() { return bottom - top; }
};

#if PLAT_WX
wxRect wxRectFromPRectangle(PRectangle prc);
PRectangle PRectangleFromwxRect(wxRect rc);
#endif

/**
 * A colour class.
 */
class Colour {
	ColourID co;
public:
	Colour(long lcol=0);
	Colour(unsigned int red, unsigned int green, unsigned int blue);
	bool operator==(const Colour &other) const;
	long AsLong() const;
	unsigned int GetRed();
	unsigned int GetGreen();
	unsigned int GetBlue();

	friend class Surface;
	friend class Palette;
};

/**
 * Colour pairs hold a desired colour and the colour that the graphics engine
 * allocates to approximate the desired colour.
 * To make palette management more automatic, ColourPairs could register at
 * construction time with a palette management object.
 */
struct ColourPair {
	Colour desired;
	Colour allocated;

	ColourPair(Colour desired_=Colour(0,0,0)) {
		desired = desired_;
		allocated = desired;
	}
};

class Window;	// Forward declaration for Palette

/**
 * Colour palette management.
 */
class Palette {
	int used;
	enum {numEntries = 100};
	ColourPair entries[numEntries];
#if PLAT_GTK
	GdkColor *allocatedPalette;
	int allocatedLen;
#elif PLAT_WIN
	HPALETTE hpal;
#elif PLAT_WX
	// wxPalette* pal;  // **** Is this needed?
#endif
public:
	bool allowRealization;

	Palette();
	~Palette();

	void Release();

	/**
	 * This method either adds a colour to the list of wanted colours (want==true)
	 * or retrieves the allocated colour back to the ColourPair.
	 * This is one method to make it easier to keep the code for wanting and retrieving in sync.
	 */
	void WantFind(ColourPair &cp, bool want);

	void Allocate(Window &w);

	friend class Surface;
};

/**
 * Font management.
 */
class Font {
protected:
	FontID id;
#if PLAT_WX
	int ascent;
#endif
	// Private so Font objects can not be copied
	Font(const Font &) {}
	Font &operator=(const Font &) { id=0; return *this; }
public:
	Font();
	virtual ~Font();

	virtual void Create(const char *faceName, int characterSet, int size, bool bold, bool italic);
	virtual void Release();

	FontID GetID() { return id; }
	// Alias another font - caller guarantees not to Release
	void SetID(FontID id_) { id = id_; }
	friend class Surface;
};

/**
 * A surface abstracts a place to draw.
 */
class Surface {
private:
	bool unicodeMode;
#if PLAT_GTK
	GdkDrawable *drawable;
	GdkGC *gc;
	GdkPixmap *ppixmap;
	int x;
	int y;
	bool inited;
	bool createdGC;
#elif PLAT_WIN
	HDC hdc;
	bool hdcOwned;
	HPEN pen;
	HPEN penOld;
	HBRUSH brush;
	HBRUSH brushOld;
	HFONT font;
	HFONT fontOld;
	HBITMAP bitmap;
	HBITMAP bitmapOld;
	HPALETTE paletteOld;
#elif PLAT_WX
	wxDC* hdc;
	bool hdcOwned;
	wxBitmap* bitmap;
	int x;
	int y;
#endif

	// Private so Surface objects can not be copied
	Surface(const Surface &) {}
	Surface &operator=(const Surface &) { return *this; }
#if PLAT_WIN || PLAT_WX
	void BrushColor(Colour back);
	void SetFont(Font &font_);
#endif
public:
	Surface();
	~Surface();

	void Init();
	void Init(SurfaceID hdc_);
	void InitPixMap(int width, int height, Surface *surface_);

	void Release();
	bool Initialised();
	void PenColour(Colour fore);
	int LogPixelsY();
	int DeviceHeightFont(int points);
	void MoveTo(int x_, int y_);
	void LineTo(int x_, int y_);
	void Polygon(Point *pts, int npts, Colour fore, Colour back);
	void RectangleDraw(PRectangle rc, Colour fore, Colour back);
	void FillRectangle(PRectangle rc, Colour back);
	void FillRectangle(PRectangle rc, Surface &surfacePattern);
	void RoundedRectangle(PRectangle rc, Colour fore, Colour back);
	void Ellipse(PRectangle rc, Colour fore, Colour back);
	void Copy(PRectangle rc, Point from, Surface &surfaceSource);

	void DrawText(PRectangle rc, Font &font_, int ybase, const char *s, int len, Colour fore, Colour back);
	void DrawTextClipped(PRectangle rc, Font &font_, int ybase, const char *s, int len, Colour fore, Colour back);
	void MeasureWidths(Font &font_, const char *s, int len, int *positions);
	int WidthText(Font &font_, const char *s, int len);
	int WidthChar(Font &font_, char ch);
	int Ascent(Font &font_);
	int Descent(Font &font_);
	int InternalLeading(Font &font_);
	int ExternalLeading(Font &font_);
	int Height(Font &font_);
	int AverageCharWidth(Font &font_);

	int SetPalette(Palette *pal, bool inBackGround);
	void SetClip(PRectangle rc);
	void FlushCachedState();

	void SetUnicodeMode(bool unicodeMode_) {
		unicodeMode=unicodeMode_;
	}
};

/**
 * Class to hide the details of window manipulation.
 * Does not own the window which will normally have a longer life than this object.
 */
class Window {
	friend class ListBox;
protected:
	WindowID id;
public:
	Window() : id(0) {}
	Window(const Window &source) : id(source.id) {}
	virtual ~Window();
	Window &operator=(WindowID id_) {
		id = id_;
		return *this;
	}
	WindowID GetID() { return id; }
	bool Created() { return id != 0; }
	void Destroy();
	bool HasFocus();
	PRectangle GetPosition();
	void SetPosition(PRectangle rc);
	void SetPositionRelative(PRectangle rc, Window relativeTo);
	PRectangle GetClientPosition();
	void Show(bool show=true);
	void InvalidateAll();
	void InvalidateRectangle(PRectangle rc);
	virtual void SetFont(Font &font);
	enum Cursor { cursorText, cursorArrow, cursorUp, cursorWait, cursorHoriz, cursorVert, cursorReverseArrow };
	void SetCursor(Cursor curs);
	void SetTitle(const char *s);
#if PLAT_WIN
	LRESULT SendMessage(UINT msg, WPARAM wParam=0, LPARAM lParam=0);
	int GetDlgCtrlID();
	HINSTANCE GetInstance();
#endif
};

/**
 * Listbox management.
 */
class ListBox : public Window {
#if PLAT_GTK
	WindowID list;
	WindowID scroller;
	int current;
#endif
	int desiredVisibleRows;
	unsigned int maxItemCharacters;
	unsigned int aveCharWidth;
public:
	ListBox();
	virtual ~ListBox();
	void Create(Window &parent, int ctrlID);
	virtual void SetFont(Font &font);
	void SetAverageCharWidth(int width);
	void SetVisibleRows(int rows);
	PRectangle GetDesiredRect();
	void Clear();
	void Append(char *s);
	int Length();
	void Select(int n);
	int GetSelection();
	int Find(const char *prefix);
	void GetValue(int n, char *value, int len);
	void Sort();
};

/**
 * Menu management.
 */
class Menu {
	MenuID id;
public:
	Menu();
	MenuID GetID() { return id; }
	void CreatePopUp();
	void Destroy();
	void Show(Point pt, Window &w);
};

/**
 * Platform class used to retrieve system wide parameters such as double click speed
 * and chrome colour. Not a creatable object, more of a module with several functions.
 */
class Platform {
	// Private so Platform objects can not be copied
	Platform(const Platform &) {}
	Platform &operator=(const Platform &) { return *this; }
public:
	// Should be private because no new Platforms are ever created
	// but gcc warns about this
	Platform() {}
	~Platform() {}
	static Colour Chrome();
	static Colour ChromeHighlight();
	static const char *DefaultFont();
	static int DefaultFontSize();
	static unsigned int DoubleClickTime();
	static void DebugDisplay(const char *s);
	static bool IsKeyDown(int key);
	static long SendScintilla(
		WindowID w, unsigned int msg, unsigned long wParam=0, long lParam=0);

	// These are utility functions not really tied to a platform
	static int Minimum(int a, int b);
	static int Maximum(int a, int b);
	// Next three assume 16 bit shorts and 32 bit longs
	static long LongFromTwoShorts(short a,short b) {
		return (a) | ((b) << 16);
	}
	static short HighShortFromLong(long x) {
		return static_cast<short>(x >> 16);
	}
	static short LowShortFromLong(long x) {
		return static_cast<short>(x & 0xffff);
	}
	static void DebugPrintf(const char *format, ...);
	static bool ShowAssertionPopUps(bool assertionPopUps_);
	static void Assert(const char *c, const char *file, int line);
	static int Clamp(int val, int minVal, int maxVal);
};

#ifdef  NDEBUG
#define PLATFORM_ASSERT(c) ((void)0)
#else
#define PLATFORM_ASSERT(c) ((c) ? (void)(0) : Platform::Assert(#c, __FILE__, __LINE__))
#endif

#endif
Commit	Line	Data
9ce192d4	1	// Scintilla source code edit control
65ec6247 RD	2	/** @file Platform.h
	3	** Interface to platform facilities. Also includes some basic utilities.
	4	** Implemented in PlatGTK.cxx for GTK+/Linux, PlatWin.cxx for Windows, and PlatWX.cxx for wxWindows.
	5	**/
	6	// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
9ce192d4 RD	7	// The License.txt file describes the conditions under which this software may be distributed.
	8
	9	#ifndef PLATFORM_H
	10	#define PLATFORM_H
	11
65ec6247 RD	12	// PLAT_GTK = GTK+ on Linux or Win32
	13	// PLAT_GTK_WIN32 is defined additionally when running PLAT_GTK under Win32
	14	// PLAT_WIN = Win32 API on Win32 OS
9ce192d4	15	// PLAT_WX is wxWindows on any supported platform
9ce192d4 RD	16
9ce192d4 RD	17	#define PLAT_GTK 0
65ec6247	18	#define PLAT_GTK_WIN32 0
9ce192d4 RD	19	#define PLAT_WIN 0
	20	#define PLAT_WX 0
	21
	22	#if defined(__WX__)
	23	#undef PLAT_WX
	24	#define PLAT_WX 1
	25
	26	#elif defined(GTK)
	27	#undef PLAT_GTK
	28	#define PLAT_GTK 1
	29
65ec6247 RD	30	#ifdef _MSC_VER
	31	#undef PLAT_GTK_WIN32
	32	#define PLAT_GTK_WIN32 1
	33	#endif
	34
9ce192d4 RD	35	#else
	36	#undef PLAT_WIN
	37	#define PLAT_WIN 1
	38
	39	#endif
	40
	41
	42	// Include the main header for each platform
	43
	44	#if PLAT_GTK
65ec6247 RD	45	#ifdef _MSC_VER
	46	#pragma warning(disable: 4505 4514 4710 4800)
	47	#endif
9ce192d4 RD	48	#include <gtk/gtk.h>
	49	#include <gdk/gdkkeysyms.h>
	50	#endif
	51
	52	#if PLAT_WIN
	53	#define _WIN32_WINNT 0x0400 // Otherwise some required stuff gets ifdef'd out
	54	// Vassili Bourdo: shut up annoying Visual C++ warnings:
	55	#ifdef _MSC_VER
65ec6247	56	#pragma warning(disable: 4244 4309 4710 4800)
9ce192d4 RD	57	#endif
9ce192d4 RD	58	#include <windows.h>
f6bcfd97	59	#include <commctrl.h>
9ce192d4 RD	60	#include <richedit.h>
	61	#endif
	62
	63	#if PLAT_WX
	64	#include <wx/wx.h>
	65	#endif
	66
1bc32508 RD	67	#define ColourID scColourID
	68	#define FontID scFontID
	69	#define SurfaceID scSurfaceID
	70	#define WindowID scWindowID
	71	#define MenuID scMenuID
	72	#define Point scPoint
	73	#define PRectangle scPRectangle
	74	#define Colour scColour
	75	#define ColourPair scColourPair
	76	#define Window scWindow
	77	#define Palette scPalette
	78	#define Font scFont
	79	#define Surface scSurface
	80	#define Window scWindow
	81	#define ListBox scListBox
	82	#define Menu scMenu
	83	#define Platform scPlatform
	84	#define TextRange scTextRange
	85	#define KeyMap scKeyMap
	86	#define Style scStyle
	87
	88
9ce192d4 RD	89	// Underlying the implementation of the platform classes are platform specific types.
	90	// Sometimes these need to be passed around by client code so they are defined here
	91
	92	#if PLAT_GTK
	93	typedef GdkColor ColourID;
	94	typedef GdkFont* FontID;
	95	typedef GdkDrawable* SurfaceID;
	96	typedef GtkWidget* WindowID;
	97	typedef GtkItemFactory* MenuID;
	98	#endif
	99
	100	#if PLAT_WIN
	101	typedef COLORREF ColourID;
	102	typedef HFONT FontID;
	103	typedef HDC SurfaceID;
	104	typedef HWND WindowID;
	105	typedef HMENU MenuID;
	106	#endif
	107
	108	#if PLAT_WX
	109	typedef wxColour ColourID;
	110	typedef wxFont* FontID;
	111	typedef wxDC* SurfaceID;
	112	typedef wxWindow* WindowID;
	113	typedef wxMenu* MenuID;
	114	#endif
	115
65ec6247 RD	116	/**
	117	* A geometric point class.
	118	* Point is exactly the same as the Win32 POINT and GTK+ GdkPoint so can be used interchangeably.
	119	*/
9ce192d4 RD	120	class Point {
	121	public:
	122	int x;
	123	int y;
65ec6247	124
9ce192d4 RD	125	Point(int x_=0, int y_=0) : x(x_), y(y_) {
	126	}
	127
	128	// Other automatically defined methods (assignment, copy constructor, destructor) are fine
65ec6247	129
9ce192d4 RD	130	static Point FromLong(long lpoint);
	131	};
	132
65ec6247 RD	133	/**
	134	* A geometric rectangle class.
	135	* PRectangle is exactly the same as the Win32 RECT so can be used interchangeably.
	136	* PRectangles contain their top and left sides, but not their right and bottom sides.
	137	*/
9ce192d4 RD	138	class PRectangle {
	139	public:
	140	int left;
	141	int top;
	142	int right;
	143	int bottom;
	144
	145	PRectangle(int left_=0, int top_=0, int right_=0, int bottom_ = 0) :
	146	left(left_), top(top_), right(right_), bottom(bottom_) {
	147	}
	148
	149	// Other automatically defined methods (assignment, copy constructor, destructor) are fine
	150
65ec6247 RD	151	bool operator==(PRectangle &rc) {
	152	return (rc.left == left) && (rc.right == right) &&
	153	(rc.top == top) && (rc.bottom == bottom);
	154	}
9ce192d4 RD	155	bool Contains(Point pt) {
	156	return (pt.x >= left) && (pt.x <= right) &&
	157	(pt.y >= top) && (pt.y <= bottom);
	158	}
	159	bool Contains(PRectangle rc) {
	160	return (rc.left >= left) && (rc.right <= right) &&
	161	(rc.top >= top) && (rc.bottom <= bottom);
	162	}
	163	bool Intersects(PRectangle other) {
	164	return (right >= other.left) && (left <= other.right) &&
	165	(bottom >= other.top) && (top <= other.bottom);
	166	}
	167	int Width() { return right - left; }
	168	int Height() { return bottom - top; }
	169	};
	170
	171	#if PLAT_WX
	172	wxRect wxRectFromPRectangle(PRectangle prc);
	173	PRectangle PRectangleFromwxRect(wxRect rc);
	174	#endif
	175
65ec6247 RD	176	/**
	177	* A colour class.
	178	*/
9ce192d4 RD	179	class Colour {
	180	ColourID co;
	181	public:
	182	Colour(long lcol=0);
	183	Colour(unsigned int red, unsigned int green, unsigned int blue);
	184	bool operator==(const Colour &other) const;
	185	long AsLong() const;
	186	unsigned int GetRed();
	187	unsigned int GetGreen();
	188	unsigned int GetBlue();
65ec6247	189
9ce192d4 RD	190	friend class Surface;
	191	friend class Palette;
	192	};
	193
65ec6247 RD	194	/**
	195	* Colour pairs hold a desired colour and the colour that the graphics engine
	196	* allocates to approximate the desired colour.
	197	* To make palette management more automatic, ColourPairs could register at
	198	* construction time with a palette management object.
	199	*/
9ce192d4 RD	200	struct ColourPair {
	201	Colour desired;
	202	Colour allocated;
	203
	204	ColourPair(Colour desired_=Colour(0,0,0)) {
	205	desired = desired_;
	206	allocated = desired;
	207	}
	208	};
	209
	210	class Window; // Forward declaration for Palette
	211
65ec6247 RD	212	/**
	213	* Colour palette management.
	214	*/
9ce192d4 RD	215	class Palette {
	216	int used;
	217	enum {numEntries = 100};
	218	ColourPair entries[numEntries];
	219	#if PLAT_GTK
	220	GdkColor *allocatedPalette;
	221	int allocatedLen;
	222	#elif PLAT_WIN
	223	HPALETTE hpal;
	224	#elif PLAT_WX
	225	// wxPalette* pal; // **** Is this needed?
	226	#endif
	227	public:
	228	bool allowRealization;
65ec6247	229
9ce192d4 RD	230	Palette();
	231	~Palette();
	232
	233	void Release();
65ec6247 RD	234
	235	/**
	236	* This method either adds a colour to the list of wanted colours (want==true)
	237	* or retrieves the allocated colour back to the ColourPair.
	238	* This is one method to make it easier to keep the code for wanting and retrieving in sync.
	239	*/
9ce192d4 RD	240	void WantFind(ColourPair &cp, bool want);
	241
	242	void Allocate(Window &w);
65ec6247	243
9ce192d4 RD	244	friend class Surface;
	245	};
	246
65ec6247 RD	247	/**
	248	* Font management.
	249	*/
9ce192d4	250	class Font {
d134f170	251	protected:
9ce192d4 RD	252	FontID id;
	253	#if PLAT_WX
	254	int ascent;
	255	#endif
	256	// Private so Font objects can not be copied
	257	Font(const Font &) {}
	258	Font &operator=(const Font &) { id=0; return *this; }
	259	public:
	260	Font();
d134f170	261	virtual ~Font();
9ce192d4	262
d134f170 RD	263	virtual void Create(const char *faceName, int characterSet, int size, bool bold, bool italic);
d134f170 RD	264	virtual void Release();
9ce192d4 RD	265
9ce192d4 RD	266	FontID GetID() { return id; }
f6bcfd97 BP	267	// Alias another font - caller guarantees not to Release
f6bcfd97 BP	268	void SetID(FontID id_) { id = id_; }
9ce192d4 RD	269	friend class Surface;
	270	};
	271
65ec6247 RD	272	/**
	273	* A surface abstracts a place to draw.
	274	*/
9ce192d4 RD	275	class Surface {
9ce192d4 RD	276	private:
f6bcfd97	277	bool unicodeMode;
9ce192d4 RD	278	#if PLAT_GTK
	279	GdkDrawable *drawable;
	280	GdkGC *gc;
	281	GdkPixmap *ppixmap;
	282	int x;
	283	int y;
	284	bool inited;
	285	bool createdGC;
	286	#elif PLAT_WIN
	287	HDC hdc;
	288	bool hdcOwned;
	289	HPEN pen;
	290	HPEN penOld;
	291	HBRUSH brush;
	292	HBRUSH brushOld;
	293	HFONT font;
	294	HFONT fontOld;
	295	HBITMAP bitmap;
	296	HBITMAP bitmapOld;
	297	HPALETTE paletteOld;
	298	#elif PLAT_WX
	299	wxDC* hdc;
	300	bool hdcOwned;
	301	wxBitmap* bitmap;
	302	int x;
	303	int y;
	304	#endif
	305
	306	// Private so Surface objects can not be copied
	307	Surface(const Surface &) {}
	308	Surface &operator=(const Surface &) { return *this; }
	309	#if PLAT_WIN \|\| PLAT_WX
	310	void BrushColor(Colour back);
	311	void SetFont(Font &font_);
	312	#endif
	313	public:
	314	Surface();
	315	~Surface();
65ec6247	316
9ce192d4 RD	317	void Init();
	318	void Init(SurfaceID hdc_);
	319	void InitPixMap(int width, int height, Surface *surface_);
	320
	321	void Release();
	322	bool Initialised();
	323	void PenColour(Colour fore);
	324	int LogPixelsY();
f6bcfd97	325	int DeviceHeightFont(int points);
9ce192d4 RD	326	void MoveTo(int x_, int y_);
	327	void LineTo(int x_, int y_);
	328	void Polygon(Point *pts, int npts, Colour fore, Colour back);
	329	void RectangleDraw(PRectangle rc, Colour fore, Colour back);
	330	void FillRectangle(PRectangle rc, Colour back);
	331	void FillRectangle(PRectangle rc, Surface &surfacePattern);
	332	void RoundedRectangle(PRectangle rc, Colour fore, Colour back);
	333	void Ellipse(PRectangle rc, Colour fore, Colour back);
	334	void Copy(PRectangle rc, Point from, Surface &surfaceSource);
	335
	336	void DrawText(PRectangle rc, Font &font_, int ybase, const char *s, int len, Colour fore, Colour back);
	337	void DrawTextClipped(PRectangle rc, Font &font_, int ybase, const char *s, int len, Colour fore, Colour back);
	338	void MeasureWidths(Font &font_, const char s, int len, int positions);
	339	int WidthText(Font &font_, const char *s, int len);
	340	int WidthChar(Font &font_, char ch);
	341	int Ascent(Font &font_);
	342	int Descent(Font &font_);
	343	int InternalLeading(Font &font_);
	344	int ExternalLeading(Font &font_);
	345	int Height(Font &font_);
	346	int AverageCharWidth(Font &font_);
65ec6247	347
9ce192d4 RD	348	int SetPalette(Palette *pal, bool inBackGround);
9ce192d4 RD	349	void SetClip(PRectangle rc);
f6bcfd97 BP	350	void FlushCachedState();
	351
	352	void SetUnicodeMode(bool unicodeMode_) {
	353	unicodeMode=unicodeMode_;
	354	}
9ce192d4 RD	355	};
9ce192d4 RD	356
65ec6247 RD	357	/**
	358	* Class to hide the details of window manipulation.
	359	* Does not own the window which will normally have a longer life than this object.
	360	*/
9ce192d4 RD	361	class Window {
	362	friend class ListBox;
	363	protected:
	364	WindowID id;
	365	public:
	366	Window() : id(0) {}
f6bcfd97	367	Window(const Window &source) : id(source.id) {}
9ce192d4 RD	368	virtual ~Window();
	369	Window &operator=(WindowID id_) {
	370	id = id_;
	371	return *this;
	372	}
	373	WindowID GetID() { return id; }
	374	bool Created() { return id != 0; }
	375	void Destroy();
	376	bool HasFocus();
	377	PRectangle GetPosition();
	378	void SetPosition(PRectangle rc);
	379	void SetPositionRelative(PRectangle rc, Window relativeTo);
	380	PRectangle GetClientPosition();
	381	void Show(bool show=true);
	382	void InvalidateAll();
	383	void InvalidateRectangle(PRectangle rc);
d134f170	384	virtual void SetFont(Font &font);
9ce192d4 RD	385	enum Cursor { cursorText, cursorArrow, cursorUp, cursorWait, cursorHoriz, cursorVert, cursorReverseArrow };
	386	void SetCursor(Cursor curs);
	387	void SetTitle(const char *s);
	388	#if PLAT_WIN
	389	LRESULT SendMessage(UINT msg, WPARAM wParam=0, LPARAM lParam=0);
	390	int GetDlgCtrlID();
	391	HINSTANCE GetInstance();
	392	#endif
	393	};
	394
65ec6247 RD	395	/**
	396	* Listbox management.
	397	*/
9ce192d4 RD	398	class ListBox : public Window {
	399	#if PLAT_GTK
	400	WindowID list;
	401	WindowID scroller;
	402	int current;
	403	#endif
d134f170 RD	404	int desiredVisibleRows;
	405	unsigned int maxItemCharacters;
	406	unsigned int aveCharWidth;
9ce192d4 RD	407	public:
	408	ListBox();
	409	virtual ~ListBox();
9ce192d4	410	void Create(Window &parent, int ctrlID);
d134f170 RD	411	virtual void SetFont(Font &font);
	412	void SetAverageCharWidth(int width);
	413	void SetVisibleRows(int rows);
	414	PRectangle GetDesiredRect();
9ce192d4 RD	415	void Clear();
	416	void Append(char *s);
	417	int Length();
	418	void Select(int n);
	419	int GetSelection();
	420	int Find(const char *prefix);
	421	void GetValue(int n, char *value, int len);
	422	void Sort();
	423	};
	424
65ec6247 RD	425	/**
	426	* Menu management.
	427	*/
9ce192d4 RD	428	class Menu {
	429	MenuID id;
	430	public:
	431	Menu();
	432	MenuID GetID() { return id; }
	433	void CreatePopUp();
	434	void Destroy();
	435	void Show(Point pt, Window &w);
	436	};
	437
65ec6247 RD	438	/**
	439	* Platform class used to retrieve system wide parameters such as double click speed
	440	* and chrome colour. Not a creatable object, more of a module with several functions.
	441	*/
9ce192d4 RD	442	class Platform {
	443	// Private so Platform objects can not be copied
	444	Platform(const Platform &) {}
	445	Platform &operator=(const Platform &) { return *this; }
	446	public:
	447	// Should be private because no new Platforms are ever created
	448	// but gcc warns about this
	449	Platform() {}
	450	~Platform() {}
	451	static Colour Chrome();
	452	static Colour ChromeHighlight();
	453	static const char *DefaultFont();
	454	static int DefaultFontSize();
	455	static unsigned int DoubleClickTime();
	456	static void DebugDisplay(const char *s);
	457	static bool IsKeyDown(int key);
	458	static long SendScintilla(
	459	WindowID w, unsigned int msg, unsigned long wParam=0, long lParam=0);
65ec6247	460
9ce192d4 RD	461	// These are utility functions not really tied to a platform
	462	static int Minimum(int a, int b);
	463	static int Maximum(int a, int b);
d134f170 RD	464	// Next three assume 16 bit shorts and 32 bit longs
	465	static long LongFromTwoShorts(short a,short b) {
	466	return (a) \| ((b) << 16);
	467	}
	468	static short HighShortFromLong(long x) {
	469	return static_cast<short>(x >> 16);
	470	}
	471	static short LowShortFromLong(long x) {
	472	return static_cast<short>(x & 0xffff);
	473	}
9ce192d4	474	static void DebugPrintf(const char *format, ...);
65ec6247 RD	475	static bool ShowAssertionPopUps(bool assertionPopUps_);
65ec6247 RD	476	static void Assert(const char c, const char file, int line);
9ce192d4 RD	477	static int Clamp(int val, int minVal, int maxVal);
	478	};
	479
65ec6247 RD	480	#ifdef NDEBUG
	481	#define PLATFORM_ASSERT(c) ((void)0)
	482	#else
	483	#define PLATFORM_ASSERT(c) ((c) ? (void)(0) : Platform::Assert(#c, __FILE__, __LINE__))
	484	#endif
	485
9ce192d4	486	#endif