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-2002 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
#define PLAT_FOX 0

#if defined(FOX)
#undef PLAT_FOX
#define PLAT_FOX 1

#elif 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


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

typedef void *FontID;
typedef void *SurfaceID;
typedef void *WindowID;
typedef void *MenuID;
typedef void *TickerID;

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

/**
 * In some circumstances, including Win32 in paletted mode and GTK+, each colour
 * must be allocated before use. The desired colours are held in the ColourDesired class,
 * and after allocation the allocation entry is stored in the ColourAllocated class. In other
 * circumstances, such as Win32 in true colour mode, the allocation process just copies
 * the RGB values from the desired to the allocated class.
 * As each desired colour requires allocation before it can be used, the ColourPair class
 * holds both a ColourDesired and a ColourAllocated
 * The Palette class is responsible for managing the palette of colours which contains a
 * list of ColourPair objects and performs the allocation.
 */

/**
 * Holds a desired RGB colour.
 */
class ColourDesired {
	long co;
public:
	ColourDesired(long lcol=0) {
		co = lcol;
	}

	ColourDesired(unsigned int red, unsigned int green, unsigned int blue) {
		co = red | (green << 8) | (blue << 16);
	}

	bool operator==(const ColourDesired &other) const {
		return co == other.co;
	}

	void Set(long lcol) {
		co = lcol;
	}

	long AsLong() const {
		return co;
	}

	unsigned int GetRed() {
		return co & 0xff;
	}

	unsigned int GetGreen() {
		return (co >> 8) & 0xff;
	}

	unsigned int GetBlue() {
		return (co >> 16) & 0xff;
	}
};

/**
 * Holds an allocated RGB colour which may be an approximation to the desired colour.
 */
class ColourAllocated {
	long coAllocated;

public:

	ColourAllocated(long lcol=0) {
		coAllocated = lcol;
	}

	void Set(long lcol) {
		coAllocated = lcol;
	}

	long AsLong() const {
		return coAllocated;
	}
};

/**
 * Colour pairs hold a desired colour and an allocated colour.
 */
struct ColourPair {
	ColourDesired desired;
	ColourAllocated allocated;

	ColourPair(ColourDesired desired_=ColourDesired(0,0,0)) {
		desired = desired_;
		allocated.Set(desired.AsLong());
	}
};

class Window;	// Forward declaration for Palette

/**
 * Colour palette management.
 */
class Palette {
	int used;
	enum {numEntries = 100};
	ColourPair entries[numEntries];
#if PLAT_GTK
	void *allocatedPalette; // GdkColor *
	int allocatedLen;
#endif
public:
#if PLAT_WIN
	void *hpal;
#endif
	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);
};

/**
 * 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;
        friend class SurfaceImpl;
};

/**
 * A surface abstracts a place to draw.
 */
class Surface {
private:
	// Private so Surface objects can not be copied
	Surface(const Surface &) {}
	Surface &operator=(const Surface &) { return *this; }
public:
	Surface() {};
	virtual ~Surface() {};
	static Surface *Allocate();

	virtual void Init()=0;
	virtual void Init(SurfaceID sid)=0;
	virtual void InitPixMap(int width, int height, Surface *surface_)=0;

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

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

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

	virtual void SetUnicodeMode(bool unicodeMode_)=0;
};

/**
 * A simple callback action passing one piece of untyped user data.
 */
typedef void (*CallBackAction)(void*);

/**
 * 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 {
protected:
	WindowID id;
public:
	Window() : id(0), cursorLast(cursorInvalid) {}
	Window(const Window &source) : id(source.id), cursorLast(cursorInvalid) {}
	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 { cursorInvalid, cursorText, cursorArrow, cursorUp, cursorWait, cursorHoriz, cursorVert, cursorReverseArrow };
	void SetCursor(Cursor curs);
	void SetTitle(const char *s);
private:
	Cursor cursorLast;
};

/**
 * Listbox management.
 */

class ListBox : public Window {
private:
#if PLAT_GTK
	WindowID list;
	WindowID scroller;
	int current;
#endif
	int desiredVisibleRows;
	unsigned int maxItemCharacters;
	unsigned int aveCharWidth;
public:
	CallBackAction doubleClickAction;
	void *doubleClickActionData;
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();
	void SetDoubleClickAction(CallBackAction action, void *data) {
		doubleClickAction = action;
		doubleClickActionData = data;
	}
};

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

class ElapsedTime {
	long bigBit;
	long littleBit;
public:
	ElapsedTime();
	double Duration(bool reset=false);
};

/**
 * 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 ColourDesired Chrome();
	static ColourDesired 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);
	static bool IsDBCSLeadByte(int codePage, char ch);

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

// Shut up annoying Visual C++ warnings:
#ifdef _MSC_VER
#pragma warning(disable: 4244 4309 4514 4710)
#endif

#endif
Commit	Line	Data
	1	// Scintilla source code edit control
	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-2002 by Neil Hodgson <neilh@scintilla.org>
	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
	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
	15	// PLAT_WX is wxWindows on any supported platform
	16
	17	#define PLAT_GTK 0
	18	#define PLAT_GTK_WIN32 0
	19	#define PLAT_WIN 0
	20	#define PLAT_WX 0
	21	#define PLAT_FOX 0
	22
	23	#if defined(FOX)
	24	#undef PLAT_FOX
	25	#define PLAT_FOX 1
	26
	27	#elif defined(__WX__)
	28	#undef PLAT_WX
	29	#define PLAT_WX 1
	30
	31	#elif defined(GTK)
	32	#undef PLAT_GTK
	33	#define PLAT_GTK 1
	34
	35	#ifdef _MSC_VER
	36	#undef PLAT_GTK_WIN32
	37	#define PLAT_GTK_WIN32 1
	38	#endif
	39
	40	#else
	41	#undef PLAT_WIN
	42	#define PLAT_WIN 1
	43
	44	#endif
	45
	46
	47	// Underlying the implementation of the platform classes are platform specific types.
	48	// Sometimes these need to be passed around by client code so they are defined here
	49
	50	typedef void *FontID;
	51	typedef void *SurfaceID;
	52	typedef void *WindowID;
	53	typedef void *MenuID;
	54	typedef void *TickerID;
	55
	56	/**
	57	* A geometric point class.
	58	* Point is exactly the same as the Win32 POINT and GTK+ GdkPoint so can be used interchangeably.
	59	*/
	60	class Point {
	61	public:
	62	int x;
	63	int y;
	64
	65	Point(int x_=0, int y_=0) : x(x_), y(y_) {
	66	}
	67
	68	// Other automatically defined methods (assignment, copy constructor, destructor) are fine
	69
	70	static Point FromLong(long lpoint);
	71	};
	72
	73	/**
	74	* A geometric rectangle class.
	75	* PRectangle is exactly the same as the Win32 RECT so can be used interchangeably.
	76	* PRectangles contain their top and left sides, but not their right and bottom sides.
	77	*/
	78	class PRectangle {
	79	public:
	80	int left;
	81	int top;
	82	int right;
	83	int bottom;
	84
	85	PRectangle(int left_=0, int top_=0, int right_=0, int bottom_ = 0) :
	86	left(left_), top(top_), right(right_), bottom(bottom_) {
	87	}
	88
	89	// Other automatically defined methods (assignment, copy constructor, destructor) are fine
	90
	91	bool operator==(PRectangle &rc) {
	92	return (rc.left == left) && (rc.right == right) &&
	93	(rc.top == top) && (rc.bottom == bottom);
	94	}
	95	bool Contains(Point pt) {
	96	return (pt.x >= left) && (pt.x <= right) &&
	97	(pt.y >= top) && (pt.y <= bottom);
	98	}
	99	bool Contains(PRectangle rc) {
	100	return (rc.left >= left) && (rc.right <= right) &&
	101	(rc.top >= top) && (rc.bottom <= bottom);
	102	}
	103	bool Intersects(PRectangle other) {
	104	return (right >= other.left) && (left <= other.right) &&
	105	(bottom >= other.top) && (top <= other.bottom);
	106	}
	107	int Width() { return right - left; }
	108	int Height() { return bottom - top; }
	109	};
	110
	111	/**
	112	* In some circumstances, including Win32 in paletted mode and GTK+, each colour
	113	* must be allocated before use. The desired colours are held in the ColourDesired class,
	114	* and after allocation the allocation entry is stored in the ColourAllocated class. In other
	115	* circumstances, such as Win32 in true colour mode, the allocation process just copies
	116	* the RGB values from the desired to the allocated class.
	117	* As each desired colour requires allocation before it can be used, the ColourPair class
	118	* holds both a ColourDesired and a ColourAllocated
	119	* The Palette class is responsible for managing the palette of colours which contains a
	120	* list of ColourPair objects and performs the allocation.
	121	*/
	122
	123	/**
	124	* Holds a desired RGB colour.
	125	*/
	126	class ColourDesired {
	127	long co;
	128	public:
	129	ColourDesired(long lcol=0) {
	130	co = lcol;
	131	}
	132
	133	ColourDesired(unsigned int red, unsigned int green, unsigned int blue) {
	134	co = red \| (green << 8) \| (blue << 16);
	135	}
	136
	137	bool operator==(const ColourDesired &other) const {
	138	return co == other.co;
	139	}
	140
	141	void Set(long lcol) {
	142	co = lcol;
	143	}
	144
	145	long AsLong() const {
	146	return co;
	147	}
	148
	149	unsigned int GetRed() {
	150	return co & 0xff;
	151	}
	152
	153	unsigned int GetGreen() {
	154	return (co >> 8) & 0xff;
	155	}
	156
	157	unsigned int GetBlue() {
	158	return (co >> 16) & 0xff;
	159	}
	160	};
	161
	162	/**
	163	* Holds an allocated RGB colour which may be an approximation to the desired colour.
	164	*/
	165	class ColourAllocated {
	166	long coAllocated;
	167
	168	public:
	169
	170	ColourAllocated(long lcol=0) {
	171	coAllocated = lcol;
	172	}
	173
	174	void Set(long lcol) {
	175	coAllocated = lcol;
	176	}
	177
	178	long AsLong() const {
	179	return coAllocated;
	180	}
	181	};
	182
	183	/**
	184	* Colour pairs hold a desired colour and an allocated colour.
	185	*/
	186	struct ColourPair {
	187	ColourDesired desired;
	188	ColourAllocated allocated;
	189
	190	ColourPair(ColourDesired desired_=ColourDesired(0,0,0)) {
	191	desired = desired_;
	192	allocated.Set(desired.AsLong());
	193	}
	194	};
	195
	196	class Window; // Forward declaration for Palette
	197
	198	/**
	199	* Colour palette management.
	200	*/
	201	class Palette {
	202	int used;
	203	enum {numEntries = 100};
	204	ColourPair entries[numEntries];
	205	#if PLAT_GTK
	206	void allocatedPalette; // GdkColor
	207	int allocatedLen;
	208	#endif
	209	public:
	210	#if PLAT_WIN
	211	void *hpal;
	212	#endif
	213	bool allowRealization;
	214
	215	Palette();
	216	~Palette();
	217
	218	void Release();
	219
	220	/**
	221	* This method either adds a colour to the list of wanted colours (want==true)
	222	* or retrieves the allocated colour back to the ColourPair.
	223	* This is one method to make it easier to keep the code for wanting and retrieving in sync.
	224	*/
	225	void WantFind(ColourPair &cp, bool want);
	226
	227	void Allocate(Window &w);
	228	};
	229
	230	/**
	231	* Font management.
	232	*/
	233	class Font {
	234	protected:
	235	FontID id;
	236	#if PLAT_WX
	237	int ascent;
	238	#endif
	239	// Private so Font objects can not be copied
	240	Font(const Font &) {}
	241	Font &operator=(const Font &) { id=0; return *this; }
	242	public:
	243	Font();
	244	virtual ~Font();
	245
	246	virtual void Create(const char *faceName, int characterSet, int size, bool bold, bool italic);
	247	virtual void Release();
	248
	249	FontID GetID() { return id; }
	250	// Alias another font - caller guarantees not to Release
	251	void SetID(FontID id_) { id = id_; }
	252	friend class Surface;
	253	friend class SurfaceImpl;
	254	};
	255
	256	/**
	257	* A surface abstracts a place to draw.
	258	*/
	259	class Surface {
	260	private:
	261	// Private so Surface objects can not be copied
	262	Surface(const Surface &) {}
	263	Surface &operator=(const Surface &) { return *this; }
	264	public:
	265	Surface() {};
	266	virtual ~Surface() {};
	267	static Surface *Allocate();
	268
	269	virtual void Init()=0;
	270	virtual void Init(SurfaceID sid)=0;
	271	virtual void InitPixMap(int width, int height, Surface *surface_)=0;
	272
	273	virtual void Release()=0;
	274	virtual bool Initialised()=0;
	275	virtual void PenColour(ColourAllocated fore)=0;
	276	virtual int LogPixelsY()=0;
	277	virtual int DeviceHeightFont(int points)=0;
	278	virtual void MoveTo(int x_, int y_)=0;
	279	virtual void LineTo(int x_, int y_)=0;
	280	virtual void Polygon(Point *pts, int npts, ColourAllocated fore, ColourAllocated back)=0;
	281	virtual void RectangleDraw(PRectangle rc, ColourAllocated fore, ColourAllocated back)=0;
	282	virtual void FillRectangle(PRectangle rc, ColourAllocated back)=0;
	283	virtual void FillRectangle(PRectangle rc, Surface &surfacePattern)=0;
	284	virtual void RoundedRectangle(PRectangle rc, ColourAllocated fore, ColourAllocated back)=0;
	285	virtual void Ellipse(PRectangle rc, ColourAllocated fore, ColourAllocated back)=0;
	286	virtual void Copy(PRectangle rc, Point from, Surface &surfaceSource)=0;
	287
	288	virtual void DrawTextNoClip(PRectangle rc, Font &font_, int ybase, const char *s, int len, ColourAllocated fore, ColourAllocated back)=0;
	289	virtual void DrawTextClipped(PRectangle rc, Font &font_, int ybase, const char *s, int len, ColourAllocated fore, ColourAllocated back)=0;
	290	virtual void MeasureWidths(Font &font_, const char s, int len, int positions)=0;
	291	virtual int WidthText(Font &font_, const char *s, int len)=0;
	292	virtual int WidthChar(Font &font_, char ch)=0;
	293	virtual int Ascent(Font &font_)=0;
	294	virtual int Descent(Font &font_)=0;
	295	virtual int InternalLeading(Font &font_)=0;
	296	virtual int ExternalLeading(Font &font_)=0;
	297	virtual int Height(Font &font_)=0;
	298	virtual int AverageCharWidth(Font &font_)=0;
	299
	300	virtual int SetPalette(Palette *pal, bool inBackGround)=0;
	301	virtual void SetClip(PRectangle rc)=0;
	302	virtual void FlushCachedState()=0;
	303
	304	virtual void SetUnicodeMode(bool unicodeMode_)=0;
	305	};
	306
	307	/**
	308	* A simple callback action passing one piece of untyped user data.
	309	*/
	310	typedef void (CallBackAction)(void);
	311
	312	/**
	313	* Class to hide the details of window manipulation.
	314	* Does not own the window which will normally have a longer life than this object.
	315	*/
	316	class Window {
	317	protected:
	318	WindowID id;
	319	public:
	320	Window() : id(0), cursorLast(cursorInvalid) {}
	321	Window(const Window &source) : id(source.id), cursorLast(cursorInvalid) {}
	322	virtual ~Window();
	323	Window &operator=(WindowID id_) {
	324	id = id_;
	325	return *this;
	326	}
	327	WindowID GetID() { return id; }
	328	bool Created() { return id != 0; }
	329	void Destroy();
	330	bool HasFocus();
	331	PRectangle GetPosition();
	332	void SetPosition(PRectangle rc);
	333	void SetPositionRelative(PRectangle rc, Window relativeTo);
	334	PRectangle GetClientPosition();
	335	void Show(bool show=true);
	336	void InvalidateAll();
	337	void InvalidateRectangle(PRectangle rc);
	338	virtual void SetFont(Font &font);
	339	enum Cursor { cursorInvalid, cursorText, cursorArrow, cursorUp, cursorWait, cursorHoriz, cursorVert, cursorReverseArrow };
	340	void SetCursor(Cursor curs);
	341	void SetTitle(const char *s);
	342	private:
	343	Cursor cursorLast;
	344	};
	345
	346	/**
	347	* Listbox management.
	348	*/
	349
	350	class ListBox : public Window {
	351	private:
	352	#if PLAT_GTK
	353	WindowID list;
	354	WindowID scroller;
	355	int current;
	356	#endif
	357	int desiredVisibleRows;
	358	unsigned int maxItemCharacters;
	359	unsigned int aveCharWidth;
	360	public:
	361	CallBackAction doubleClickAction;
	362	void *doubleClickActionData;
	363	public:
	364	ListBox();
	365	virtual ~ListBox();
	366	void Create(Window &parent, int ctrlID);
	367	virtual void SetFont(Font &font);
	368	void SetAverageCharWidth(int width);
	369	void SetVisibleRows(int rows);
	370	PRectangle GetDesiredRect();
	371	void Clear();
	372	void Append(char *s);
	373	int Length();
	374	void Select(int n);
	375	int GetSelection();
	376	int Find(const char *prefix);
	377	void GetValue(int n, char *value, int len);
	378	void Sort();
	379	void SetDoubleClickAction(CallBackAction action, void *data) {
	380	doubleClickAction = action;
	381	doubleClickActionData = data;
	382	}
	383	};
	384
	385	/**
	386	* Menu management.
	387	*/
	388	class Menu {
	389	MenuID id;
	390	public:
	391	Menu();
	392	MenuID GetID() { return id; }
	393	void CreatePopUp();
	394	void Destroy();
	395	void Show(Point pt, Window &w);
	396	};
	397
	398	class ElapsedTime {
	399	long bigBit;
	400	long littleBit;
	401	public:
	402	ElapsedTime();
	403	double Duration(bool reset=false);
	404	};
	405
	406	/**
	407	* Platform class used to retrieve system wide parameters such as double click speed
	408	* and chrome colour. Not a creatable object, more of a module with several functions.
	409	*/
	410	class Platform {
	411	// Private so Platform objects can not be copied
	412	Platform(const Platform &) {}
	413	Platform &operator=(const Platform &) { return *this; }
	414	public:
	415	// Should be private because no new Platforms are ever created
	416	// but gcc warns about this
	417	Platform() {}
	418	~Platform() {}
	419	static ColourDesired Chrome();
	420	static ColourDesired ChromeHighlight();
	421	static const char *DefaultFont();
	422	static int DefaultFontSize();
	423	static unsigned int DoubleClickTime();
	424	static void DebugDisplay(const char *s);
	425	static bool IsKeyDown(int key);
	426	static long SendScintilla(
	427	WindowID w, unsigned int msg, unsigned long wParam=0, long lParam=0);
	428	static bool IsDBCSLeadByte(int codePage, char ch);
	429
	430	// These are utility functions not really tied to a platform
	431	static int Minimum(int a, int b);
	432	static int Maximum(int a, int b);
	433	// Next three assume 16 bit shorts and 32 bit longs
	434	static long LongFromTwoShorts(short a,short b) {
	435	return (a) \| ((b) << 16);
	436	}
	437	static short HighShortFromLong(long x) {
	438	return static_cast<short>(x >> 16);
	439	}
	440	static short LowShortFromLong(long x) {
	441	return static_cast<short>(x & 0xffff);
	442	}
	443	static void DebugPrintf(const char *format, ...);
	444	static bool ShowAssertionPopUps(bool assertionPopUps_);
	445	static void Assert(const char c, const char file, int line);
	446	static int Clamp(int val, int minVal, int maxVal);
	447	};
	448
	449	#ifdef NDEBUG
	450	#define PLATFORM_ASSERT(c) ((void)0)
	451	#else
	452	#define PLATFORM_ASSERT(c) ((c) ? (void)(0) : Platform::Assert(#c, __FILE__, __LINE__))
	453	#endif
	454
	455	// Shut up annoying Visual C++ warnings:
	456	#ifdef _MSC_VER
	457	#pragma warning(disable: 4244 4309 4514 4710)
	458	#endif
	459
	460	#endif