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