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