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