]> git.saurik.com Git - wxWidgets.git/blob - contrib/src/stc/PlatWX.cpp
implemented IsModified() and DiscardEdits()
[wxWidgets.git] / contrib / src / stc / PlatWX.cpp
1 // Scintilla source code edit control
2 // PlatWX.cxx - implementation of platform facilities on wxWindows
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 #include <ctype.h>
8
9 #include <wx/wx.h>
10 #include <wx/encconv.h>
11 #include <wx/listctrl.h>
12 #include <wx/mstream.h>
13 #include <wx/image.h>
14 #include <wx/imaglist.h>
15
16 #include "Platform.h"
17 #include "PlatWX.h"
18 #include "wx/stc/stc.h"
19
20
21 #ifdef __WXGTK__
22 #include <gtk/gtk.h>
23 #endif
24
25
26 Point Point::FromLong(long lpoint) {
27 return Point(lpoint & 0xFFFF, lpoint >> 16);
28 }
29
30 wxRect wxRectFromPRectangle(PRectangle prc) {
31 wxRect rc(prc.left, prc.top,
32 prc.right-prc.left, prc.bottom-prc.top);
33 return rc;
34 }
35
36 PRectangle PRectangleFromwxRect(wxRect rc) {
37 return PRectangle(rc.GetLeft(), rc.GetTop(),
38 rc.GetRight()+1, rc.GetBottom()+1);
39 }
40
41 wxColour wxColourFromCA(const ColourAllocated& ca) {
42 ColourDesired cd(ca.AsLong());
43 return wxColour(cd.GetRed(), cd.GetGreen(), cd.GetBlue());
44 }
45
46 //----------------------------------------------------------------------
47
48 Palette::Palette() {
49 used = 0;
50 allowRealization = false;
51 }
52
53 Palette::~Palette() {
54 Release();
55 }
56
57 void Palette::Release() {
58 used = 0;
59 }
60
61 // This method either adds a colour to the list of wanted colours (want==true)
62 // or retrieves the allocated colour back to the ColourPair.
63 // This is one method to make it easier to keep the code for wanting and retrieving in sync.
64 void Palette::WantFind(ColourPair &cp, bool want) {
65 if (want) {
66 for (int i=0; i < used; i++) {
67 if (entries[i].desired == cp.desired)
68 return;
69 }
70
71 if (used < numEntries) {
72 entries[used].desired = cp.desired;
73 entries[used].allocated.Set(cp.desired.AsLong());
74 used++;
75 }
76 } else {
77 for (int i=0; i < used; i++) {
78 if (entries[i].desired == cp.desired) {
79 cp.allocated = entries[i].allocated;
80 return;
81 }
82 }
83 cp.allocated.Set(cp.desired.AsLong());
84 }
85 }
86
87 void Palette::Allocate(Window &) {
88 if (allowRealization) {
89 }
90 }
91
92
93 //----------------------------------------------------------------------
94
95 Font::Font() {
96 id = 0;
97 ascent = 0;
98 }
99
100 Font::~Font() {
101 }
102
103 void Font::Create(const char *faceName, int characterSet, int size, bool bold, bool italic) {
104 wxFontEncoding encoding;
105
106 Release();
107
108 switch (characterSet) {
109 default:
110 case wxSTC_CHARSET_ANSI:
111 case wxSTC_CHARSET_DEFAULT:
112 encoding = wxFONTENCODING_DEFAULT;
113 break;
114
115 case wxSTC_CHARSET_BALTIC:
116 encoding = wxFONTENCODING_ISO8859_13;
117 break;
118
119 case wxSTC_CHARSET_CHINESEBIG5:
120 encoding = wxFONTENCODING_CP950;
121 break;
122
123 case wxSTC_CHARSET_EASTEUROPE:
124 encoding = wxFONTENCODING_ISO8859_2;
125 break;
126
127 case wxSTC_CHARSET_GB2312:
128 encoding = wxFONTENCODING_CP936;
129 break;
130
131 case wxSTC_CHARSET_GREEK:
132 encoding = wxFONTENCODING_ISO8859_7;
133 break;
134
135 case wxSTC_CHARSET_HANGUL:
136 encoding = wxFONTENCODING_CP949;
137 break;
138
139 case wxSTC_CHARSET_MAC:
140 encoding = wxFONTENCODING_DEFAULT;
141 break;
142
143 case wxSTC_CHARSET_OEM:
144 encoding = wxFONTENCODING_DEFAULT;
145 break;
146
147 case wxSTC_CHARSET_RUSSIAN:
148 encoding = wxFONTENCODING_KOI8;
149 break;
150
151 case wxSTC_CHARSET_SHIFTJIS:
152 encoding = wxFONTENCODING_CP932;
153 break;
154
155 case wxSTC_CHARSET_SYMBOL:
156 encoding = wxFONTENCODING_DEFAULT;
157 break;
158
159 case wxSTC_CHARSET_TURKISH:
160 encoding = wxFONTENCODING_ISO8859_9;
161 break;
162
163 case wxSTC_CHARSET_JOHAB:
164 encoding = wxFONTENCODING_DEFAULT;
165 break;
166
167 case wxSTC_CHARSET_HEBREW:
168 encoding = wxFONTENCODING_ISO8859_8;
169 break;
170
171 case wxSTC_CHARSET_ARABIC:
172 encoding = wxFONTENCODING_ISO8859_6;
173 break;
174
175 case wxSTC_CHARSET_VIETNAMESE:
176 encoding = wxFONTENCODING_DEFAULT;
177 break;
178
179 case wxSTC_CHARSET_THAI:
180 encoding = wxFONTENCODING_ISO8859_11;
181 break;
182 }
183
184 wxFontEncodingArray ea = wxEncodingConverter::GetPlatformEquivalents(encoding);
185 if (ea.GetCount())
186 encoding = ea[0];
187
188 id = new wxFont(size,
189 wxDEFAULT,
190 italic ? wxITALIC : wxNORMAL,
191 bold ? wxBOLD : wxNORMAL,
192 false,
193 stc2wx(faceName),
194 encoding);
195 }
196
197
198 void Font::Release() {
199 if (id)
200 delete (wxFont*)id;
201 id = 0;
202 }
203
204 //----------------------------------------------------------------------
205
206 class SurfaceImpl : public Surface {
207 private:
208 wxDC* hdc;
209 bool hdcOwned;
210 wxBitmap* bitmap;
211 int x;
212 int y;
213 bool unicodeMode;
214
215 public:
216 SurfaceImpl();
217 ~SurfaceImpl();
218
219 virtual void Init(WindowID wid);
220 virtual void Init(SurfaceID sid, WindowID wid);
221 virtual void InitPixMap(int width, int height, Surface *surface_, WindowID wid);
222
223 virtual void Release();
224 virtual bool Initialised();
225 virtual void PenColour(ColourAllocated fore);
226 virtual int LogPixelsY();
227 virtual int DeviceHeightFont(int points);
228 virtual void MoveTo(int x_, int y_);
229 virtual void LineTo(int x_, int y_);
230 virtual void Polygon(Point *pts, int npts, ColourAllocated fore, ColourAllocated back);
231 virtual void RectangleDraw(PRectangle rc, ColourAllocated fore, ColourAllocated back);
232 virtual void FillRectangle(PRectangle rc, ColourAllocated back);
233 virtual void FillRectangle(PRectangle rc, Surface &surfacePattern);
234 virtual void RoundedRectangle(PRectangle rc, ColourAllocated fore, ColourAllocated back);
235 virtual void Ellipse(PRectangle rc, ColourAllocated fore, ColourAllocated back);
236 virtual void Copy(PRectangle rc, Point from, Surface &surfaceSource);
237
238 virtual void DrawTextNoClip(PRectangle rc, Font &font_, int ybase, const char *s, int len, ColourAllocated fore, ColourAllocated back);
239 virtual void DrawTextClipped(PRectangle rc, Font &font_, int ybase, const char *s, int len, ColourAllocated fore, ColourAllocated back);
240 virtual void DrawTextTransparent(PRectangle rc, Font &font_, int ybase, const char *s, int len, ColourAllocated fore);
241 virtual void MeasureWidths(Font &font_, const char *s, int len, int *positions);
242 virtual int WidthText(Font &font_, const char *s, int len);
243 virtual int WidthChar(Font &font_, char ch);
244 virtual int Ascent(Font &font_);
245 virtual int Descent(Font &font_);
246 virtual int InternalLeading(Font &font_);
247 virtual int ExternalLeading(Font &font_);
248 virtual int Height(Font &font_);
249 virtual int AverageCharWidth(Font &font_);
250
251 virtual int SetPalette(Palette *pal, bool inBackGround);
252 virtual void SetClip(PRectangle rc);
253 virtual void FlushCachedState();
254
255 virtual void SetUnicodeMode(bool unicodeMode_);
256 virtual void SetDBCSMode(int codePage);
257
258 void BrushColour(ColourAllocated back);
259 void SetFont(Font &font_);
260 };
261
262
263
264 SurfaceImpl::SurfaceImpl() :
265 hdc(0), hdcOwned(0), bitmap(0),
266 x(0), y(0), unicodeMode(0)
267 {}
268
269 SurfaceImpl::~SurfaceImpl() {
270 Release();
271 }
272
273 void SurfaceImpl::Init(WindowID wid) {
274 #if 0
275 Release();
276 hdc = new wxMemoryDC();
277 hdcOwned = true;
278 #else
279 // On Mac and GTK the DC is not really valid until it has a bitmap
280 // selected into it. So instead of just creating the DC with no bitmap,
281 // go ahead and give it one.
282 InitPixMap(1,1,NULL,wid);
283 #endif
284 }
285
286 void SurfaceImpl::Init(SurfaceID hdc_, WindowID) {
287 Release();
288 hdc = (wxDC*)hdc_;
289 }
290
291 void SurfaceImpl::InitPixMap(int width, int height, Surface *surface_, WindowID) {
292 Release();
293 hdc = new wxMemoryDC();
294 hdcOwned = true;
295 if (width < 1) width = 1;
296 if (height < 1) height = 1;
297 bitmap = new wxBitmap(width, height);
298 ((wxMemoryDC*)hdc)->SelectObject(*bitmap);
299 }
300
301
302 void SurfaceImpl::Release() {
303 if (bitmap) {
304 ((wxMemoryDC*)hdc)->SelectObject(wxNullBitmap);
305 delete bitmap;
306 bitmap = 0;
307 }
308 if (hdcOwned) {
309 delete hdc;
310 hdc = 0;
311 hdcOwned = false;
312 }
313 }
314
315
316 bool SurfaceImpl::Initialised() {
317 return hdc != 0;
318 }
319
320
321 void SurfaceImpl::PenColour(ColourAllocated fore) {
322 hdc->SetPen(wxPen(wxColourFromCA(fore), 1, wxSOLID));
323 }
324
325 void SurfaceImpl::BrushColour(ColourAllocated back) {
326 hdc->SetBrush(wxBrush(wxColourFromCA(back), wxSOLID));
327 }
328
329 void SurfaceImpl::SetFont(Font &font_) {
330 if (font_.GetID()) {
331 hdc->SetFont(*((wxFont*)font_.GetID()));
332 }
333 }
334
335 int SurfaceImpl::LogPixelsY() {
336 return hdc->GetPPI().y;
337 }
338
339 int SurfaceImpl::DeviceHeightFont(int points) {
340 return points;
341 }
342
343 void SurfaceImpl::MoveTo(int x_, int y_) {
344 x = x_;
345 y = y_;
346 }
347
348 void SurfaceImpl::LineTo(int x_, int y_) {
349 hdc->DrawLine(x,y, x_,y_);
350 x = x_;
351 y = y_;
352 }
353
354 void SurfaceImpl::Polygon(Point *pts, int npts, ColourAllocated fore, ColourAllocated back) {
355 PenColour(fore);
356 BrushColour(back);
357 hdc->DrawPolygon(npts, (wxPoint*)pts);
358 }
359
360 void SurfaceImpl::RectangleDraw(PRectangle rc, ColourAllocated fore, ColourAllocated back) {
361 PenColour(fore);
362 BrushColour(back);
363 hdc->DrawRectangle(wxRectFromPRectangle(rc));
364 }
365
366 void SurfaceImpl::FillRectangle(PRectangle rc, ColourAllocated back) {
367 BrushColour(back);
368 hdc->SetPen(*wxTRANSPARENT_PEN);
369 hdc->DrawRectangle(wxRectFromPRectangle(rc));
370 }
371
372 void SurfaceImpl::FillRectangle(PRectangle rc, Surface &surfacePattern) {
373 wxBrush br;
374 if (((SurfaceImpl&)surfacePattern).bitmap)
375 br = wxBrush(*((SurfaceImpl&)surfacePattern).bitmap);
376 else // Something is wrong so display in red
377 br = wxBrush(*wxRED, wxSOLID);
378 hdc->SetPen(*wxTRANSPARENT_PEN);
379 hdc->SetBrush(br);
380 hdc->DrawRectangle(wxRectFromPRectangle(rc));
381 }
382
383 void SurfaceImpl::RoundedRectangle(PRectangle rc, ColourAllocated fore, ColourAllocated back) {
384 PenColour(fore);
385 BrushColour(back);
386 hdc->DrawRoundedRectangle(wxRectFromPRectangle(rc), 4);
387 }
388
389 void SurfaceImpl::Ellipse(PRectangle rc, ColourAllocated fore, ColourAllocated back) {
390 PenColour(fore);
391 BrushColour(back);
392 hdc->DrawEllipse(wxRectFromPRectangle(rc));
393 }
394
395 void SurfaceImpl::Copy(PRectangle rc, Point from, Surface &surfaceSource) {
396 wxRect r = wxRectFromPRectangle(rc);
397 hdc->Blit(r.x, r.y, r.width, r.height,
398 ((SurfaceImpl&)surfaceSource).hdc,
399 from.x, from.y, wxCOPY);
400 }
401
402 void SurfaceImpl::DrawTextNoClip(PRectangle rc, Font &font, int ybase,
403 const char *s, int len,
404 ColourAllocated fore, ColourAllocated back) {
405 SetFont(font);
406 hdc->SetTextForeground(wxColourFromCA(fore));
407 hdc->SetTextBackground(wxColourFromCA(back));
408 FillRectangle(rc, back);
409
410 // ybase is where the baseline should be, but wxWin uses the upper left
411 // corner, so I need to calculate the real position for the text...
412 hdc->DrawText(stc2wx(s, len), rc.left, ybase - font.ascent);
413 }
414
415 void SurfaceImpl::DrawTextClipped(PRectangle rc, Font &font, int ybase,
416 const char *s, int len,
417 ColourAllocated fore, ColourAllocated back) {
418 SetFont(font);
419 hdc->SetTextForeground(wxColourFromCA(fore));
420 hdc->SetTextBackground(wxColourFromCA(back));
421 FillRectangle(rc, back);
422 hdc->SetClippingRegion(wxRectFromPRectangle(rc));
423
424 // see comments above
425 hdc->DrawText(stc2wx(s, len), rc.left, ybase - font.ascent);
426 hdc->DestroyClippingRegion();
427 }
428
429
430 void SurfaceImpl::DrawTextTransparent(PRectangle rc, Font &font, int ybase,
431 const char *s, int len,
432 ColourAllocated fore) {
433
434 SetFont(font);
435 hdc->SetTextForeground(wxColourFromCA(fore));
436 hdc->SetBackgroundMode(wxTRANSPARENT);
437
438 // ybase is where the baseline should be, but wxWin uses the upper left
439 // corner, so I need to calculate the real position for the text...
440 hdc->DrawText(stc2wx(s, len), rc.left, ybase - font.ascent);
441
442 hdc->SetBackgroundMode(wxSOLID);
443 }
444
445
446 void SurfaceImpl::MeasureWidths(Font &font, const char *s, int len, int *positions) {
447
448 wxString str = stc2wx(s, len);
449 SetFont(font);
450
451 #ifndef __WXMAC__
452 // Calculate the position of each character based on the widths of
453 // the previous characters
454 int* tpos = new int[len+1];
455 int totalWidth = 0;
456 size_t i;
457 for (i=0; i<str.Length(); i++) {
458 int w, h;
459 hdc->GetTextExtent(str[i], &w, &h);
460 totalWidth += w;
461 tpos[i] = totalWidth;
462 }
463 #else
464 // Instead of a running total, remeasure from the begining of the
465 // text for each character's position. This is because with AA fonts
466 // on OS X widths can be fractions of pixels wide when more than one
467 // are drawn together, so the sum of all character widths is not necessarily
468 // (and probably not) the same as the whole string width.
469 int* tpos = new int[len+1];
470 size_t i;
471 for (i=0; i<str.Length(); i++) {
472 int w, h;
473 hdc->GetTextExtent(str.Left(i+1), &w, &h);
474 tpos[i] = w;
475 }
476 #endif
477
478
479 #if wxUSE_UNICODE
480 // Map the widths for UCS-2 characters back to the UTF-8 input string
481 // NOTE: I don't think this is right for when sizeof(wxChar) > 2, ie wxGTK2
482 // so figure it out and fix it!
483 i = 0;
484 size_t ui = 0;
485 while ((int)i < len) {
486 unsigned char uch = (unsigned char)s[i];
487 positions[i++] = tpos[ui];
488 if (uch >= 0x80) {
489 if (uch < (0x80 + 0x40 + 0x20)) {
490 positions[i++] = tpos[ui];
491 } else {
492 positions[i++] = tpos[ui];
493 positions[i++] = tpos[ui];
494 }
495 }
496 ui++;
497 }
498 #else
499
500 // If not unicode then just use the widths we have
501 memcpy(positions, tpos, len * sizeof(*tpos));
502 #endif
503
504 delete [] tpos;
505 }
506
507
508 int SurfaceImpl::WidthText(Font &font, const char *s, int len) {
509 SetFont(font);
510 int w;
511 int h;
512
513 hdc->GetTextExtent(stc2wx(s, len), &w, &h);
514 return w;
515 }
516
517
518 int SurfaceImpl::WidthChar(Font &font, char ch) {
519 SetFont(font);
520 int w;
521 int h;
522 char s[2] = { ch, 0 };
523
524 hdc->GetTextExtent(stc2wx(s, 1), &w, &h);
525 return w;
526 }
527
528 #define EXTENT_TEST wxT(" `~!@#$%^&*()-_=+\\|[]{};:\"\'<,>.?/1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
529
530 int SurfaceImpl::Ascent(Font &font) {
531 SetFont(font);
532 int w, h, d, e;
533 hdc->GetTextExtent(EXTENT_TEST, &w, &h, &d, &e);
534 font.ascent = h - d;
535 return font.ascent;
536 }
537
538 int SurfaceImpl::Descent(Font &font) {
539 SetFont(font);
540 int w, h, d, e;
541 hdc->GetTextExtent(EXTENT_TEST, &w, &h, &d, &e);
542 return d;
543 }
544
545 int SurfaceImpl::InternalLeading(Font &font) {
546 return 0;
547 }
548
549 int SurfaceImpl::ExternalLeading(Font &font) {
550 SetFont(font);
551 int w, h, d, e;
552 hdc->GetTextExtent(EXTENT_TEST, &w, &h, &d, &e);
553 return e;
554 }
555
556 int SurfaceImpl::Height(Font &font) {
557 SetFont(font);
558 return hdc->GetCharHeight();
559 }
560
561 int SurfaceImpl::AverageCharWidth(Font &font) {
562 SetFont(font);
563 return hdc->GetCharWidth();
564 }
565
566 int SurfaceImpl::SetPalette(Palette *pal, bool inBackGround) {
567 return 0;
568 }
569
570 void SurfaceImpl::SetClip(PRectangle rc) {
571 hdc->SetClippingRegion(wxRectFromPRectangle(rc));
572 }
573
574 void SurfaceImpl::FlushCachedState() {
575 }
576
577 void SurfaceImpl::SetUnicodeMode(bool unicodeMode_) {
578 unicodeMode=unicodeMode_;
579 }
580
581 void SurfaceImpl::SetDBCSMode(int codePage) {
582 // dbcsMode = codePage == SC_CP_DBCS;
583 }
584
585
586 Surface *Surface::Allocate() {
587 return new SurfaceImpl;
588 }
589
590
591 //----------------------------------------------------------------------
592
593
594 inline wxWindow* GETWIN(WindowID id) { return (wxWindow*)id; }
595
596 Window::~Window() {
597 }
598
599 void Window::Destroy() {
600 if (id) {
601 Show(FALSE);
602 GETWIN(id)->Destroy();
603 }
604 id = 0;
605 }
606
607 bool Window::HasFocus() {
608 return wxWindow::FindFocus() == GETWIN(id);
609 }
610
611 PRectangle Window::GetPosition() {
612 if (! id) return PRectangle();
613 wxRect rc(GETWIN(id)->GetPosition(), GETWIN(id)->GetSize());
614 return PRectangleFromwxRect(rc);
615 }
616
617 void Window::SetPosition(PRectangle rc) {
618 wxRect r = wxRectFromPRectangle(rc);
619 GETWIN(id)->SetSize(r);
620 }
621
622 void Window::SetPositionRelative(PRectangle rc, Window) {
623 SetPosition(rc); // ????
624 }
625
626 PRectangle Window::GetClientPosition() {
627 if (! id) return PRectangle();
628 wxSize sz = GETWIN(id)->GetClientSize();
629 return PRectangle(0, 0, sz.x, sz.y);
630 }
631
632 void Window::Show(bool show) {
633 GETWIN(id)->Show(show);
634 }
635
636 void Window::InvalidateAll() {
637 GETWIN(id)->Refresh(false);
638 wxWakeUpIdle();
639 }
640
641 void Window::InvalidateRectangle(PRectangle rc) {
642 wxRect r = wxRectFromPRectangle(rc);
643 GETWIN(id)->Refresh(false, &r);
644 wxWakeUpIdle();
645 }
646
647 void Window::SetFont(Font &font) {
648 GETWIN(id)->SetFont(*((wxFont*)font.GetID()));
649 }
650
651 void Window::SetCursor(Cursor curs) {
652 int cursorId;
653
654 switch (curs) {
655 case cursorText:
656 cursorId = wxCURSOR_IBEAM;
657 break;
658 case cursorArrow:
659 cursorId = wxCURSOR_ARROW;
660 break;
661 case cursorUp:
662 cursorId = wxCURSOR_ARROW; // ** no up arrow... wxCURSOR_UPARROW;
663 break;
664 case cursorWait:
665 cursorId = wxCURSOR_WAIT;
666 break;
667 case cursorHoriz:
668 cursorId = wxCURSOR_SIZEWE;
669 break;
670 case cursorVert:
671 cursorId = wxCURSOR_SIZENS;
672 break;
673 case cursorReverseArrow:
674 cursorId = wxCURSOR_RIGHT_ARROW;
675 break;
676 case cursorHand:
677 cursorId = wxCURSOR_HAND;
678 default:
679 cursorId = wxCURSOR_ARROW;
680 break;
681 }
682 #ifdef __WXMOTIF__
683 wxCursor wc = wxStockCursor(cursorId) ;
684 #else
685 wxCursor wc = wxCursor(cursorId) ;
686 #endif
687 GETWIN(id)->SetCursor(wc);
688 }
689
690
691 void Window::SetTitle(const char *s) {
692 GETWIN(id)->SetTitle(stc2wx(s));
693 }
694
695
696 //----------------------------------------------------------------------
697 // Helper classes for ListBox
698
699
700 // This is a simple subclass of wxLIstView that just resets focus to the
701 // parent when it gets it.
702 class wxSTCListBox : public wxListView {
703 public:
704 wxSTCListBox(wxWindow* parent, wxWindowID id,
705 const wxPoint& pos, const wxSize& size,
706 long style)
707 : wxListView(parent, id, pos, size, style)
708 {}
709
710 void OnFocus(wxFocusEvent& event) {
711 GetParent()->SetFocus();
712 event.Skip();
713 }
714
715 private:
716 DECLARE_EVENT_TABLE()
717 };
718
719 BEGIN_EVENT_TABLE(wxSTCListBox, wxListView)
720 EVT_SET_FOCUS( wxSTCListBox::OnFocus)
721 END_EVENT_TABLE()
722
723
724
725
726 // A window to place the wxSTCListBox upon
727 class wxSTCListBoxWin : public wxWindow {
728 private:
729 wxListView* lv;
730 CallBackAction doubleClickAction;
731 void* doubleClickActionData;
732 public:
733 wxSTCListBoxWin(wxWindow* parent, wxWindowID id) :
734 wxWindow(parent, id, wxDefaultPosition, wxSize(0,0), wxNO_BORDER )
735 {
736
737 SetBackgroundColour(*wxBLACK);
738 lv = new wxSTCListBox(this, id, wxDefaultPosition, wxDefaultSize,
739 wxLC_REPORT | wxLC_SINGLE_SEL | wxLC_NO_HEADER | wxNO_BORDER);
740 lv->SetCursor(wxCursor(wxCURSOR_ARROW));
741 lv->InsertColumn(0, wxEmptyString);
742 lv->InsertColumn(1, wxEmptyString);
743 Hide();
744 }
745
746 int IconWidth() {
747 wxImageList* il = lv->GetImageList(wxIMAGE_LIST_SMALL);
748 if (il != NULL) {
749 int w, h;
750 il->GetSize(0, w, h);
751 return w;
752 }
753 return 0;
754 }
755
756
757 void SetDoubleClickAction(CallBackAction action, void *data) {
758 doubleClickAction = action;
759 doubleClickActionData = data;
760 }
761
762
763 void OnFocus(wxFocusEvent& event) {
764 GetParent()->SetFocus();
765 event.Skip();
766 }
767
768 void OnSize(wxSizeEvent& event) {
769 // resize the child, leaving a 1 pixel border
770 wxSize sz = GetClientSize();
771 lv->SetSize(1, 1, sz.x-2, sz.y-2);
772 // reset the column widths
773 lv->SetColumnWidth(0, IconWidth()+4);
774 lv->SetColumnWidth(1, sz.x - 2 - lv->GetColumnWidth(0) -
775 wxSystemSettings::GetMetric(wxSYS_VSCROLL_X));
776 event.Skip();
777 }
778
779 void OnActivate(wxListEvent& event) {
780 doubleClickAction(doubleClickActionData);
781 }
782
783 wxListView* GetLB() { return lv; }
784
785 private:
786 DECLARE_EVENT_TABLE()
787 };
788
789
790 BEGIN_EVENT_TABLE(wxSTCListBoxWin, wxWindow)
791 EVT_SET_FOCUS ( wxSTCListBoxWin::OnFocus)
792 EVT_SIZE ( wxSTCListBoxWin::OnSize)
793 EVT_LIST_ITEM_ACTIVATED(-1, wxSTCListBoxWin::OnActivate)
794 END_EVENT_TABLE()
795
796
797
798 inline wxSTCListBoxWin* GETLBW(WindowID win) {
799 return ((wxSTCListBoxWin*)win);
800 }
801
802 inline wxListView* GETLB(WindowID win) {
803 return GETLBW(win)->GetLB();
804 }
805
806 //----------------------------------------------------------------------
807
808 class ListBoxImpl : public ListBox {
809 private:
810 int lineHeight;
811 bool unicodeMode;
812 int desiredVisibleRows;
813 int aveCharWidth;
814 int maxStrWidth;
815 wxImageList* imgList;
816 wxArrayInt* imgTypeMap;
817
818 public:
819 ListBoxImpl();
820 ~ListBoxImpl();
821
822 virtual void SetFont(Font &font);
823 virtual void Create(Window &parent, int ctrlID, int lineHeight_, bool unicodeMode_);
824 virtual void SetAverageCharWidth(int width);
825 virtual void SetVisibleRows(int rows);
826 virtual PRectangle GetDesiredRect();
827 virtual int CaretFromEdge();
828 virtual void Clear();
829 virtual void Append(char *s, int type = -1);
830 virtual int Length();
831 virtual void Select(int n);
832 virtual int GetSelection();
833 virtual int Find(const char *prefix);
834 virtual void GetValue(int n, char *value, int len);
835 virtual void Sort();
836 virtual void RegisterImage(int type, const char *xpm_data);
837 virtual void ClearRegisteredImages();
838 virtual void SetDoubleClickAction(CallBackAction, void *);
839
840 };
841
842
843 ListBoxImpl::ListBoxImpl()
844 : lineHeight(10), unicodeMode(false),
845 desiredVisibleRows(5), aveCharWidth(8), maxStrWidth(0),
846 imgList(NULL), imgTypeMap(NULL)
847 {
848 }
849
850 ListBoxImpl::~ListBoxImpl() {
851 if (imgList) {
852 delete imgList;
853 imgList = NULL;
854 }
855 if (imgTypeMap) {
856 delete imgTypeMap;
857 imgTypeMap = NULL;
858 }
859 }
860
861
862 void ListBoxImpl::SetFont(Font &font) {
863 GETLB(id)->SetFont(*((wxFont*)font.GetID()));
864 }
865
866
867 void ListBoxImpl::Create(Window &parent, int ctrlID, int lineHeight_, bool unicodeMode_) {
868 lineHeight = lineHeight_;
869 unicodeMode = unicodeMode_;
870 maxStrWidth = 0;
871 id = new wxSTCListBoxWin(GETWIN(parent.GetID()), ctrlID);
872 if (imgList != NULL)
873 GETLB(id)->SetImageList(imgList, wxIMAGE_LIST_SMALL);
874 }
875
876
877 void ListBoxImpl::SetAverageCharWidth(int width) {
878 aveCharWidth = width;
879 }
880
881
882 void ListBoxImpl::SetVisibleRows(int rows) {
883 desiredVisibleRows = rows;
884 }
885
886
887 PRectangle ListBoxImpl::GetDesiredRect() {
888 // wxListCtrl doesn't have a DoGetBestSize, so instead we kept track of
889 // the max size in Append and calculate it here...
890 int maxw = maxStrWidth;
891 int maxh = 0;
892
893 // give it a default if there are no lines, and/or add a bit more
894 if (maxw == 0) maxw = 100;
895 maxw += aveCharWidth * 3 +
896 GETLBW(id)->IconWidth() + wxSystemSettings::GetMetric(wxSYS_VSCROLL_X);
897 if (maxw > 350)
898 maxw = 350;
899
900 // estimate a desired height
901 int count = GETLB(id)->GetItemCount();
902 if (count) {
903 wxRect rect;
904 GETLB(id)->GetItemRect(0, rect);
905 maxh = count * rect.GetHeight();
906 if (maxh > 140) // TODO: Use desiredVisibleRows??
907 maxh = 140;
908
909 // Try to make the size an exact multiple of some number of lines
910 int lines = maxh / rect.GetHeight();
911 maxh = (lines + 1) * rect.GetHeight() + 2;
912 }
913 else
914 maxh = 100;
915
916 PRectangle rc;
917 rc.top = 0;
918 rc.left = 0;
919 rc.right = maxw;
920 rc.bottom = maxh;
921 return rc;
922 }
923
924
925 int ListBoxImpl::CaretFromEdge() {
926 return 4 + GETLBW(id)->IconWidth();
927 }
928
929
930 void ListBoxImpl::Clear() {
931 GETLB(id)->DeleteAllItems();
932 }
933
934
935 void ListBoxImpl::Append(char *s, int type) {
936 wxString text = stc2wx(s);
937 long count = GETLB(id)->GetItemCount();
938 long itemID = GETLB(id)->InsertItem(count, wxEmptyString);
939 GETLB(id)->SetItem(itemID, 1, text);
940 int itemWidth = 0;
941 GETLB(id)->GetTextExtent(text, &itemWidth, NULL);
942 maxStrWidth = wxMax(maxStrWidth, itemWidth);
943 if (type != -1) {
944 wxCHECK_RET(imgTypeMap, wxT("Unexpected NULL imgTypeMap"));
945 long idx = imgTypeMap->Item(type);
946 GETLB(id)->SetItemImage(itemID, idx, idx);
947 }
948 }
949
950
951 int ListBoxImpl::Length() {
952 return GETLB(id)->GetItemCount();
953 }
954
955
956 void ListBoxImpl::Select(int n) {
957 bool select = TRUE;
958 if (n == -1) {
959 n = 0;
960 select = FALSE;
961 }
962 GETLB(id)->Focus(n);
963 GETLB(id)->Select(n, select);
964 }
965
966
967 int ListBoxImpl::GetSelection() {
968 return GETLB(id)->GetFirstSelected();
969 }
970
971
972 int ListBoxImpl::Find(const char *prefix) {
973 // No longer used
974 return -1;
975 }
976
977
978 void ListBoxImpl::GetValue(int n, char *value, int len) {
979 wxListItem item;
980 item.SetId(n);
981 item.SetColumn(1);
982 item.SetMask(wxLIST_MASK_TEXT);
983 GETLB(id)->GetItem(item);
984 strncpy(value, wx2stc(item.GetText()), len);
985 value[len-1] = '\0';
986 }
987
988 void ListBoxImpl::Sort() {
989 }
990
991
992 void ListBoxImpl::RegisterImage(int type, const char *xpm_data) {
993 wxMemoryInputStream stream(xpm_data, strlen(xpm_data)+1);
994 wxBitmap bmp(wxImage(stream, wxBITMAP_TYPE_XPM));
995
996 if (! imgList) {
997 // assumes all images are the same size
998 imgList = new wxImageList(bmp.GetWidth(), bmp.GetHeight(), TRUE);
999 imgTypeMap = new wxArrayInt;
1000 }
1001
1002 int idx = imgList->Add(bmp);
1003
1004 // do we need to extend the mapping array?
1005 wxArrayInt& itm = *imgTypeMap;
1006 if ( itm.GetCount() < (size_t)type+1)
1007 itm.Add(-1, type - itm.GetCount() + 1);
1008
1009 // Add an item that maps type to the image index
1010 itm[type] = idx;
1011 }
1012
1013 void ListBoxImpl::ClearRegisteredImages() {
1014 if (imgList) {
1015 delete imgList;
1016 imgList = NULL;
1017 }
1018 if (imgTypeMap) {
1019 delete imgTypeMap;
1020 imgTypeMap = NULL;
1021 }
1022 if (id)
1023 GETLB(id)->SetImageList(NULL, wxIMAGE_LIST_SMALL);
1024 }
1025
1026
1027 void ListBoxImpl::SetDoubleClickAction(CallBackAction action, void *data) {
1028 GETLBW(id)->SetDoubleClickAction(action, data);
1029 }
1030
1031
1032
1033 ListBox::ListBox() {
1034 }
1035
1036 ListBox::~ListBox() {
1037 }
1038
1039 ListBox *ListBox::Allocate() {
1040 return new ListBoxImpl();
1041 }
1042
1043 //----------------------------------------------------------------------
1044
1045 Menu::Menu() : id(0) {
1046 }
1047
1048 void Menu::CreatePopUp() {
1049 Destroy();
1050 id = new wxMenu();
1051 }
1052
1053 void Menu::Destroy() {
1054 if (id)
1055 delete (wxMenu*)id;
1056 id = 0;
1057 }
1058
1059 void Menu::Show(Point pt, Window &w) {
1060 GETWIN(w.GetID())->PopupMenu((wxMenu*)id, pt.x - 4, pt.y);
1061 Destroy();
1062 }
1063
1064 //----------------------------------------------------------------------
1065
1066 DynamicLibrary *DynamicLibrary::Load(const char *modulePath) {
1067 wxFAIL_MSG(wxT("Dynamic lexer loading not implemented yet"));
1068 return NULL;
1069 }
1070
1071 //----------------------------------------------------------------------
1072
1073 ColourDesired Platform::Chrome() {
1074 wxColour c;
1075 c = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
1076 return ColourDesired(c.Red(), c.Green(), c.Blue());
1077 }
1078
1079 ColourDesired Platform::ChromeHighlight() {
1080 wxColour c;
1081 c = wxSystemSettings::GetColour(wxSYS_COLOUR_3DHIGHLIGHT);
1082 return ColourDesired(c.Red(), c.Green(), c.Blue());
1083 }
1084
1085 const char *Platform::DefaultFont() {
1086 static char buf[128];
1087 strcpy(buf, wxNORMAL_FONT->GetFaceName().mbc_str());
1088 return buf;
1089 }
1090
1091 int Platform::DefaultFontSize() {
1092 return wxNORMAL_FONT->GetPointSize();
1093 }
1094
1095 unsigned int Platform::DoubleClickTime() {
1096 return 500; // **** ::GetDoubleClickTime();
1097 }
1098
1099 bool Platform::MouseButtonBounce() {
1100 return FALSE;
1101 }
1102 void Platform::DebugDisplay(const char *s) {
1103 wxLogDebug(stc2wx(s));
1104 }
1105
1106 bool Platform::IsKeyDown(int key) {
1107 return false; // I don't think we'll need this.
1108 }
1109
1110 long Platform::SendScintilla(WindowID w,
1111 unsigned int msg,
1112 unsigned long wParam,
1113 long lParam) {
1114
1115 wxStyledTextCtrl* stc = (wxStyledTextCtrl*)w;
1116 return stc->SendMsg(msg, wParam, lParam);
1117 }
1118
1119 long Platform::SendScintillaPointer(WindowID w,
1120 unsigned int msg,
1121 unsigned long wParam,
1122 void *lParam) {
1123
1124 wxStyledTextCtrl* stc = (wxStyledTextCtrl*)w;
1125 return stc->SendMsg(msg, wParam, (long)lParam);
1126 }
1127
1128
1129 // These are utility functions not really tied to a platform
1130
1131 int Platform::Minimum(int a, int b) {
1132 if (a < b)
1133 return a;
1134 else
1135 return b;
1136 }
1137
1138 int Platform::Maximum(int a, int b) {
1139 if (a > b)
1140 return a;
1141 else
1142 return b;
1143 }
1144
1145 #define TRACE
1146
1147 void Platform::DebugPrintf(const char *format, ...) {
1148 #ifdef TRACE
1149 char buffer[2000];
1150 va_list pArguments;
1151 va_start(pArguments, format);
1152 vsprintf(buffer,format,pArguments);
1153 va_end(pArguments);
1154 Platform::DebugDisplay(buffer);
1155 #endif
1156 }
1157
1158
1159 static bool assertionPopUps = true;
1160
1161 bool Platform::ShowAssertionPopUps(bool assertionPopUps_) {
1162 bool ret = assertionPopUps;
1163 assertionPopUps = assertionPopUps_;
1164 return ret;
1165 }
1166
1167 void Platform::Assert(const char *c, const char *file, int line) {
1168 char buffer[2000];
1169 sprintf(buffer, "Assertion [%s] failed at %s %d", c, file, line);
1170 if (assertionPopUps) {
1171 /*int idButton = */
1172 wxMessageBox(stc2wx(buffer),
1173 wxT("Assertion failure"),
1174 wxICON_HAND | wxOK);
1175 // if (idButton == IDRETRY) {
1176 // ::DebugBreak();
1177 // } else if (idButton == IDIGNORE) {
1178 // // all OK
1179 // } else {
1180 // abort();
1181 // }
1182 } else {
1183 strcat(buffer, "\r\n");
1184 Platform::DebugDisplay(buffer);
1185 abort();
1186 }
1187 }
1188
1189
1190 int Platform::Clamp(int val, int minVal, int maxVal) {
1191 if (val > maxVal)
1192 val = maxVal;
1193 if (val < minVal)
1194 val = minVal;
1195 return val;
1196 }
1197
1198
1199 bool Platform::IsDBCSLeadByte(int codePage, char ch) {
1200 return false;
1201 }
1202
1203 int Platform::DBCSCharLength(int codePage, const char *s) {
1204 return 1;
1205 }
1206
1207 int Platform::DBCSCharMaxLength() {
1208 return 1;
1209 }
1210
1211
1212 //----------------------------------------------------------------------
1213
1214 ElapsedTime::ElapsedTime() {
1215 wxStartTimer();
1216 }
1217
1218 double ElapsedTime::Duration(bool reset) {
1219 double result = wxGetElapsedTime(reset);
1220 result /= 1000.0;
1221 return result;
1222 }
1223
1224
1225 //----------------------------------------------------------------------
1226
1227 #if wxUSE_UNICODE
1228 wxString stc2wx(const char* str, size_t len)
1229 {
1230 char *buffer=new char[len+1];
1231 strncpy(buffer, str, len);
1232 buffer[len]=0;
1233
1234 wxString cstr(buffer, wxConvUTF8);
1235
1236 delete[] buffer;
1237 return cstr;
1238 }
1239 #endif
1240
1241
1242
1243
1244
1245