src/stc/PlatWX.cpp

   1 // Scintilla source code edit control
   2 // PlatWX.cxx - implementation of platform facilities on wxWidgets
   3 // Copyright 1998-1999 by Neil Hodgson <neilh@scintilla.org>
   4 //                        Robin Dunn <robin@aldunn.com>
   5 // The License.txt file describes the conditions under which this software may be distributed.
   6
   7 // For compilers that support precompilation, includes "wx.h".
   8 #include "wx/wxprec.h"
   9
  10 #ifdef __BORLANDC__
  11     #pragma hdrstop
  12 #endif
  13
  14 #if wxUSE_STC
  15
  16 #ifndef WX_PRECOMP
  17     #include "wx/menu.h"
  18     #include "wx/dcmemory.h"
  19     #include "wx/settings.h"
  20 #endif // WX_PRECOMP
  21
  22 #include <ctype.h>
  23
  24 #if wxUSE_DISPLAY
  25 #include "wx/display.h"
  26 #endif
  27
  28 #include "wx/encconv.h"
  29 #include "wx/listctrl.h"
  30 #include "wx/mstream.h"
  31 #include "wx/image.h"
  32 #include "wx/imaglist.h"
  33 #include "wx/tokenzr.h"
  34
  35 #ifdef wxHAS_RAW_BITMAP
  36 #include "wx/rawbmp.h"
  37 #endif
  38 #if wxUSE_GRAPHICS_CONTEXT
  39 #include "wx/dcgraph.h"
  40 #endif
  41
  42 #include "Platform.h"
  43 #include "PlatWX.h"
  44 #include "wx/stc/stc.h"
  45 #include "wx/stc/private.h"
  46
  47
  48 Point Point::FromLong(long lpoint) {
  49     return Point(lpoint & 0xFFFF, lpoint >> 16);
  50 }
  51
  52 wxRect wxRectFromPRectangle(PRectangle prc) {
  53     wxRect r(prc.left, prc.top,
  54              prc.Width(), prc.Height());
  55     return r;
  56 }
  57
  58 PRectangle PRectangleFromwxRect(wxRect rc) {
  59     return PRectangle(rc.GetLeft(), rc.GetTop(),
  60                       rc.GetRight()+1, rc.GetBottom()+1);
  61 }
  62
  63 wxColour wxColourFromCD(ColourDesired& cd) {
  64     return wxColour((unsigned char)cd.GetRed(),
  65                     (unsigned char)cd.GetGreen(),
  66                     (unsigned char)cd.GetBlue());
  67 }
  68
  69 wxColour wxColourFromCDandAlpha(ColourDesired& cd, int alpha) {
  70     return wxColour((unsigned char)cd.GetRed(),
  71                     (unsigned char)cd.GetGreen(),
  72                     (unsigned char)cd.GetBlue(),
  73                     (unsigned char)alpha);
  74 }
  75
  76 //----------------------------------------------------------------------
  77
  78 Font::Font() {
  79     fid = 0;
  80     ascent = 0;
  81 }
  82
  83 Font::~Font() {
  84 }
  85
  86 void Font::Create(const FontParameters &fp) {
  87     Release();
  88
  89     // The minus one is done because since Scintilla uses SC_CHARSET_DEFAULT
  90     // internally and we need to have wxFONENCODING_DEFAULT == SC_SHARSET_DEFAULT
  91     // so we adjust the encoding before passing it to Scintilla.  See also
  92     // wxStyledTextCtrl::StyleSetCharacterSet
  93     wxFontEncoding encoding = (wxFontEncoding)(fp.characterSet-1);
  94
  95     wxFontEncodingArray ea = wxEncodingConverter::GetPlatformEquivalents(encoding);
  96     if (ea.GetCount())
  97         encoding = ea[0];
  98
  99     wxFontWeight weight;
 100     if (fp.weight <= 300)
 101         weight = wxFONTWEIGHT_LIGHT;
 102     else if (fp.weight >= 700)
 103         weight = wxFONTWEIGHT_BOLD;
 104     else
 105         weight = wxFONTWEIGHT_NORMAL;
 106
 107     wxFont* font = new wxFont(fp.size,
 108                               wxFONTFAMILY_DEFAULT,
 109                               fp.italic ? wxFONTSTYLE_ITALIC :  wxFONTSTYLE_NORMAL,
 110                               weight,
 111                               false,
 112                               stc2wx(fp.faceName),
 113                               encoding);
 114     fid = font;
 115 }
 116
 117
 118 void Font::Release() {
 119     if (fid)
 120         delete (wxFont*)fid;
 121     fid = 0;
 122 }
 123
 124 //----------------------------------------------------------------------
 125
 126 class SurfaceImpl : public Surface {
 127 private:
 128     wxDC*       hdc;
 129     bool        hdcOwned;
 130     wxBitmap*   bitmap;
 131     int         x;
 132     int         y;
 133     bool        unicodeMode;
 134
 135 public:
 136     SurfaceImpl();
 137     ~SurfaceImpl();
 138
 139     virtual void Init(WindowID wid);
 140     virtual void Init(SurfaceID sid, WindowID wid);
 141     virtual void InitPixMap(int width, int height, Surface *surface_, WindowID wid);
 142
 143     virtual void Release();
 144     virtual bool Initialised();
 145     virtual void PenColour(ColourDesired fore);
 146     virtual int LogPixelsY();
 147     virtual int DeviceHeightFont(int points);
 148     virtual void MoveTo(int x_, int y_);
 149     virtual void LineTo(int x_, int y_);
 150     virtual void Polygon(Point *pts, int npts, ColourDesired fore, ColourDesired back);
 151     virtual void RectangleDraw(PRectangle rc, ColourDesired fore, ColourDesired back);
 152     virtual void FillRectangle(PRectangle rc, ColourDesired back);
 153     virtual void FillRectangle(PRectangle rc, Surface &surfacePattern);
 154     virtual void RoundedRectangle(PRectangle rc, ColourDesired fore, ColourDesired back);
 155     virtual void AlphaRectangle(PRectangle rc, int cornerSize, ColourDesired fill, int alphaFill,
 156                                 ColourDesired outline, int alphaOutline, int flags);
 157     virtual void DrawRGBAImage(PRectangle rc, int width, int height,
 158                                const unsigned char *pixelsImage);
 159     virtual void Ellipse(PRectangle rc, ColourDesired fore, ColourDesired back);
 160     virtual void Copy(PRectangle rc, Point from, Surface &surfaceSource);
 161
 162     virtual void DrawTextNoClip(PRectangle rc, Font &font_, XYPOSITION ybase, const char *s, int len, ColourDesired fore, ColourDesired back);
 163     virtual void DrawTextClipped(PRectangle rc, Font &font_, XYPOSITION ybase, const char *s, int len, ColourDesired fore, ColourDesired back);
 164     virtual void DrawTextTransparent(PRectangle rc, Font &font_, XYPOSITION ybase, const char *s, int len, ColourDesired fore);
 165     virtual void MeasureWidths(Font &font_, const char *s, int len, XYPOSITION *positions);
 166     virtual XYPOSITION WidthText(Font &font_, const char *s, int len);
 167     virtual XYPOSITION WidthChar(Font &font_, char ch);
 168     virtual XYPOSITION Ascent(Font &font_);
 169     virtual XYPOSITION Descent(Font &font_);
 170     virtual XYPOSITION InternalLeading(Font &font_);
 171     virtual XYPOSITION ExternalLeading(Font &font_);
 172     virtual XYPOSITION Height(Font &font_);
 173     virtual XYPOSITION AverageCharWidth(Font &font_);
 174
 175     virtual void SetClip(PRectangle rc);
 176     virtual void FlushCachedState();
 177
 178     virtual void SetUnicodeMode(bool unicodeMode_);
 179     virtual void SetDBCSMode(int codePage);
 180
 181     void BrushColour(ColourDesired back);
 182     void SetFont(Font &font_);
 183 };
 184
 185
 186
 187 SurfaceImpl::SurfaceImpl() :
 188     hdc(0), hdcOwned(0), bitmap(0),
 189     x(0), y(0), unicodeMode(0)
 190 {}
 191
 192 SurfaceImpl::~SurfaceImpl() {
 193     Release();
 194 }
 195
 196 void SurfaceImpl::Init(WindowID wid) {
 197 #if 0
 198     Release();
 199     hdc = new wxMemoryDC();
 200     hdcOwned = true;
 201 #else
 202     // On Mac and GTK the DC is not really valid until it has a bitmap
 203     // selected into it.  So instead of just creating the DC with no bitmap,
 204     // go ahead and give it one.
 205     InitPixMap(1,1,NULL,wid);
 206 #endif
 207 }
 208
 209 void SurfaceImpl::Init(SurfaceID hdc_, WindowID) {
 210     Release();
 211     hdc = (wxDC*)hdc_;
 212 }
 213
 214 void SurfaceImpl::InitPixMap(int width, int height, Surface *WXUNUSED(surface_), WindowID) {
 215     Release();
 216     hdc = new wxMemoryDC();
 217     hdcOwned = true;
 218     if (width < 1) width = 1;
 219     if (height < 1) height = 1;
 220     bitmap = new wxBitmap(width, height);
 221     ((wxMemoryDC*)hdc)->SelectObject(*bitmap);
 222 }
 223
 224
 225 void SurfaceImpl::Release() {
 226     if (bitmap) {
 227         ((wxMemoryDC*)hdc)->SelectObject(wxNullBitmap);
 228         delete bitmap;
 229         bitmap = 0;
 230     }
 231     if (hdcOwned) {
 232         delete hdc;
 233         hdc = 0;
 234         hdcOwned = false;
 235     }
 236 }
 237
 238
 239 bool SurfaceImpl::Initialised() {
 240     return hdc != 0;
 241 }
 242
 243
 244 void SurfaceImpl::PenColour(ColourDesired fore) {
 245     hdc->SetPen(wxPen(wxColourFromCD(fore)));
 246 }
 247
 248 void SurfaceImpl::BrushColour(ColourDesired back) {
 249     hdc->SetBrush(wxBrush(wxColourFromCD(back)));
 250 }
 251
 252 void SurfaceImpl::SetFont(Font &font_) {
 253   if (font_.GetID()) {
 254       hdc->SetFont(*((wxFont*)font_.GetID()));
 255     }
 256 }
 257
 258 int SurfaceImpl::LogPixelsY() {
 259     return hdc->GetPPI().y;
 260 }
 261
 262 int SurfaceImpl::DeviceHeightFont(int points) {
 263     return points;
 264 }
 265
 266 void SurfaceImpl::MoveTo(int x_, int y_) {
 267     x = x_;
 268     y = y_;
 269 }
 270
 271 void SurfaceImpl::LineTo(int x_, int y_) {
 272     hdc->DrawLine(x,y, x_,y_);
 273     x = x_;
 274     y = y_;
 275 }
 276
 277 void SurfaceImpl::Polygon(Point *pts, int npts, ColourDesired fore, ColourDesired back) {
 278     PenColour(fore);
 279     BrushColour(back);
 280     hdc->DrawPolygon(npts, (wxPoint*)pts);
 281 }
 282
 283 void SurfaceImpl::RectangleDraw(PRectangle rc, ColourDesired fore, ColourDesired back) {
 284     PenColour(fore);
 285     BrushColour(back);
 286     hdc->DrawRectangle(wxRectFromPRectangle(rc));
 287 }
 288
 289 void SurfaceImpl::FillRectangle(PRectangle rc, ColourDesired back) {
 290     BrushColour(back);
 291     hdc->SetPen(*wxTRANSPARENT_PEN);
 292     hdc->DrawRectangle(wxRectFromPRectangle(rc));
 293 }
 294
 295 void SurfaceImpl::FillRectangle(PRectangle rc, Surface &surfacePattern) {
 296     wxBrush br;
 297     if (((SurfaceImpl&)surfacePattern).bitmap)
 298         br = wxBrush(*((SurfaceImpl&)surfacePattern).bitmap);
 299     else    // Something is wrong so display in red
 300         br = wxBrush(*wxRED);
 301     hdc->SetPen(*wxTRANSPARENT_PEN);
 302     hdc->SetBrush(br);
 303     hdc->DrawRectangle(wxRectFromPRectangle(rc));
 304 }
 305
 306 void SurfaceImpl::RoundedRectangle(PRectangle rc, ColourDesired fore, ColourDesired back) {
 307     PenColour(fore);
 308     BrushColour(back);
 309     hdc->DrawRoundedRectangle(wxRectFromPRectangle(rc), 4);
 310 }
 311
 312 #if defined(__WXMSW__) || defined(__WXMAC__)
 313 #define wxPy_premultiply(p, a)   ((p) * (a) / 0xff)
 314 #else
 315 #define wxPy_premultiply(p, a)   (p)
 316 #endif
 317
 318 void SurfaceImpl::AlphaRectangle(PRectangle rc, int cornerSize,
 319                                  ColourDesired fill, int alphaFill,
 320                                  ColourDesired outline, int alphaOutline,
 321                                  int /*flags*/) {
 322 #if wxUSE_GRAPHICS_CONTEXT
 323     wxGCDC dc(*(wxMemoryDC*)hdc);
 324     wxColour penColour(wxColourFromCDandAlpha(outline, alphaOutline));
 325     wxColour brushColour(wxColourFromCDandAlpha(fill, alphaFill));
 326     dc.SetPen(wxPen(penColour));
 327     dc.SetBrush(wxBrush(brushColour));
 328     dc.DrawRoundedRectangle(wxRectFromPRectangle(rc), cornerSize);
 329     return;
 330 #else
 331
 332 #ifdef wxHAS_RAW_BITMAP
 333
 334     // TODO:  do something with cornerSize
 335     wxUnusedVar(cornerSize);
 336
 337     int x, y;
 338     wxRect r = wxRectFromPRectangle(rc);
 339     wxBitmap bmp(r.width, r.height, 32);
 340     wxAlphaPixelData pixData(bmp);
 341
 342     // Set the fill pixels
 343     ColourDesired cdf(fill.AsLong());
 344     int red   = cdf.GetRed();
 345     int green = cdf.GetGreen();
 346     int blue  = cdf.GetBlue();
 347
 348     wxAlphaPixelData::Iterator p(pixData);
 349     for (y=0; y<r.height; y++) {
 350         p.MoveTo(pixData, 0, y);
 351         for (x=0; x<r.width; x++) {
 352             p.Red()   = wxPy_premultiply(red,   alphaFill);
 353             p.Green() = wxPy_premultiply(green, alphaFill);
 354             p.Blue()  = wxPy_premultiply(blue,  alphaFill);
 355             p.Alpha() = alphaFill;
 356             ++p;
 357         }
 358     }
 359
 360     // Set the outline pixels
 361     ColourDesired cdo(outline.AsLong());
 362     red   = cdo.GetRed();
 363     green = cdo.GetGreen();
 364     blue  = cdo.GetBlue();
 365     for (x=0; x<r.width; x++) {
 366         p.MoveTo(pixData, x, 0);
 367         p.Red()   = wxPy_premultiply(red,   alphaOutline);
 368         p.Green() = wxPy_premultiply(green, alphaOutline);
 369         p.Blue()  = wxPy_premultiply(blue,  alphaOutline);
 370         p.Alpha() = alphaOutline;
 371         p.MoveTo(pixData, x, r.height-1);
 372         p.Red()   = wxPy_premultiply(red,   alphaOutline);
 373         p.Green() = wxPy_premultiply(green, alphaOutline);
 374         p.Blue()  = wxPy_premultiply(blue,  alphaOutline);
 375         p.Alpha() = alphaOutline;
 376     }
 377
 378     for (y=0; y<r.height; y++) {
 379         p.MoveTo(pixData, 0, y);
 380         p.Red()   = wxPy_premultiply(red,   alphaOutline);
 381         p.Green() = wxPy_premultiply(green, alphaOutline);
 382         p.Blue()  = wxPy_premultiply(blue,  alphaOutline);
 383         p.Alpha() = alphaOutline;
 384         p.MoveTo(pixData, r.width-1, y);
 385         p.Red()   = wxPy_premultiply(red,   alphaOutline);
 386         p.Green() = wxPy_premultiply(green, alphaOutline);
 387         p.Blue()  = wxPy_premultiply(blue,  alphaOutline);
 388         p.Alpha() = alphaOutline;
 389     }
 390
 391     // Draw the bitmap
 392     hdc->DrawBitmap(bmp, r.x, r.y, true);
 393
 394 #else
 395     wxUnusedVar(cornerSize);
 396     wxUnusedVar(alphaFill);
 397     wxUnusedVar(alphaOutline);
 398     RectangleDraw(rc, outline, fill);
 399 #endif
 400 #endif
 401 }
 402
 403 #ifdef wxHAS_RAW_BITMAP
 404 wxBitmap BitmapFromRGBAImage(int width, int height, const unsigned char *pixelsImage)
 405 {
 406     int x, y;
 407     wxBitmap bmp(width, height, 32);
 408     wxAlphaPixelData pixData(bmp);
 409
 410     wxAlphaPixelData::Iterator p(pixData);
 411     for (y=0; y<height; y++) {
 412         p.MoveTo(pixData, 0, y);
 413         for (x=0; x<width; x++) {
 414             unsigned char red   = *pixelsImage++;
 415             unsigned char green = *pixelsImage++;
 416             unsigned char blue  = *pixelsImage++;
 417             unsigned char alpha = *pixelsImage++;
 418
 419             p.Red()   = wxPy_premultiply(red,   alpha);
 420             p.Green() = wxPy_premultiply(green, alpha);
 421             p.Blue()  = wxPy_premultiply(blue,  alpha);
 422             p.Alpha() = alpha;
 423             ++p;
 424         }
 425     }
 426     return bmp;
 427 }
 428 #endif
 429
 430
 431 void SurfaceImpl::DrawRGBAImage(PRectangle rc, int width, int height,
 432                                 const unsigned char *pixelsImage)
 433 {
 434 #ifdef wxHAS_RAW_BITMAP
 435     wxRect r = wxRectFromPRectangle(rc);
 436     wxBitmap bmp = BitmapFromRGBAImage(width, height, pixelsImage);
 437     hdc->DrawBitmap(bmp, r.x, r.y, true);
 438 #endif
 439 }
 440
 441
 442 void SurfaceImpl::Ellipse(PRectangle rc, ColourDesired fore, ColourDesired back) {
 443     PenColour(fore);
 444     BrushColour(back);
 445     hdc->DrawEllipse(wxRectFromPRectangle(rc));
 446 }
 447
 448 void SurfaceImpl::Copy(PRectangle rc, Point from, Surface &surfaceSource) {
 449     wxRect r = wxRectFromPRectangle(rc);
 450     hdc->Blit(r.x, r.y, r.width, r.height,
 451               ((SurfaceImpl&)surfaceSource).hdc,
 452               from.x, from.y, wxCOPY);
 453 }
 454
 455 void SurfaceImpl::DrawTextNoClip(PRectangle rc, Font &font, XYPOSITION ybase,
 456                                  const char *s, int len,
 457                                  ColourDesired fore, ColourDesired back) {
 458     SetFont(font);
 459     hdc->SetTextForeground(wxColourFromCD(fore));
 460     hdc->SetTextBackground(wxColourFromCD(back));
 461     FillRectangle(rc, back);
 462
 463     // ybase is where the baseline should be, but wxWin uses the upper left
 464     // corner, so I need to calculate the real position for the text...
 465     hdc->DrawText(stc2wx(s, len), rc.left, ybase - font.ascent);
 466 }
 467
 468 void SurfaceImpl::DrawTextClipped(PRectangle rc, Font &font, XYPOSITION ybase,
 469                                   const char *s, int len,
 470                                   ColourDesired fore, ColourDesired back) {
 471     SetFont(font);
 472     hdc->SetTextForeground(wxColourFromCD(fore));
 473     hdc->SetTextBackground(wxColourFromCD(back));
 474     FillRectangle(rc, back);
 475     hdc->SetClippingRegion(wxRectFromPRectangle(rc));
 476
 477     // see comments above
 478     hdc->DrawText(stc2wx(s, len), rc.left, ybase - font.ascent);
 479     hdc->DestroyClippingRegion();
 480 }
 481
 482
 483 void SurfaceImpl::DrawTextTransparent(PRectangle rc, Font &font, XYPOSITION ybase,
 484                                       const char *s, int len,
 485                                       ColourDesired fore) {
 486
 487     SetFont(font);
 488     hdc->SetTextForeground(wxColourFromCD(fore));
 489     hdc->SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT);
 490
 491     // ybase is where the baseline should be, but wxWin uses the upper left
 492     // corner, so I need to calculate the real position for the text...
 493     hdc->DrawText(stc2wx(s, len), rc.left, ybase - font.ascent);
 494
 495     hdc->SetBackgroundMode(wxBRUSHSTYLE_SOLID);
 496 }
 497
 498
 499 void SurfaceImpl::MeasureWidths(Font &font, const char *s, int len, XYPOSITION *positions) {
 500
 501     wxString   str = stc2wx(s, len);
 502     wxArrayInt tpos;
 503
 504     SetFont(font);
 505
 506     hdc->GetPartialTextExtents(str, tpos);
 507
 508 #if wxUSE_UNICODE
 509     // Map the widths for UCS-2 characters back to the UTF-8 input string
 510     // NOTE:  I don't think this is right for when sizeof(wxChar) > 2, ie wxGTK2
 511     // so figure it out and fix it!
 512     size_t i = 0;
 513     size_t ui = 0;
 514     while ((int)i < len) {
 515         unsigned char uch = (unsigned char)s[i];
 516         positions[i++] = tpos[ui];
 517         if (uch >= 0x80) {
 518             if (uch < (0x80 + 0x40 + 0x20)) {
 519                 positions[i++] = tpos[ui];
 520             } else {
 521                 positions[i++] = tpos[ui];
 522                 positions[i++] = tpos[ui];
 523             }
 524         }
 525         ui++;
 526     }
 527 #else
 528
 529     // If not unicode then just use the widths we have
 530 #if wxUSE_STD_CONTAINERS
 531     std::copy(tpos.begin(), tpos.end(), positions);
 532 #else
 533     memcpy(positions, tpos.begin(), len * sizeof(int));
 534 #endif
 535 #endif
 536 }
 537
 538
 539 XYPOSITION SurfaceImpl::WidthText(Font &font, const char *s, int len) {
 540     SetFont(font);
 541     int w;
 542     int h;
 543
 544     hdc->GetTextExtent(stc2wx(s, len), &w, &h);
 545     return w;
 546 }
 547
 548
 549 XYPOSITION SurfaceImpl::WidthChar(Font &font, char ch) {
 550     SetFont(font);
 551     int w;
 552     int h;
 553     char s[2] = { ch, 0 };
 554
 555     hdc->GetTextExtent(stc2wx(s, 1), &w, &h);
 556     return w;
 557 }
 558
 559 #define EXTENT_TEST wxT(" `~!@#$%^&*()-_=+\\|[]{};:\"\'<,>.?/1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
 560
 561 XYPOSITION SurfaceImpl::Ascent(Font &font) {
 562     SetFont(font);
 563     int w, h, d, e;
 564     hdc->GetTextExtent(EXTENT_TEST, &w, &h, &d, &e);
 565     font.ascent = h - d;
 566     return font.ascent;
 567 }
 568
 569 XYPOSITION SurfaceImpl::Descent(Font &font) {
 570     SetFont(font);
 571     int w, h, d, e;
 572     hdc->GetTextExtent(EXTENT_TEST, &w, &h, &d, &e);
 573     return d;
 574 }
 575
 576 XYPOSITION SurfaceImpl::InternalLeading(Font &WXUNUSED(font)) {
 577     return 0;
 578 }
 579
 580 XYPOSITION SurfaceImpl::ExternalLeading(Font &font) {
 581     SetFont(font);
 582     int w, h, d, e;
 583     hdc->GetTextExtent(EXTENT_TEST, &w, &h, &d, &e);
 584     return e;
 585 }
 586
 587 XYPOSITION SurfaceImpl::Height(Font &font) {
 588     SetFont(font);
 589     return hdc->GetCharHeight() + 1;
 590 }
 591
 592 XYPOSITION SurfaceImpl::AverageCharWidth(Font &font) {
 593     SetFont(font);
 594     return hdc->GetCharWidth();
 595 }
 596
 597 void SurfaceImpl::SetClip(PRectangle rc) {
 598     hdc->SetClippingRegion(wxRectFromPRectangle(rc));
 599 }
 600
 601 void SurfaceImpl::FlushCachedState() {
 602 }
 603
 604 void SurfaceImpl::SetUnicodeMode(bool unicodeMode_) {
 605     unicodeMode=unicodeMode_;
 606 }
 607
 608 void SurfaceImpl::SetDBCSMode(int WXUNUSED(codePage)) {
 609     // dbcsMode = codePage == SC_CP_DBCS;
 610 }
 611
 612
 613 Surface *Surface::Allocate(int WXUNUSED(technology)) {
 614     return new SurfaceImpl;
 615 }
 616
 617
 618 //----------------------------------------------------------------------
 619
 620
 621 inline wxWindow* GETWIN(WindowID id) { return (wxWindow*)id; }
 622
 623 Window::~Window() {
 624 }
 625
 626 void Window::Destroy() {
 627     if (wid) {
 628         Show(false);
 629         GETWIN(wid)->Destroy();
 630     }
 631     wid = 0;
 632 }
 633
 634 bool Window::HasFocus() {
 635     return wxWindow::FindFocus() == GETWIN(wid);
 636 }
 637
 638 PRectangle Window::GetPosition() {
 639     if (! wid) return PRectangle();
 640     wxRect rc(GETWIN(wid)->GetPosition(), GETWIN(wid)->GetSize());
 641     return PRectangleFromwxRect(rc);
 642 }
 643
 644 void Window::SetPosition(PRectangle rc) {
 645     wxRect r = wxRectFromPRectangle(rc);
 646     GETWIN(wid)->SetSize(r);
 647 }
 648
 649 void Window::SetPositionRelative(PRectangle rc, Window) {
 650     SetPosition(rc);  // ????
 651 }
 652
 653 PRectangle Window::GetClientPosition() {
 654     if (! wid) return PRectangle();
 655     wxSize sz = GETWIN(wid)->GetClientSize();
 656     return  PRectangle(0, 0, sz.x, sz.y);
 657 }
 658
 659 void Window::Show(bool show) {
 660     GETWIN(wid)->Show(show);
 661 }
 662
 663 void Window::InvalidateAll() {
 664     GETWIN(wid)->Refresh(false);
 665 }
 666
 667 void Window::InvalidateRectangle(PRectangle rc) {
 668     wxRect r = wxRectFromPRectangle(rc);
 669     GETWIN(wid)->Refresh(false, &r);
 670 }
 671
 672 void Window::SetFont(Font &font) {
 673     GETWIN(wid)->SetFont(*((wxFont*)font.GetID()));
 674 }
 675
 676 void Window::SetCursor(Cursor curs) {
 677     wxStockCursor cursorId;
 678
 679     switch (curs) {
 680     case cursorText:
 681         cursorId = wxCURSOR_IBEAM;
 682         break;
 683     case cursorArrow:
 684         cursorId = wxCURSOR_ARROW;
 685         break;
 686     case cursorUp:
 687         cursorId = wxCURSOR_ARROW; // ** no up arrow...  wxCURSOR_UPARROW;
 688         break;
 689     case cursorWait:
 690         cursorId = wxCURSOR_WAIT;
 691         break;
 692     case cursorHoriz:
 693         cursorId = wxCURSOR_SIZEWE;
 694         break;
 695     case cursorVert:
 696         cursorId = wxCURSOR_SIZENS;
 697         break;
 698     case cursorReverseArrow:
 699         cursorId = wxCURSOR_RIGHT_ARROW;
 700         break;
 701     case cursorHand:
 702         cursorId = wxCURSOR_HAND;
 703         break;
 704     default:
 705         cursorId = wxCURSOR_ARROW;
 706         break;
 707     }
 708
 709     wxCursor wc = wxCursor(cursorId);
 710     if(curs != cursorLast)
 711     {
 712         GETWIN(wid)->SetCursor(wc);
 713         cursorLast = curs;
 714     }
 715 }
 716
 717
 718 void Window::SetTitle(const char *s) {
 719     GETWIN(wid)->SetLabel(stc2wx(s));
 720 }
 721
 722
 723 // Returns rectangle of monitor pt is on
 724 PRectangle Window::GetMonitorRect(Point pt) {
 725     wxRect rect;
 726     if (! wid) return PRectangle();
 727 #if wxUSE_DISPLAY
 728     // Get the display the point is found on
 729     int n = wxDisplay::GetFromPoint(wxPoint(pt.x, pt.y));
 730     wxDisplay dpy(n == wxNOT_FOUND ? 0 : n);
 731     rect = dpy.GetGeometry();
 732 #else
 733     wxUnusedVar(pt);
 734 #endif
 735     return PRectangleFromwxRect(rect);
 736 }
 737
 738 //----------------------------------------------------------------------
 739 // Helper classes for ListBox
 740
 741
 742 // This is a simple subclass of wxListView that just resets focus to the
 743 // parent when it gets it.
 744 class wxSTCListBox : public wxListView {
 745 public:
 746     wxSTCListBox(wxWindow* parent, wxWindowID id,
 747                  const wxPoint& pos, const wxSize& size,
 748                  long style)
 749         : wxListView()
 750     {
 751 #ifdef __WXMSW__
 752         Hide(); // don't flicker as we move it around...
 753 #endif
 754         Create(parent, id, pos, size, style);
 755     }
 756
 757
 758     void OnFocus(wxFocusEvent& event) {
 759         GetParent()->SetFocus();
 760         event.Skip();
 761     }
 762
 763     void OnKillFocus(wxFocusEvent& WXUNUSED(event)) {
 764         // Do nothing.  Prevents base class from resetting the colors...
 765     }
 766
 767 #ifdef __WXMAC__
 768     // For some reason I don't understand yet the focus doesn't really leave
 769     // the listbox like it should, so if we get any events feed them back to
 770     // the wxSTC
 771     void OnKeyDown(wxKeyEvent& event) {
 772         GetGrandParent()->GetEventHandler()->ProcessEvent(event);
 773     }
 774     void OnChar(wxKeyEvent& event) {
 775         GetGrandParent()->GetEventHandler()->ProcessEvent(event);
 776     }
 777
 778     // And we need to force the focus back when being destroyed
 779     ~wxSTCListBox() {
 780         GetGrandParent()->SetFocus();
 781     }
 782 #endif
 783
 784 private:
 785     DECLARE_EVENT_TABLE()
 786 };
 787
 788 BEGIN_EVENT_TABLE(wxSTCListBox, wxListView)
 789     EVT_SET_FOCUS( wxSTCListBox::OnFocus)
 790     EVT_KILL_FOCUS(wxSTCListBox::OnKillFocus)
 791 #ifdef __WXMAC__
 792     EVT_KEY_DOWN(  wxSTCListBox::OnKeyDown)
 793     EVT_CHAR(      wxSTCListBox::OnChar)
 794 #endif
 795 END_EVENT_TABLE()
 796
 797
 798
 799 #if wxUSE_POPUPWIN //-----------------------------------
 800 #include "wx/popupwin.h"
 801
 802 // A popup window to place the wxSTCListBox upon
 803 class wxSTCListBoxWin : public wxPopupWindow
 804 {
 805 private:
 806     wxListView*         lv;
 807     CallBackAction      doubleClickAction;
 808     void*               doubleClickActionData;
 809 public:
 810     wxSTCListBoxWin(wxWindow* parent, wxWindowID id, Point WXUNUSED(location)) :
 811         wxPopupWindow(parent, wxBORDER_SIMPLE)
 812     {
 813
 814         lv = new wxSTCListBox(parent, id, wxPoint(-50,-50), wxDefaultSize,
 815                               wxLC_REPORT | wxLC_SINGLE_SEL | wxLC_NO_HEADER | wxBORDER_NONE);
 816         lv->SetCursor(wxCursor(wxCURSOR_ARROW));
 817         lv->InsertColumn(0, wxEmptyString);
 818         lv->InsertColumn(1, wxEmptyString);
 819
 820         // NOTE: We need to fool the wxListView into thinking that it has the
 821         // focus so it will use the normal selection colour and will look
 822         // "right" to the user.  But since the wxPopupWindow or its children
 823         // can't receive focus then we have to pull a fast one and temporarily
 824         // parent the listctrl on the STC window and then call SetFocus and
 825         // then reparent it back to the popup.
 826         lv->SetFocus();
 827         lv->Reparent(this);
 828 #ifdef __WXMSW__
 829         lv->Show();
 830 #endif
 831 #if defined(__WXOSX_COCOA__) || defined(__WXGTK__)
 832         // This color will end up being our border
 833         SetBackgroundColour(wxColour(0xC0, 0xC0, 0xC0));
 834 #endif
 835     }
 836
 837
 838     // Set position in client coords
 839     virtual void DoSetSize(int x, int y,
 840                            int width, int height,
 841                            int sizeFlags = wxSIZE_AUTO) {
 842         if (x != wxDefaultCoord) {
 843             GetParent()->ClientToScreen(&x, NULL);
 844         }
 845         if (y != wxDefaultCoord) {
 846             GetParent()->ClientToScreen(NULL, &y);
 847         }
 848         wxPopupWindow::DoSetSize(x, y, width, height, sizeFlags);
 849     }
 850
 851     // return position as if it were in client coords
 852     virtual void DoGetPosition( int *x, int *y ) const {
 853         int sx, sy;
 854         wxPopupWindow::DoGetPosition(&sx, &sy);
 855         GetParent()->ScreenToClient(&sx, &sy);
 856         if (x) *x = sx;
 857         if (y) *y = sy;
 858     }
 859
 860
 861     bool Destroy() {
 862         if ( !wxPendingDelete.Member(this) )
 863             wxPendingDelete.Append(this);
 864         return true;
 865     }
 866
 867
 868     int IconWidth() {
 869         wxImageList* il = lv->GetImageList(wxIMAGE_LIST_SMALL);
 870         if (il != NULL) {
 871             int w, h;
 872             il->GetSize(0, w, h);
 873             return w;
 874         }
 875         return 0;
 876     }
 877
 878
 879     void SetDoubleClickAction(CallBackAction action, void *data) {
 880         doubleClickAction = action;
 881         doubleClickActionData = data;
 882     }
 883
 884
 885     void OnFocus(wxFocusEvent& event) {
 886         GetParent()->SetFocus();
 887         event.Skip();
 888     }
 889
 890     void OnSize(wxSizeEvent& event) {
 891         // resize the child to fill the popup
 892         wxSize sz = GetClientSize();
 893         int x, y, w, h;
 894         x = y = 0;
 895         w = sz.x;
 896         h = sz.y;
 897 #if defined(__WXOSX_COCOA__) || defined(__WXGTK__)
 898         // make room for the parent's bg color to show, to act as a border
 899         x = y = 1;
 900         w -= 2;
 901         h -= 2;
 902 #endif
 903         lv->SetSize(x, y, w, h);
 904         // reset the column widths
 905         lv->SetColumnWidth(0, IconWidth()+4);
 906         lv->SetColumnWidth(1, w - 2 - lv->GetColumnWidth(0) -
 907                            wxSystemSettings::GetMetric(wxSYS_VSCROLL_X));
 908         event.Skip();
 909     }
 910
 911     void OnActivate(wxListEvent& WXUNUSED(event)) {
 912         doubleClickAction(doubleClickActionData);
 913     }
 914
 915     wxListView* GetLB() { return lv; }
 916
 917 private:
 918     DECLARE_EVENT_TABLE()
 919
 920 };
 921
 922 BEGIN_EVENT_TABLE(wxSTCListBoxWin, wxPopupWindow)
 923     EVT_SET_FOCUS          (          wxSTCListBoxWin::OnFocus)
 924     EVT_SIZE               (          wxSTCListBoxWin::OnSize)
 925     EVT_LIST_ITEM_ACTIVATED(wxID_ANY, wxSTCListBoxWin::OnActivate)
 926 END_EVENT_TABLE()
 927
 928
 929
 930 #else // !wxUSE_POPUPWIN -----------------------------------
 931 #include "wx/frame.h"
 932
 933 // A normal window to place the wxSTCListBox upon, but make it behave as much
 934 // like a wxPopupWindow as possible
 935 class wxSTCListBoxWin : public wxFrame {
 936 private:
 937     wxListView*         lv;
 938     CallBackAction      doubleClickAction;
 939     void*               doubleClickActionData;
 940 public:
 941     wxSTCListBoxWin(wxWindow* parent, wxWindowID id, Point location) :
 942         wxFrame(parent, id, wxEmptyString, wxPoint(location.x, location.y), wxSize(0,0),
 943                 wxFRAME_NO_TASKBAR
 944                 | wxFRAME_FLOAT_ON_PARENT
 945 #ifdef __WXMAC__
 946                 | wxPOPUP_WINDOW
 947                 | wxNO_BORDER
 948 #else
 949                 | wxSIMPLE_BORDER
 950 #endif
 951             )
 952     {
 953
 954         lv = new wxSTCListBox(this, id, wxDefaultPosition, wxDefaultSize,
 955                               wxLC_REPORT | wxLC_SINGLE_SEL | wxLC_NO_HEADER | wxNO_BORDER);
 956         lv->SetCursor(wxCursor(wxCURSOR_ARROW));
 957         lv->InsertColumn(0, wxEmptyString);
 958         lv->InsertColumn(1, wxEmptyString);
 959
 960         // Eventhough we immediately reset the focus to the parent, this helps
 961         // things to look right...
 962         lv->SetFocus();
 963
 964         Hide();
 965     }
 966
 967
 968     // On OSX and (possibly others) there can still be pending
 969     // messages/events for the list control when Scintilla wants to
 970     // close it, so do a pending delete of it instead of destroying
 971     // immediately.
 972     bool Destroy()
 973     {
 974 #ifdef __WXMAC__
 975         // The bottom edge of this window is not getting properly
 976         // refreshed upon deletion, so help it out...
 977         wxWindow* p = GetParent();
 978         wxRect r(GetPosition(), GetSize());
 979         r.SetHeight(r.GetHeight()+1);
 980         p->Refresh(false, &r);
 981 #endif
 982         if ( !wxPendingDelete.Member(this) )
 983             wxPendingDelete.Append(this);
 984         return true;
 985     }
 986
 987
 988     int IconWidth()
 989     {
 990         wxImageList* il = lv->GetImageList(wxIMAGE_LIST_SMALL);
 991         if (il != NULL) {
 992             int w, h;
 993             il->GetSize(0, w, h);
 994             return w;
 995         }
 996         return 0;
 997     }
 998
 999
1000     void SetDoubleClickAction(CallBackAction action, void *data)
1001     {
1002         doubleClickAction = action;
1003         doubleClickActionData = data;
1004     }
1005
1006
1007     void OnFocus(wxFocusEvent& event)
1008     {
1009         ActivateParent();
1010         GetParent()->SetFocus();
1011         event.Skip();
1012     }
1013
1014     void OnSize(wxSizeEvent& event)
1015     {
1016         // resize the child
1017         wxSize sz = GetClientSize();
1018         lv->SetSize(sz);
1019         // reset the column widths
1020         lv->SetColumnWidth(0, IconWidth()+4);
1021         lv->SetColumnWidth(1, sz.x - 2 - lv->GetColumnWidth(0) -
1022                            wxSystemSettings::GetMetric(wxSYS_VSCROLL_X));
1023         event.Skip();
1024     }
1025
1026     void ActivateParent()
1027     {
1028         // Although we're a frame, we always want the parent to be active, so
1029         // raise it whenever we get shown, focused, etc.
1030         wxTopLevelWindow *frame = wxDynamicCast(
1031             wxGetTopLevelParent(GetParent()), wxTopLevelWindow);
1032         if (frame)
1033             frame->Raise();
1034     }
1035
1036
1037     virtual void DoSetSize(int x, int y,
1038                            int width, int height,
1039                            int sizeFlags = wxSIZE_AUTO)
1040     {
1041         // convert coords to screen coords since we're a top-level window
1042         if (x != wxDefaultCoord) {
1043             GetParent()->ClientToScreen(&x, NULL);
1044         }
1045         if (y != wxDefaultCoord) {
1046             GetParent()->ClientToScreen(NULL, &y);
1047         }
1048         wxFrame::DoSetSize(x, y, width, height, sizeFlags);
1049     }
1050
1051     virtual bool Show(bool show = true)
1052     {
1053         bool rv = wxFrame::Show(show);
1054         if (rv && show)
1055             ActivateParent();
1056 #ifdef __WXMAC__
1057         GetParent()->Refresh(false);
1058 #endif
1059         return rv;
1060     }
1061
1062     void OnActivate(wxListEvent& WXUNUSED(event))
1063     {
1064         doubleClickAction(doubleClickActionData);
1065     }
1066
1067     wxListView* GetLB() { return lv; }
1068
1069 private:
1070     DECLARE_EVENT_TABLE()
1071 };
1072
1073
1074 BEGIN_EVENT_TABLE(wxSTCListBoxWin, wxWindow)
1075     EVT_SET_FOCUS          (          wxSTCListBoxWin::OnFocus)
1076     EVT_SIZE               (          wxSTCListBoxWin::OnSize)
1077     EVT_LIST_ITEM_ACTIVATED(wxID_ANY, wxSTCListBoxWin::OnActivate)
1078 END_EVENT_TABLE()
1079
1080 #endif // wxUSE_POPUPWIN -----------------------------------
1081
1082
1083 inline wxSTCListBoxWin* GETLBW(WindowID win) {
1084     return ((wxSTCListBoxWin*)win);
1085 }
1086
1087 inline wxListView* GETLB(WindowID win) {
1088     return GETLBW(win)->GetLB();
1089 }
1090
1091 //----------------------------------------------------------------------
1092
1093 class ListBoxImpl : public ListBox {
1094 private:
1095     int                 lineHeight;
1096     bool                unicodeMode;
1097     int                 desiredVisibleRows;
1098     int                 aveCharWidth;
1099     size_t              maxStrWidth;
1100     Point               location;       // Caret location at which the list is opened
1101     wxImageList*        imgList;
1102     wxArrayInt*         imgTypeMap;
1103
1104 public:
1105     ListBoxImpl();
1106     ~ListBoxImpl();
1107     static ListBox *Allocate();
1108
1109     virtual void SetFont(Font &font);
1110     virtual void Create(Window &parent, int ctrlID, Point location_, int lineHeight_, bool unicodeMode_, int technology_);
1111     virtual void SetAverageCharWidth(int width);
1112     virtual void SetVisibleRows(int rows);
1113     virtual int GetVisibleRows() const;
1114     virtual PRectangle GetDesiredRect();
1115     virtual int CaretFromEdge();
1116     virtual void Clear();
1117     virtual void Append(char *s, int type = -1);
1118             void Append(const wxString& text, int type);
1119     virtual int Length();
1120     virtual void Select(int n);
1121     virtual int GetSelection();
1122     virtual int Find(const char *prefix);
1123     virtual void GetValue(int n, char *value, int len);
1124     virtual void RegisterImage(int type, const char *xpm_data);
1125             void RegisterImageHelper(int type, wxBitmap& bmp);
1126     virtual void RegisterRGBAImage(int type, int width, int height, const unsigned char *pixelsImage);
1127     virtual void ClearRegisteredImages();
1128     virtual void SetDoubleClickAction(CallBackAction, void *);
1129     virtual void SetList(const char* list, char separator, char typesep);
1130 };
1131
1132
1133 ListBoxImpl::ListBoxImpl()
1134     : lineHeight(10), unicodeMode(false),
1135       desiredVisibleRows(5), aveCharWidth(8), maxStrWidth(0),
1136       imgList(NULL), imgTypeMap(NULL)
1137 {
1138 }
1139
1140 ListBoxImpl::~ListBoxImpl() {
1141     wxDELETE(imgList);
1142     wxDELETE(imgTypeMap);
1143 }
1144
1145
1146 void ListBoxImpl::SetFont(Font &font) {
1147     GETLB(wid)->SetFont(*((wxFont*)font.GetID()));
1148 }
1149
1150
1151 void ListBoxImpl::Create(Window &parent, int ctrlID, Point location_, int lineHeight_, bool unicodeMode_, int WXUNUSED(technology_)) {
1152     location = location_;
1153     lineHeight =  lineHeight_;
1154     unicodeMode = unicodeMode_;
1155     maxStrWidth = 0;
1156     wid = new wxSTCListBoxWin(GETWIN(parent.GetID()), ctrlID, location);
1157     if (imgList != NULL)
1158         GETLB(wid)->SetImageList(imgList, wxIMAGE_LIST_SMALL);
1159 }
1160
1161
1162 void ListBoxImpl::SetAverageCharWidth(int width) {
1163     aveCharWidth = width;
1164 }
1165
1166
1167 void ListBoxImpl::SetVisibleRows(int rows) {
1168     desiredVisibleRows = rows;
1169 }
1170
1171
1172 int ListBoxImpl::GetVisibleRows() const {
1173     return desiredVisibleRows;
1174 }
1175
1176 PRectangle ListBoxImpl::GetDesiredRect() {
1177     // wxListCtrl doesn't have a DoGetBestSize, so instead we kept track of
1178     // the max size in Append and calculate it here...
1179     int maxw = maxStrWidth * aveCharWidth;
1180     int maxh ;
1181
1182     // give it a default if there are no lines, and/or add a bit more
1183     if (maxw == 0) maxw = 100;
1184     maxw += aveCharWidth * 3 +
1185             GETLBW(wid)->IconWidth() + wxSystemSettings::GetMetric(wxSYS_VSCROLL_X);
1186     if (maxw > 350)
1187         maxw = 350;
1188
1189     // estimate a desired height
1190     int count = GETLB(wid)->GetItemCount();
1191     if (count) {
1192         wxRect rect;
1193         GETLB(wid)->GetItemRect(0, rect);
1194         maxh = count * rect.GetHeight();
1195         if (maxh > 140)  // TODO:  Use desiredVisibleRows??
1196             maxh = 140;
1197
1198         // Try to make the size an exact multiple of some number of lines
1199         int lines = maxh / rect.GetHeight();
1200         maxh = (lines + 1) * rect.GetHeight() + 2;
1201     }
1202     else
1203         maxh = 100;
1204
1205     PRectangle rc;
1206     rc.top = 0;
1207     rc.left = 0;
1208     rc.right = maxw;
1209     rc.bottom = maxh;
1210     return rc;
1211 }
1212
1213
1214 int ListBoxImpl::CaretFromEdge() {
1215     return 4 + GETLBW(wid)->IconWidth();
1216 }
1217
1218
1219 void ListBoxImpl::Clear() {
1220     GETLB(wid)->DeleteAllItems();
1221 }
1222
1223
1224 void ListBoxImpl::Append(char *s, int type) {
1225     Append(stc2wx(s), type);
1226 }
1227
1228 void ListBoxImpl::Append(const wxString& text, int type) {
1229     long count  = GETLB(wid)->GetItemCount();
1230     long itemID  = GETLB(wid)->InsertItem(count, wxEmptyString);
1231     long idx = -1;
1232     GETLB(wid)->SetItem(itemID, 1, text);
1233     maxStrWidth = wxMax(maxStrWidth, text.length());
1234     if (type != -1) {
1235         wxCHECK_RET(imgTypeMap, wxT("Unexpected NULL imgTypeMap"));
1236         idx = imgTypeMap->Item(type);
1237     }
1238     GETLB(wid)->SetItemImage(itemID, idx, idx);
1239 }
1240
1241 void ListBoxImpl::SetList(const char* list, char separator, char typesep) {
1242     GETLB(wid)->Freeze();
1243     Clear();
1244     wxStringTokenizer tkzr(stc2wx(list), (wxChar)separator);
1245     while ( tkzr.HasMoreTokens() ) {
1246         wxString token = tkzr.GetNextToken();
1247         long type = -1;
1248         int pos = token.Find(typesep);
1249         if (pos != -1) {
1250             token.Mid(pos+1).ToLong(&type);
1251             token.Truncate(pos);
1252         }
1253         Append(token, (int)type);
1254     }
1255     GETLB(wid)->Thaw();
1256 }
1257
1258
1259 int ListBoxImpl::Length() {
1260     return GETLB(wid)->GetItemCount();
1261 }
1262
1263
1264 void ListBoxImpl::Select(int n) {
1265     bool select = true;
1266     if (n == -1) {
1267         n = 0;
1268         select = false;
1269     }
1270     GETLB(wid)->EnsureVisible(n);
1271     GETLB(wid)->Select(n, select);
1272 }
1273
1274
1275 int ListBoxImpl::GetSelection() {
1276     return GETLB(wid)->GetFirstSelected();
1277 }
1278
1279
1280 int ListBoxImpl::Find(const char *WXUNUSED(prefix)) {
1281     // No longer used
1282     return wxNOT_FOUND;
1283 }
1284
1285
1286 void ListBoxImpl::GetValue(int n, char *value, int len) {
1287     wxListItem item;
1288     item.SetId(n);
1289     item.SetColumn(1);
1290     item.SetMask(wxLIST_MASK_TEXT);
1291     GETLB(wid)->GetItem(item);
1292     strncpy(value, wx2stc(item.GetText()), len);
1293     value[len-1] = '\0';
1294 }
1295
1296 void ListBoxImpl::RegisterImageHelper(int type, wxBitmap& bmp)
1297 {
1298     if (! imgList) {
1299         // assumes all images are the same size
1300         imgList = new wxImageList(bmp.GetWidth(), bmp.GetHeight(), true);
1301         imgTypeMap = new wxArrayInt;
1302     }
1303
1304     int idx = imgList->Add(bmp);
1305
1306     // do we need to extend the mapping array?
1307     wxArrayInt& itm = *imgTypeMap;
1308     if ( itm.GetCount() < (size_t)type+1)
1309         itm.Add(-1, type - itm.GetCount() + 1);
1310
1311     // Add an item that maps type to the image index
1312     itm[type] = idx;
1313 }
1314
1315 void ListBoxImpl::RegisterImage(int type, const char *xpm_data) {
1316     wxMemoryInputStream stream(xpm_data, strlen(xpm_data)+1);
1317     wxImage img(stream, wxBITMAP_TYPE_XPM);
1318     wxBitmap bmp(img);
1319     RegisterImageHelper(type, bmp);
1320 }
1321
1322
1323 void ListBoxImpl::RegisterRGBAImage(int type, int width, int height,
1324                                     const unsigned char *pixelsImage)
1325 {
1326 #ifdef wxHAS_RAW_BITMAP
1327     wxBitmap bmp = BitmapFromRGBAImage(width, height, pixelsImage);
1328     RegisterImageHelper(type, bmp);
1329 #endif
1330 }
1331
1332
1333 void ListBoxImpl::ClearRegisteredImages() {
1334     wxDELETE(imgList);
1335     wxDELETE(imgTypeMap);
1336     if (wid)
1337         GETLB(wid)->SetImageList(NULL, wxIMAGE_LIST_SMALL);
1338 }
1339
1340
1341 void ListBoxImpl::SetDoubleClickAction(CallBackAction action, void *data) {
1342     GETLBW(wid)->SetDoubleClickAction(action, data);
1343 }
1344
1345
1346 ListBox::ListBox() {
1347 }
1348
1349 ListBox::~ListBox() {
1350 }
1351
1352 ListBox *ListBox::Allocate() {
1353     return new ListBoxImpl();
1354 }
1355
1356 //----------------------------------------------------------------------
1357
1358 Menu::Menu() : mid(0) {
1359 }
1360
1361 void Menu::CreatePopUp() {
1362     Destroy();
1363     mid = new wxMenu();
1364 }
1365
1366 void Menu::Destroy() {
1367     if (mid)
1368         delete (wxMenu*)mid;
1369     mid = 0;
1370 }
1371
1372 void Menu::Show(Point pt, Window &w) {
1373     GETWIN(w.GetID())->PopupMenu((wxMenu*)mid, pt.x - 4, pt.y);
1374     Destroy();
1375 }
1376
1377 //----------------------------------------------------------------------
1378
1379 DynamicLibrary *DynamicLibrary::Load(const char *WXUNUSED(modulePath)) {
1380     wxFAIL_MSG(wxT("Dynamic lexer loading not implemented yet"));
1381     return NULL;
1382 }
1383
1384 //----------------------------------------------------------------------
1385
1386 ColourDesired Platform::Chrome() {
1387     wxColour c;
1388     c = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
1389     return ColourDesired(c.Red(), c.Green(), c.Blue());
1390 }
1391
1392 ColourDesired Platform::ChromeHighlight() {
1393     wxColour c;
1394     c = wxSystemSettings::GetColour(wxSYS_COLOUR_3DHIGHLIGHT);
1395     return ColourDesired(c.Red(), c.Green(), c.Blue());
1396 }
1397
1398 const char *Platform::DefaultFont() {
1399     static char buf[128];
1400     strcpy(buf, wxNORMAL_FONT->GetFaceName().mbc_str());
1401     return buf;
1402 }
1403
1404 int Platform::DefaultFontSize() {
1405     return wxNORMAL_FONT->GetPointSize();
1406 }
1407
1408 unsigned int Platform::DoubleClickTime() {
1409     return 500;   // **** ::GetDoubleClickTime();
1410 }
1411
1412 bool Platform::MouseButtonBounce() {
1413     return false;
1414 }
1415
1416 bool Platform::IsKeyDown(int WXUNUSED(key)) {
1417     return false;  // I don't think we'll need this.
1418 }
1419
1420 long Platform::SendScintilla(WindowID w,
1421                              unsigned int msg,
1422                              unsigned long wParam,
1423                              long lParam) {
1424
1425     wxStyledTextCtrl* stc = (wxStyledTextCtrl*)w;
1426     return stc->SendMsg(msg, wParam, lParam);
1427 }
1428
1429 long Platform::SendScintillaPointer(WindowID w,
1430                                     unsigned int msg,
1431                                     unsigned long wParam,
1432                                     void *lParam) {
1433
1434     wxStyledTextCtrl* stc = (wxStyledTextCtrl*)w;
1435     return stc->SendMsg(msg, wParam, (wxIntPtr)lParam);
1436 }
1437
1438
1439 // These are utility functions not really tied to a platform
1440
1441 int Platform::Minimum(int a, int b) {
1442     if (a < b)
1443         return a;
1444     else
1445         return b;
1446 }
1447
1448 int Platform::Maximum(int a, int b) {
1449     if (a > b)
1450         return a;
1451     else
1452         return b;
1453 }
1454
1455 //#define TRACE
1456
1457 void Platform::DebugDisplay(const char *s) {
1458 #ifdef TRACE
1459     wxLogDebug(stc2wx(s));
1460 #else
1461     wxUnusedVar(s);
1462 #endif
1463 }
1464
1465 void Platform::DebugPrintf(const char *format, ...) {
1466 #ifdef TRACE
1467     char buffer[2000];
1468     va_list pArguments;
1469     va_start(pArguments, format);
1470     vsprintf(buffer,format,pArguments);
1471     va_end(pArguments);
1472     Platform::DebugDisplay(buffer);
1473 #else
1474     wxUnusedVar(format);
1475 #endif
1476 }
1477
1478
1479 static bool assertionPopUps = true;
1480
1481 bool Platform::ShowAssertionPopUps(bool assertionPopUps_) {
1482     bool ret = assertionPopUps;
1483     assertionPopUps = assertionPopUps_;
1484     return ret;
1485 }
1486
1487 void Platform::Assert(const char *c, const char *file, int line) {
1488 #ifdef TRACE
1489     char buffer[2000];
1490     sprintf(buffer, "Assertion [%s] failed at %s %d", c, file, line);
1491     if (assertionPopUps) {
1492         /*int idButton = */
1493         wxMessageBox(stc2wx(buffer),
1494                      wxT("Assertion failure"),
1495                      wxICON_HAND | wxOK);
1496     } else {
1497         strcat(buffer, "\r\n");
1498         Platform::DebugDisplay(buffer);
1499         abort();
1500     }
1501 #else
1502     wxUnusedVar(c);
1503     wxUnusedVar(file);
1504     wxUnusedVar(line);
1505 #endif
1506 }
1507
1508
1509 int Platform::Clamp(int val, int minVal, int maxVal) {
1510     if (val > maxVal)
1511         val = maxVal;
1512     if (val < minVal)
1513         val = minVal;
1514     return val;
1515 }
1516
1517
1518 bool Platform::IsDBCSLeadByte(int WXUNUSED(codePage), char WXUNUSED(ch)) {
1519     return false;
1520 }
1521
1522 int Platform::DBCSCharLength(int WXUNUSED(codePage), const char *WXUNUSED(s)) {
1523     return 1;
1524 }
1525
1526 int Platform::DBCSCharMaxLength() {
1527     return 1;
1528 }
1529
1530
1531 //----------------------------------------------------------------------
1532
1533 ElapsedTime::ElapsedTime() {
1534     wxLongLong localTime = wxGetLocalTimeMillis();
1535     littleBit = localTime.GetLo();
1536     bigBit = localTime.GetHi();
1537 }
1538
1539 double ElapsedTime::Duration(bool reset) {
1540     wxLongLong prevTime(bigBit, littleBit);
1541     wxLongLong localTime = wxGetLocalTimeMillis();
1542     if(reset) {
1543         littleBit = localTime.GetLo();
1544         bigBit = localTime.GetHi();
1545     }
1546     wxLongLong duration = localTime - prevTime;
1547     double result = duration.ToDouble();
1548     result /= 1000.0;
1549     return result;
1550 }
1551
1552
1553 //----------------------------------------------------------------------
1554
1555 #if wxUSE_UNICODE
1556
1557 #include "UniConversion.h"
1558
1559 // Convert using Scintilla's functions instead of wx's, Scintilla's are more
1560 // forgiving and won't assert...
1561
1562 wxString stc2wx(const char* str, size_t len)
1563 {
1564     if (!len)
1565         return wxEmptyString;
1566
1567     size_t wclen = UTF16Length(str, len);
1568     wxWCharBuffer buffer(wclen+1);
1569
1570     size_t actualLen = UTF16FromUTF8(str, len, buffer.data(), wclen+1);
1571     return wxString(buffer.data(), actualLen);
1572 }
1573
1574
1575
1576 wxString stc2wx(const char* str)
1577 {
1578     return stc2wx(str, strlen(str));
1579 }
1580
1581
1582 wxWX2MBbuf wx2stc(const wxString& str)
1583 {
1584     const wchar_t* wcstr = str.c_str();
1585     size_t wclen         = str.length();
1586     size_t len           = UTF8Length(wcstr, wclen);
1587
1588     wxCharBuffer buffer(len+1);
1589     UTF8FromUTF16(wcstr, wclen, buffer.data(), len);
1590
1591     // TODO check NULL termination!!
1592
1593     return buffer;
1594 }
1595
1596 #endif
1597
1598 #endif // wxUSE_STC