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 #ifdef __WXOSX_COCOA__
 832         SetBackgroundColour(wxColour(0xC0, 0xC0, 0xC0));
 833 #endif
 834     }
 835
 836
 837     // Set position in client coords
 838     virtual void DoSetSize(int x, int y,
 839                            int width, int height,
 840                            int sizeFlags = wxSIZE_AUTO) {
 841         if (x != wxDefaultCoord) {
 842             GetParent()->ClientToScreen(&x, NULL);
 843         }
 844         if (y != wxDefaultCoord) {
 845             GetParent()->ClientToScreen(NULL, &y);
 846         }
 847         wxPopupWindow::DoSetSize(x, y, width, height, sizeFlags);
 848     }
 849
 850     // return position as if it were in client coords
 851     virtual void DoGetPosition( int *x, int *y ) const {
 852         int sx, sy;
 853         wxPopupWindow::DoGetPosition(&sx, &sy);
 854         GetParent()->ScreenToClient(&sx, &sy);
 855         if (x) *x = sx;
 856         if (y) *y = sy;
 857     }
 858
 859
 860     bool Destroy() {
 861         if ( !wxPendingDelete.Member(this) )
 862             wxPendingDelete.Append(this);
 863         return true;
 864     }
 865
 866
 867     int IconWidth() {
 868         wxImageList* il = lv->GetImageList(wxIMAGE_LIST_SMALL);
 869         if (il != NULL) {
 870             int w, h;
 871             il->GetSize(0, w, h);
 872             return w;
 873         }
 874         return 0;
 875     }
 876
 877
 878     void SetDoubleClickAction(CallBackAction action, void *data) {
 879         doubleClickAction = action;
 880         doubleClickActionData = data;
 881     }
 882
 883
 884     void OnFocus(wxFocusEvent& event) {
 885         GetParent()->SetFocus();
 886         event.Skip();
 887     }
 888
 889     void OnSize(wxSizeEvent& event) {
 890         // resize the child to fill the popup
 891         wxSize sz = GetClientSize();
 892         int x, y, w, h;
 893         x = y = 0;
 894         w = sz.x;
 895         h = sz.y;
 896 #ifdef __WXOSX_COCOA__
 897         // make room for the parent's bg color to show, to act as a border
 898         x = y = 1;
 899         w -= 2;
 900         h -= 2;
 901 #endif
 902         lv->SetSize(x, y, w, h);
 903         // reset the column widths
 904         lv->SetColumnWidth(0, IconWidth()+4);
 905         lv->SetColumnWidth(1, w - 2 - lv->GetColumnWidth(0) -
 906                            wxSystemSettings::GetMetric(wxSYS_VSCROLL_X));
 907         event.Skip();
 908     }
 909
 910     void OnActivate(wxListEvent& WXUNUSED(event)) {
 911         doubleClickAction(doubleClickActionData);
 912     }
 913
 914     wxListView* GetLB() { return lv; }
 915
 916 private:
 917     DECLARE_EVENT_TABLE()
 918
 919 };
 920
 921 BEGIN_EVENT_TABLE(wxSTCListBoxWin, wxPopupWindow)
 922     EVT_SET_FOCUS          (          wxSTCListBoxWin::OnFocus)
 923     EVT_SIZE               (          wxSTCListBoxWin::OnSize)
 924     EVT_LIST_ITEM_ACTIVATED(wxID_ANY, wxSTCListBoxWin::OnActivate)
 925 END_EVENT_TABLE()
 926
 927
 928
 929 #else // !wxUSE_POPUPWIN -----------------------------------
 930 #include "wx/frame.h"
 931
 932 // A normal window to place the wxSTCListBox upon, but make it behave as much
 933 // like a wxPopupWindow as possible
 934 class wxSTCListBoxWin : public wxFrame {
 935 private:
 936     wxListView*         lv;
 937     CallBackAction      doubleClickAction;
 938     void*               doubleClickActionData;
 939 public:
 940     wxSTCListBoxWin(wxWindow* parent, wxWindowID id, Point location) :
 941         wxFrame(parent, id, wxEmptyString, wxPoint(location.x, location.y), wxSize(0,0),
 942                 wxFRAME_NO_TASKBAR
 943                 | wxFRAME_FLOAT_ON_PARENT
 944 #ifdef __WXMAC__
 945                 | wxPOPUP_WINDOW
 946                 | wxNO_BORDER
 947 #else
 948                 | wxSIMPLE_BORDER
 949 #endif
 950             )
 951     {
 952
 953         lv = new wxSTCListBox(this, id, wxDefaultPosition, wxDefaultSize,
 954                               wxLC_REPORT | wxLC_SINGLE_SEL | wxLC_NO_HEADER | wxNO_BORDER);
 955         lv->SetCursor(wxCursor(wxCURSOR_ARROW));
 956         lv->InsertColumn(0, wxEmptyString);
 957         lv->InsertColumn(1, wxEmptyString);
 958
 959         // Eventhough we immediately reset the focus to the parent, this helps
 960         // things to look right...
 961         lv->SetFocus();
 962
 963         Hide();
 964     }
 965
 966
 967     // On OSX and (possibly others) there can still be pending
 968     // messages/events for the list control when Scintilla wants to
 969     // close it, so do a pending delete of it instead of destroying
 970     // immediately.
 971     bool Destroy()
 972     {
 973 #ifdef __WXMAC__
 974         // The bottom edge of this window is not getting properly
 975         // refreshed upon deletion, so help it out...
 976         wxWindow* p = GetParent();
 977         wxRect r(GetPosition(), GetSize());
 978         r.SetHeight(r.GetHeight()+1);
 979         p->Refresh(false, &r);
 980 #endif
 981         if ( !wxPendingDelete.Member(this) )
 982             wxPendingDelete.Append(this);
 983         return true;
 984     }
 985
 986
 987     int IconWidth()
 988     {
 989         wxImageList* il = lv->GetImageList(wxIMAGE_LIST_SMALL);
 990         if (il != NULL) {
 991             int w, h;
 992             il->GetSize(0, w, h);
 993             return w;
 994         }
 995         return 0;
 996     }
 997
 998
 999     void SetDoubleClickAction(CallBackAction action, void *data)
1000     {
1001         doubleClickAction = action;
1002         doubleClickActionData = data;
1003     }
1004
1005
1006     void OnFocus(wxFocusEvent& event)
1007     {
1008         ActivateParent();
1009         GetParent()->SetFocus();
1010         event.Skip();
1011     }
1012
1013     void OnSize(wxSizeEvent& event)
1014     {
1015         // resize the child
1016         wxSize sz = GetClientSize();
1017         lv->SetSize(sz);
1018         // reset the column widths
1019         lv->SetColumnWidth(0, IconWidth()+4);
1020         lv->SetColumnWidth(1, sz.x - 2 - lv->GetColumnWidth(0) -
1021                            wxSystemSettings::GetMetric(wxSYS_VSCROLL_X));
1022         event.Skip();
1023     }
1024
1025     void ActivateParent()
1026     {
1027         // Although we're a frame, we always want the parent to be active, so
1028         // raise it whenever we get shown, focused, etc.
1029         wxTopLevelWindow *frame = wxDynamicCast(
1030             wxGetTopLevelParent(GetParent()), wxTopLevelWindow);
1031         if (frame)
1032             frame->Raise();
1033     }
1034
1035
1036     virtual void DoSetSize(int x, int y,
1037                            int width, int height,
1038                            int sizeFlags = wxSIZE_AUTO)
1039     {
1040         // convert coords to screen coords since we're a top-level window
1041         if (x != wxDefaultCoord) {
1042             GetParent()->ClientToScreen(&x, NULL);
1043         }
1044         if (y != wxDefaultCoord) {
1045             GetParent()->ClientToScreen(NULL, &y);
1046         }
1047         wxFrame::DoSetSize(x, y, width, height, sizeFlags);
1048     }
1049
1050     virtual bool Show(bool show = true)
1051     {
1052         bool rv = wxFrame::Show(show);
1053         if (rv && show)
1054             ActivateParent();
1055 #ifdef __WXMAC__
1056         GetParent()->Refresh(false);
1057 #endif
1058         return rv;
1059     }
1060
1061     void OnActivate(wxListEvent& WXUNUSED(event))
1062     {
1063         doubleClickAction(doubleClickActionData);
1064     }
1065
1066     wxListView* GetLB() { return lv; }
1067
1068 private:
1069     DECLARE_EVENT_TABLE()
1070 };
1071
1072
1073 BEGIN_EVENT_TABLE(wxSTCListBoxWin, wxWindow)
1074     EVT_SET_FOCUS          (          wxSTCListBoxWin::OnFocus)
1075     EVT_SIZE               (          wxSTCListBoxWin::OnSize)
1076     EVT_LIST_ITEM_ACTIVATED(wxID_ANY, wxSTCListBoxWin::OnActivate)
1077 END_EVENT_TABLE()
1078
1079 #endif // wxUSE_POPUPWIN -----------------------------------
1080
1081
1082 inline wxSTCListBoxWin* GETLBW(WindowID win) {
1083     return ((wxSTCListBoxWin*)win);
1084 }
1085
1086 inline wxListView* GETLB(WindowID win) {
1087     return GETLBW(win)->GetLB();
1088 }
1089
1090 //----------------------------------------------------------------------
1091
1092 class ListBoxImpl : public ListBox {
1093 private:
1094     int                 lineHeight;
1095     bool                unicodeMode;
1096     int                 desiredVisibleRows;
1097     int                 aveCharWidth;
1098     size_t              maxStrWidth;
1099     Point               location;       // Caret location at which the list is opened
1100     wxImageList*        imgList;
1101     wxArrayInt*         imgTypeMap;
1102
1103 public:
1104     ListBoxImpl();
1105     ~ListBoxImpl();
1106     static ListBox *Allocate();
1107
1108     virtual void SetFont(Font &font);
1109     virtual void Create(Window &parent, int ctrlID, Point location_, int lineHeight_, bool unicodeMode_, int technology_);
1110     virtual void SetAverageCharWidth(int width);
1111     virtual void SetVisibleRows(int rows);
1112     virtual int GetVisibleRows() const;
1113     virtual PRectangle GetDesiredRect();
1114     virtual int CaretFromEdge();
1115     virtual void Clear();
1116     virtual void Append(char *s, int type = -1);
1117             void Append(const wxString& text, int type);
1118     virtual int Length();
1119     virtual void Select(int n);
1120     virtual int GetSelection();
1121     virtual int Find(const char *prefix);
1122     virtual void GetValue(int n, char *value, int len);
1123     virtual void RegisterImage(int type, const char *xpm_data);
1124             void RegisterImageHelper(int type, wxBitmap& bmp);
1125     virtual void RegisterRGBAImage(int type, int width, int height, const unsigned char *pixelsImage);
1126     virtual void ClearRegisteredImages();
1127     virtual void SetDoubleClickAction(CallBackAction, void *);
1128     virtual void SetList(const char* list, char separator, char typesep);
1129 };
1130
1131
1132 ListBoxImpl::ListBoxImpl()
1133     : lineHeight(10), unicodeMode(false),
1134       desiredVisibleRows(5), aveCharWidth(8), maxStrWidth(0),
1135       imgList(NULL), imgTypeMap(NULL)
1136 {
1137 }
1138
1139 ListBoxImpl::~ListBoxImpl() {
1140     wxDELETE(imgList);
1141     wxDELETE(imgTypeMap);
1142 }
1143
1144
1145 void ListBoxImpl::SetFont(Font &font) {
1146     GETLB(wid)->SetFont(*((wxFont*)font.GetID()));
1147 }
1148
1149
1150 void ListBoxImpl::Create(Window &parent, int ctrlID, Point location_, int lineHeight_, bool unicodeMode_, int WXUNUSED(technology_)) {
1151     location = location_;
1152     lineHeight =  lineHeight_;
1153     unicodeMode = unicodeMode_;
1154     maxStrWidth = 0;
1155     wid = new wxSTCListBoxWin(GETWIN(parent.GetID()), ctrlID, location);
1156     if (imgList != NULL)
1157         GETLB(wid)->SetImageList(imgList, wxIMAGE_LIST_SMALL);
1158 }
1159
1160
1161 void ListBoxImpl::SetAverageCharWidth(int width) {
1162     aveCharWidth = width;
1163 }
1164
1165
1166 void ListBoxImpl::SetVisibleRows(int rows) {
1167     desiredVisibleRows = rows;
1168 }
1169
1170
1171 int ListBoxImpl::GetVisibleRows() const {
1172     return desiredVisibleRows;
1173 }
1174
1175 PRectangle ListBoxImpl::GetDesiredRect() {
1176     // wxListCtrl doesn't have a DoGetBestSize, so instead we kept track of
1177     // the max size in Append and calculate it here...
1178     int maxw = maxStrWidth * aveCharWidth;
1179     int maxh ;
1180
1181     // give it a default if there are no lines, and/or add a bit more
1182     if (maxw == 0) maxw = 100;
1183     maxw += aveCharWidth * 3 +
1184             GETLBW(wid)->IconWidth() + wxSystemSettings::GetMetric(wxSYS_VSCROLL_X);
1185     if (maxw > 350)
1186         maxw = 350;
1187
1188     // estimate a desired height
1189     int count = GETLB(wid)->GetItemCount();
1190     if (count) {
1191         wxRect rect;
1192         GETLB(wid)->GetItemRect(0, rect);
1193         maxh = count * rect.GetHeight();
1194         if (maxh > 140)  // TODO:  Use desiredVisibleRows??
1195             maxh = 140;
1196
1197         // Try to make the size an exact multiple of some number of lines
1198         int lines = maxh / rect.GetHeight();
1199         maxh = (lines + 1) * rect.GetHeight() + 2;
1200     }
1201     else
1202         maxh = 100;
1203
1204     PRectangle rc;
1205     rc.top = 0;
1206     rc.left = 0;
1207     rc.right = maxw;
1208     rc.bottom = maxh;
1209     return rc;
1210 }
1211
1212
1213 int ListBoxImpl::CaretFromEdge() {
1214     return 4 + GETLBW(wid)->IconWidth();
1215 }
1216
1217
1218 void ListBoxImpl::Clear() {
1219     GETLB(wid)->DeleteAllItems();
1220 }
1221
1222
1223 void ListBoxImpl::Append(char *s, int type) {
1224     Append(stc2wx(s), type);
1225 }
1226
1227 void ListBoxImpl::Append(const wxString& text, int type) {
1228     long count  = GETLB(wid)->GetItemCount();
1229     long itemID  = GETLB(wid)->InsertItem(count, wxEmptyString);
1230     long idx = -1;
1231     GETLB(wid)->SetItem(itemID, 1, text);
1232     maxStrWidth = wxMax(maxStrWidth, text.length());
1233     if (type != -1) {
1234         wxCHECK_RET(imgTypeMap, wxT("Unexpected NULL imgTypeMap"));
1235         idx = imgTypeMap->Item(type);
1236     }
1237     GETLB(wid)->SetItemImage(itemID, idx, idx);
1238 }
1239
1240 void ListBoxImpl::SetList(const char* list, char separator, char typesep) {
1241     GETLB(wid)->Freeze();
1242     Clear();
1243     wxStringTokenizer tkzr(stc2wx(list), (wxChar)separator);
1244     while ( tkzr.HasMoreTokens() ) {
1245         wxString token = tkzr.GetNextToken();
1246         long type = -1;
1247         int pos = token.Find(typesep);
1248         if (pos != -1) {
1249             token.Mid(pos+1).ToLong(&type);
1250             token.Truncate(pos);
1251         }
1252         Append(token, (int)type);
1253     }
1254     GETLB(wid)->Thaw();
1255 }
1256
1257
1258 int ListBoxImpl::Length() {
1259     return GETLB(wid)->GetItemCount();
1260 }
1261
1262
1263 void ListBoxImpl::Select(int n) {
1264     bool select = true;
1265     if (n == -1) {
1266         n = 0;
1267         select = false;
1268     }
1269     GETLB(wid)->EnsureVisible(n);
1270     GETLB(wid)->Select(n, select);
1271 }
1272
1273
1274 int ListBoxImpl::GetSelection() {
1275     return GETLB(wid)->GetFirstSelected();
1276 }
1277
1278
1279 int ListBoxImpl::Find(const char *WXUNUSED(prefix)) {
1280     // No longer used
1281     return wxNOT_FOUND;
1282 }
1283
1284
1285 void ListBoxImpl::GetValue(int n, char *value, int len) {
1286     wxListItem item;
1287     item.SetId(n);
1288     item.SetColumn(1);
1289     item.SetMask(wxLIST_MASK_TEXT);
1290     GETLB(wid)->GetItem(item);
1291     strncpy(value, wx2stc(item.GetText()), len);
1292     value[len-1] = '\0';
1293 }
1294
1295 void ListBoxImpl::RegisterImageHelper(int type, wxBitmap& bmp)
1296 {
1297     if (! imgList) {
1298         // assumes all images are the same size
1299         imgList = new wxImageList(bmp.GetWidth(), bmp.GetHeight(), true);
1300         imgTypeMap = new wxArrayInt;
1301     }
1302
1303     int idx = imgList->Add(bmp);
1304
1305     // do we need to extend the mapping array?
1306     wxArrayInt& itm = *imgTypeMap;
1307     if ( itm.GetCount() < (size_t)type+1)
1308         itm.Add(-1, type - itm.GetCount() + 1);
1309
1310     // Add an item that maps type to the image index
1311     itm[type] = idx;
1312 }
1313
1314 void ListBoxImpl::RegisterImage(int type, const char *xpm_data) {
1315     wxMemoryInputStream stream(xpm_data, strlen(xpm_data)+1);
1316     wxImage img(stream, wxBITMAP_TYPE_XPM);
1317     wxBitmap bmp(img);
1318     RegisterImageHelper(type, bmp);
1319 }
1320
1321
1322 void ListBoxImpl::RegisterRGBAImage(int type, int width, int height,
1323                                     const unsigned char *pixelsImage)
1324 {
1325     wxBitmap bmp = BitmapFromRGBAImage(width, height, pixelsImage);
1326     RegisterImageHelper(type, bmp);
1327 }
1328
1329
1330 void ListBoxImpl::ClearRegisteredImages() {
1331     wxDELETE(imgList);
1332     wxDELETE(imgTypeMap);
1333     if (wid)
1334         GETLB(wid)->SetImageList(NULL, wxIMAGE_LIST_SMALL);
1335 }
1336
1337
1338 void ListBoxImpl::SetDoubleClickAction(CallBackAction action, void *data) {
1339     GETLBW(wid)->SetDoubleClickAction(action, data);
1340 }
1341
1342
1343 ListBox::ListBox() {
1344 }
1345
1346 ListBox::~ListBox() {
1347 }
1348
1349 ListBox *ListBox::Allocate() {
1350     return new ListBoxImpl();
1351 }
1352
1353 //----------------------------------------------------------------------
1354
1355 Menu::Menu() : mid(0) {
1356 }
1357
1358 void Menu::CreatePopUp() {
1359     Destroy();
1360     mid = new wxMenu();
1361 }
1362
1363 void Menu::Destroy() {
1364     if (mid)
1365         delete (wxMenu*)mid;
1366     mid = 0;
1367 }
1368
1369 void Menu::Show(Point pt, Window &w) {
1370     GETWIN(w.GetID())->PopupMenu((wxMenu*)mid, pt.x - 4, pt.y);
1371     Destroy();
1372 }
1373
1374 //----------------------------------------------------------------------
1375
1376 DynamicLibrary *DynamicLibrary::Load(const char *WXUNUSED(modulePath)) {
1377     wxFAIL_MSG(wxT("Dynamic lexer loading not implemented yet"));
1378     return NULL;
1379 }
1380
1381 //----------------------------------------------------------------------
1382
1383 ColourDesired Platform::Chrome() {
1384     wxColour c;
1385     c = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
1386     return ColourDesired(c.Red(), c.Green(), c.Blue());
1387 }
1388
1389 ColourDesired Platform::ChromeHighlight() {
1390     wxColour c;
1391     c = wxSystemSettings::GetColour(wxSYS_COLOUR_3DHIGHLIGHT);
1392     return ColourDesired(c.Red(), c.Green(), c.Blue());
1393 }
1394
1395 const char *Platform::DefaultFont() {
1396     static char buf[128];
1397     strcpy(buf, wxNORMAL_FONT->GetFaceName().mbc_str());
1398     return buf;
1399 }
1400
1401 int Platform::DefaultFontSize() {
1402     return wxNORMAL_FONT->GetPointSize();
1403 }
1404
1405 unsigned int Platform::DoubleClickTime() {
1406     return 500;   // **** ::GetDoubleClickTime();
1407 }
1408
1409 bool Platform::MouseButtonBounce() {
1410     return false;
1411 }
1412
1413 bool Platform::IsKeyDown(int WXUNUSED(key)) {
1414     return false;  // I don't think we'll need this.
1415 }
1416
1417 long Platform::SendScintilla(WindowID w,
1418                              unsigned int msg,
1419                              unsigned long wParam,
1420                              long lParam) {
1421
1422     wxStyledTextCtrl* stc = (wxStyledTextCtrl*)w;
1423     return stc->SendMsg(msg, wParam, lParam);
1424 }
1425
1426 long Platform::SendScintillaPointer(WindowID w,
1427                                     unsigned int msg,
1428                                     unsigned long wParam,
1429                                     void *lParam) {
1430
1431     wxStyledTextCtrl* stc = (wxStyledTextCtrl*)w;
1432     return stc->SendMsg(msg, wParam, (wxIntPtr)lParam);
1433 }
1434
1435
1436 // These are utility functions not really tied to a platform
1437
1438 int Platform::Minimum(int a, int b) {
1439     if (a < b)
1440         return a;
1441     else
1442         return b;
1443 }
1444
1445 int Platform::Maximum(int a, int b) {
1446     if (a > b)
1447         return a;
1448     else
1449         return b;
1450 }
1451
1452 //#define TRACE
1453
1454 void Platform::DebugDisplay(const char *s) {
1455 #ifdef TRACE
1456     wxLogDebug(stc2wx(s));
1457 #else
1458     wxUnusedVar(s);
1459 #endif
1460 }
1461
1462 void Platform::DebugPrintf(const char *format, ...) {
1463 #ifdef TRACE
1464     char buffer[2000];
1465     va_list pArguments;
1466     va_start(pArguments, format);
1467     vsprintf(buffer,format,pArguments);
1468     va_end(pArguments);
1469     Platform::DebugDisplay(buffer);
1470 #else
1471     wxUnusedVar(format);
1472 #endif
1473 }
1474
1475
1476 static bool assertionPopUps = true;
1477
1478 bool Platform::ShowAssertionPopUps(bool assertionPopUps_) {
1479     bool ret = assertionPopUps;
1480     assertionPopUps = assertionPopUps_;
1481     return ret;
1482 }
1483
1484 void Platform::Assert(const char *c, const char *file, int line) {
1485 #ifdef TRACE
1486     char buffer[2000];
1487     sprintf(buffer, "Assertion [%s] failed at %s %d", c, file, line);
1488     if (assertionPopUps) {
1489         /*int idButton = */
1490         wxMessageBox(stc2wx(buffer),
1491                      wxT("Assertion failure"),
1492                      wxICON_HAND | wxOK);
1493     } else {
1494         strcat(buffer, "\r\n");
1495         Platform::DebugDisplay(buffer);
1496         abort();
1497     }
1498 #else
1499     wxUnusedVar(c);
1500     wxUnusedVar(file);
1501     wxUnusedVar(line);
1502 #endif
1503 }
1504
1505
1506 int Platform::Clamp(int val, int minVal, int maxVal) {
1507     if (val > maxVal)
1508         val = maxVal;
1509     if (val < minVal)
1510         val = minVal;
1511     return val;
1512 }
1513
1514
1515 bool Platform::IsDBCSLeadByte(int WXUNUSED(codePage), char WXUNUSED(ch)) {
1516     return false;
1517 }
1518
1519 int Platform::DBCSCharLength(int WXUNUSED(codePage), const char *WXUNUSED(s)) {
1520     return 1;
1521 }
1522
1523 int Platform::DBCSCharMaxLength() {
1524     return 1;
1525 }
1526
1527
1528 //----------------------------------------------------------------------
1529
1530 ElapsedTime::ElapsedTime() {
1531     wxLongLong localTime = wxGetLocalTimeMillis();
1532     littleBit = localTime.GetLo();
1533     bigBit = localTime.GetHi();
1534 }
1535
1536 double ElapsedTime::Duration(bool reset) {
1537     wxLongLong prevTime(bigBit, littleBit);
1538     wxLongLong localTime = wxGetLocalTimeMillis();
1539     if(reset) {
1540         littleBit = localTime.GetLo();
1541         bigBit = localTime.GetHi();
1542     }
1543     wxLongLong duration = localTime - prevTime;
1544     double result = duration.ToDouble();
1545     result /= 1000.0;
1546     return result;
1547 }
1548
1549
1550 //----------------------------------------------------------------------
1551
1552 #if wxUSE_UNICODE
1553
1554 #include "UniConversion.h"
1555
1556 // Convert using Scintilla's functions instead of wx's, Scintilla's are more
1557 // forgiving and won't assert...
1558
1559 wxString stc2wx(const char* str, size_t len)
1560 {
1561     if (!len)
1562         return wxEmptyString;
1563
1564     size_t wclen = UTF16Length(str, len);
1565     wxWCharBuffer buffer(wclen+1);
1566
1567     size_t actualLen = UTF16FromUTF8(str, len, buffer.data(), wclen+1);
1568     return wxString(buffer.data(), actualLen);
1569 }
1570
1571
1572
1573 wxString stc2wx(const char* str)
1574 {
1575     return stc2wx(str, strlen(str));
1576 }
1577
1578
1579 wxWX2MBbuf wx2stc(const wxString& str)
1580 {
1581     const wchar_t* wcstr = str.c_str();
1582     size_t wclen         = str.length();
1583     size_t len           = UTF8Length(wcstr, wclen);
1584
1585     wxCharBuffer buffer(len+1);
1586     UTF8FromUTF16(wcstr, wclen, buffer.data(), len);
1587
1588     // TODO check NULL termination!!
1589
1590     return buffer;
1591 }
1592
1593 #endif
1594
1595 #endif // wxUSE_STC