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.
7 // For compilers that support precompilation, includes "wx.h".
18 #include "wx/dcmemory.h"
19 #include "wx/settings.h"
25 #include "wx/display.h"
28 #include "wx/encconv.h"
29 #include "wx/listctrl.h"
30 #include "wx/mstream.h"
32 #include "wx/imaglist.h"
33 #include "wx/tokenzr.h"
35 #ifdef wxHAS_RAW_BITMAP
36 #include "wx/rawbmp.h"
41 #include "wx/stc/stc.h"
42 #include "wx/stc/private.h"
46 Point
Point::FromLong(long lpoint
) {
47 return Point(lpoint
& 0xFFFF, lpoint
>> 16);
50 wxRect
wxRectFromPRectangle(PRectangle prc
) {
51 wxRect
r(prc
.left
, prc
.top
,
52 prc
.Width(), prc
.Height());
56 PRectangle
PRectangleFromwxRect(wxRect rc
) {
57 return PRectangle(rc
.GetLeft(), rc
.GetTop(),
58 rc
.GetRight()+1, rc
.GetBottom()+1);
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());
68 //----------------------------------------------------------------------
72 allowRealization
= false;
74 entries
= new ColourPair
[size
];
83 void Palette::Release() {
87 entries
= new ColourPair
[size
];
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
) {
95 for (int i
=0; i
< used
; i
++) {
96 if (entries
[i
].desired
== cp
.desired
)
101 int sizeNew
= size
* 2;
102 ColourPair
*entriesNew
= new ColourPair
[sizeNew
];
103 for (int j
=0; j
<size
; j
++) {
104 entriesNew
[j
] = entries
[j
];
107 entries
= entriesNew
;
111 entries
[used
].desired
= cp
.desired
;
112 entries
[used
].allocated
.Set(cp
.desired
.AsLong());
115 for (int i
=0; i
< used
; i
++) {
116 if (entries
[i
].desired
== cp
.desired
) {
117 cp
.allocated
= entries
[i
].allocated
;
121 cp
.allocated
.Set(cp
.desired
.AsLong());
125 void Palette::Allocate(Window
&) {
126 if (allowRealization
) {
131 //----------------------------------------------------------------------
141 void Font::Create(const char *faceName
, int characterSet
,
142 int size
, bool bold
, bool italic
,
143 bool WXUNUSED(extraFontFlag
)) {
146 // The minus one is done because since Scintilla uses SC_SHARSET_DEFAULT
147 // internally and we need to have wxFONENCODING_DEFAULT == SC_SHARSET_DEFAULT
148 // so we adjust the encoding before passing it to Scintilla. See also
149 // wxStyledTextCtrl::StyleSetCharacterSet
150 wxFontEncoding encoding
= (wxFontEncoding
)(characterSet
-1);
152 wxFontEncodingArray ea
= wxEncodingConverter::GetPlatformEquivalents(encoding
);
156 wxFont
* font
= new wxFont(size
,
158 italic
? wxITALIC
: wxNORMAL
,
159 bold
? wxBOLD
: wxNORMAL
,
167 void Font::Release() {
173 //----------------------------------------------------------------------
175 class SurfaceImpl
: public Surface
{
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
);
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
);
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_
);
222 virtual int SetPalette(Palette
*pal
, bool inBackGround
);
223 virtual void SetClip(PRectangle rc
);
224 virtual void FlushCachedState();
226 virtual void SetUnicodeMode(bool unicodeMode_
);
227 virtual void SetDBCSMode(int codePage
);
229 void BrushColour(ColourAllocated back
);
230 void SetFont(Font
&font_
);
235 SurfaceImpl::SurfaceImpl() :
236 hdc(0), hdcOwned(0), bitmap(0),
237 x(0), y(0), unicodeMode(0)
240 SurfaceImpl::~SurfaceImpl() {
244 void SurfaceImpl::Init(WindowID wid
) {
247 hdc
= new wxMemoryDC();
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
);
257 void SurfaceImpl::Init(SurfaceID hdc_
, WindowID
) {
262 void SurfaceImpl::InitPixMap(int width
, int height
, Surface
*WXUNUSED(surface_
), WindowID
) {
264 hdc
= new wxMemoryDC();
266 if (width
< 1) width
= 1;
267 if (height
< 1) height
= 1;
268 bitmap
= new wxBitmap(width
, height
);
269 ((wxMemoryDC
*)hdc
)->SelectObject(*bitmap
);
273 void SurfaceImpl::Release() {
275 ((wxMemoryDC
*)hdc
)->SelectObject(wxNullBitmap
);
287 bool SurfaceImpl::Initialised() {
292 void SurfaceImpl::PenColour(ColourAllocated fore
) {
293 hdc
->SetPen(wxPen(wxColourFromCA(fore
)));
296 void SurfaceImpl::BrushColour(ColourAllocated back
) {
297 hdc
->SetBrush(wxBrush(wxColourFromCA(back
)));
300 void SurfaceImpl::SetFont(Font
&font_
) {
302 hdc
->SetFont(*((wxFont
*)font_
.GetID()));
306 int SurfaceImpl::LogPixelsY() {
307 return hdc
->GetPPI().y
;
310 int SurfaceImpl::DeviceHeightFont(int points
) {
314 void SurfaceImpl::MoveTo(int x_
, int y_
) {
319 void SurfaceImpl::LineTo(int x_
, int y_
) {
320 hdc
->DrawLine(x
,y
, x_
,y_
);
325 void SurfaceImpl::Polygon(Point
*pts
, int npts
, ColourAllocated fore
, ColourAllocated back
) {
328 hdc
->DrawPolygon(npts
, (wxPoint
*)pts
);
331 void SurfaceImpl::RectangleDraw(PRectangle rc
, ColourAllocated fore
, ColourAllocated back
) {
334 hdc
->DrawRectangle(wxRectFromPRectangle(rc
));
337 void SurfaceImpl::FillRectangle(PRectangle rc
, ColourAllocated back
) {
339 hdc
->SetPen(*wxTRANSPARENT_PEN
);
340 hdc
->DrawRectangle(wxRectFromPRectangle(rc
));
343 void SurfaceImpl::FillRectangle(PRectangle rc
, Surface
&surfacePattern
) {
345 if (((SurfaceImpl
&)surfacePattern
).bitmap
)
346 br
= wxBrush(*((SurfaceImpl
&)surfacePattern
).bitmap
);
347 else // Something is wrong so display in red
348 br
= wxBrush(*wxRED
);
349 hdc
->SetPen(*wxTRANSPARENT_PEN
);
351 hdc
->DrawRectangle(wxRectFromPRectangle(rc
));
354 void SurfaceImpl::RoundedRectangle(PRectangle rc
, ColourAllocated fore
, ColourAllocated back
) {
357 hdc
->DrawRoundedRectangle(wxRectFromPRectangle(rc
), 4);
361 #define wxPy_premultiply(p, a) ((p) * (a) / 0xff)
363 #define wxPy_premultiply(p, a) (p)
366 void SurfaceImpl::AlphaRectangle(PRectangle rc
, int cornerSize
,
367 ColourAllocated fill
, int alphaFill
,
368 ColourAllocated outline
, int alphaOutline
,
370 #ifdef wxHAS_RAW_BITMAP
372 // TODO: do something with cornerSize
373 wxUnusedVar(cornerSize
);
376 wxRect r
= wxRectFromPRectangle(rc
);
377 wxBitmap
bmp(r
.width
, r
.height
, 32);
378 wxAlphaPixelData
pixData(bmp
);
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();
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
;
398 // Set the outline pixels
399 ColourDesired
cdo(outline
.AsLong());
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
;
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
;
430 hdc
->DrawBitmap(bmp
, r
.x
, r
.y
, true);
433 wxUnusedVar(cornerSize
);
434 wxUnusedVar(alphaFill
);
435 wxUnusedVar(alphaOutline
);
436 RectangleDraw(rc
, outline
, fill
);
440 void SurfaceImpl::Ellipse(PRectangle rc
, ColourAllocated fore
, ColourAllocated back
) {
443 hdc
->DrawEllipse(wxRectFromPRectangle(rc
));
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
);
453 void SurfaceImpl::DrawTextNoClip(PRectangle rc
, Font
&font
, int ybase
,
454 const char *s
, int len
,
455 ColourAllocated fore
, ColourAllocated back
) {
457 hdc
->SetTextForeground(wxColourFromCA(fore
));
458 hdc
->SetTextBackground(wxColourFromCA(back
));
459 FillRectangle(rc
, back
);
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
);
466 void SurfaceImpl::DrawTextClipped(PRectangle rc
, Font
&font
, int ybase
,
467 const char *s
, int len
,
468 ColourAllocated fore
, ColourAllocated back
) {
470 hdc
->SetTextForeground(wxColourFromCA(fore
));
471 hdc
->SetTextBackground(wxColourFromCA(back
));
472 FillRectangle(rc
, back
);
473 hdc
->SetClippingRegion(wxRectFromPRectangle(rc
));
475 // see comments above
476 hdc
->DrawText(stc2wx(s
, len
), rc
.left
, ybase
- font
.ascent
);
477 hdc
->DestroyClippingRegion();
481 void SurfaceImpl::DrawTextTransparent(PRectangle rc
, Font
&font
, int ybase
,
482 const char *s
, int len
,
483 ColourAllocated fore
) {
486 hdc
->SetTextForeground(wxColourFromCA(fore
));
487 hdc
->SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT
);
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
);
493 hdc
->SetBackgroundMode(wxBRUSHSTYLE_SOLID
);
497 void SurfaceImpl::MeasureWidths(Font
&font
, const char *s
, int len
, int *positions
) {
499 wxString str
= stc2wx(s
, len
);
504 hdc
->GetPartialTextExtents(str
, tpos
);
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!
512 while ((int)i
< len
) {
513 unsigned char uch
= (unsigned char)s
[i
];
514 positions
[i
++] = tpos
[ui
];
516 if (uch
< (0x80 + 0x40 + 0x20)) {
517 positions
[i
++] = tpos
[ui
];
519 positions
[i
++] = tpos
[ui
];
520 positions
[i
++] = tpos
[ui
];
527 // If not unicode then just use the widths we have
529 std::copy(tpos
.begin(), tpos
.end(), positions
);
531 memcpy(positions
, tpos
.begin(), len
* sizeof(int));
537 int SurfaceImpl::WidthText(Font
&font
, const char *s
, int len
) {
542 hdc
->GetTextExtent(stc2wx(s
, len
), &w
, &h
);
547 int SurfaceImpl::WidthChar(Font
&font
, char ch
) {
551 char s
[2] = { ch
, 0 };
553 hdc
->GetTextExtent(stc2wx(s
, 1), &w
, &h
);
557 #define EXTENT_TEST wxT(" `~!@#$%^&*()-_=+\\|[]{};:\"\'<,>.?/1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
559 int SurfaceImpl::Ascent(Font
&font
) {
562 hdc
->GetTextExtent(EXTENT_TEST
, &w
, &h
, &d
, &e
);
567 int SurfaceImpl::Descent(Font
&font
) {
570 hdc
->GetTextExtent(EXTENT_TEST
, &w
, &h
, &d
, &e
);
574 int SurfaceImpl::InternalLeading(Font
&WXUNUSED(font
)) {
578 int SurfaceImpl::ExternalLeading(Font
&font
) {
581 hdc
->GetTextExtent(EXTENT_TEST
, &w
, &h
, &d
, &e
);
585 int SurfaceImpl::Height(Font
&font
) {
587 return hdc
->GetCharHeight() + 1;
590 int SurfaceImpl::AverageCharWidth(Font
&font
) {
592 return hdc
->GetCharWidth();
595 int SurfaceImpl::SetPalette(Palette
*WXUNUSED(pal
), bool WXUNUSED(inBackGround
)) {
599 void SurfaceImpl::SetClip(PRectangle rc
) {
600 hdc
->SetClippingRegion(wxRectFromPRectangle(rc
));
603 void SurfaceImpl::FlushCachedState() {
606 void SurfaceImpl::SetUnicodeMode(bool unicodeMode_
) {
607 unicodeMode
=unicodeMode_
;
610 void SurfaceImpl::SetDBCSMode(int WXUNUSED(codePage
)) {
611 // dbcsMode = codePage == SC_CP_DBCS;
615 Surface
*Surface::Allocate() {
616 return new SurfaceImpl
;
620 //----------------------------------------------------------------------
623 inline wxWindow
* GETWIN(WindowID id
) { return (wxWindow
*)id
; }
628 void Window::Destroy() {
631 GETWIN(id
)->Destroy();
636 bool Window::HasFocus() {
637 return wxWindow::FindFocus() == GETWIN(id
);
640 PRectangle
Window::GetPosition() {
641 if (! id
) return PRectangle();
642 wxRect
rc(GETWIN(id
)->GetPosition(), GETWIN(id
)->GetSize());
643 return PRectangleFromwxRect(rc
);
646 void Window::SetPosition(PRectangle rc
) {
647 wxRect r
= wxRectFromPRectangle(rc
);
648 GETWIN(id
)->SetSize(r
);
651 void Window::SetPositionRelative(PRectangle rc
, Window
) {
652 SetPosition(rc
); // ????
655 PRectangle
Window::GetClientPosition() {
656 if (! id
) return PRectangle();
657 wxSize sz
= GETWIN(id
)->GetClientSize();
658 return PRectangle(0, 0, sz
.x
, sz
.y
);
661 void Window::Show(bool show
) {
662 GETWIN(id
)->Show(show
);
665 void Window::InvalidateAll() {
666 GETWIN(id
)->Refresh(false);
669 void Window::InvalidateRectangle(PRectangle rc
) {
670 wxRect r
= wxRectFromPRectangle(rc
);
671 GETWIN(id
)->Refresh(false, &r
);
674 void Window::SetFont(Font
&font
) {
675 GETWIN(id
)->SetFont(*((wxFont
*)font
.GetID()));
678 void Window::SetCursor(Cursor curs
) {
679 wxStockCursor cursorId
;
683 cursorId
= wxCURSOR_IBEAM
;
686 cursorId
= wxCURSOR_ARROW
;
689 cursorId
= wxCURSOR_ARROW
; // ** no up arrow... wxCURSOR_UPARROW;
692 cursorId
= wxCURSOR_WAIT
;
695 cursorId
= wxCURSOR_SIZEWE
;
698 cursorId
= wxCURSOR_SIZENS
;
700 case cursorReverseArrow
:
701 cursorId
= wxCURSOR_RIGHT_ARROW
;
704 cursorId
= wxCURSOR_HAND
;
707 cursorId
= wxCURSOR_ARROW
;
711 wxCursor wc
= wxCursor(cursorId
);
712 if(curs
!= cursorLast
)
714 GETWIN(id
)->SetCursor(wc
);
720 void Window::SetTitle(const char *s
) {
721 GETWIN(id
)->SetLabel(stc2wx(s
));
725 // Returns rectangle of monitor pt is on
726 PRectangle
Window::GetMonitorRect(Point pt
) {
728 if (! id
) return PRectangle();
730 // Get the display the point is found on
731 int n
= wxDisplay::GetFromPoint(wxPoint(pt
.x
, pt
.y
));
732 wxDisplay
dpy(n
== wxNOT_FOUND
? 0 : n
);
733 rect
= dpy
.GetGeometry();
735 return PRectangleFromwxRect(rect
);
738 //----------------------------------------------------------------------
739 // Helper classes for ListBox
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
{
746 wxSTCListBox(wxWindow
* parent
, wxWindowID id
,
747 const wxPoint
& pos
, const wxSize
& size
,
752 Hide(); // don't flicker as we move it around...
754 Create(parent
, id
, pos
, size
, style
);
758 void OnFocus(wxFocusEvent
& event
) {
759 GetParent()->SetFocus();
763 void OnKillFocus(wxFocusEvent
& WXUNUSED(event
)) {
764 // Do nothing. Prevents base class from resetting the colors...
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
771 void OnKeyDown(wxKeyEvent
& event
) {
772 GetGrandParent()->GetEventHandler()->ProcessEvent(event
);
774 void OnChar(wxKeyEvent
& event
) {
775 GetGrandParent()->GetEventHandler()->ProcessEvent(event
);
778 // And we need to force the focus back when being destroyed
780 GetGrandParent()->SetFocus();
785 DECLARE_EVENT_TABLE()
788 BEGIN_EVENT_TABLE(wxSTCListBox
, wxListView
)
789 EVT_SET_FOCUS( wxSTCListBox::OnFocus
)
790 EVT_KILL_FOCUS(wxSTCListBox::OnKillFocus
)
792 EVT_KEY_DOWN( wxSTCListBox::OnKeyDown
)
793 EVT_CHAR( wxSTCListBox::OnChar
)
799 #if wxUSE_POPUPWIN //-----------------------------------
800 #include "wx/popupwin.h"
804 // TODO: Refactor these two classes to have a common base (or a mix-in) to get
805 // rid of the code duplication. (Either that or convince somebody to
806 // implement wxPopupWindow for the Mac!!)
808 // In the meantime, be careful to duplicate any changes as needed...
811 // A popup window to place the wxSTCListBox upon
812 class wxSTCListBoxWin
: public wxPopupWindow
816 CallBackAction doubleClickAction
;
817 void* doubleClickActionData
;
819 wxSTCListBoxWin(wxWindow
* parent
, wxWindowID id
, Point
WXUNUSED(location
)) :
820 wxPopupWindow(parent
, wxBORDER_NONE
)
823 SetBackgroundColour(*wxBLACK
); // for our simple border
825 lv
= new wxSTCListBox(parent
, id
, wxPoint(-50,-50), wxDefaultSize
,
826 wxLC_REPORT
| wxLC_SINGLE_SEL
| wxLC_NO_HEADER
| wxBORDER_NONE
);
827 lv
->SetCursor(wxCursor(wxCURSOR_ARROW
));
828 lv
->InsertColumn(0, wxEmptyString
);
829 lv
->InsertColumn(1, wxEmptyString
);
831 // NOTE: We need to fool the wxListView into thinking that it has the
832 // focus so it will use the normal selection colour and will look
833 // "right" to the user. But since the wxPopupWindow or its children
834 // can't receive focus then we have to pull a fast one and temporarily
835 // parent the listctrl on the STC window and then call SetFocus and
836 // then reparent it back to the popup.
845 // Set position in client coords
846 virtual void DoSetSize(int x
, int y
,
847 int width
, int height
,
848 int sizeFlags
= wxSIZE_AUTO
) {
849 if (x
!= wxDefaultCoord
) {
850 GetParent()->ClientToScreen(&x
, NULL
);
852 if (y
!= wxDefaultCoord
) {
853 GetParent()->ClientToScreen(NULL
, &y
);
855 wxPopupWindow::DoSetSize(x
, y
, width
, height
, sizeFlags
);
858 // return position as if it were in client coords
859 virtual void DoGetPosition( int *x
, int *y
) const {
861 wxPopupWindow::DoGetPosition(&sx
, &sy
);
862 GetParent()->ScreenToClient(&sx
, &sy
);
869 if ( !wxPendingDelete
.Member(this) )
870 wxPendingDelete
.Append(this);
876 wxImageList
* il
= lv
->GetImageList(wxIMAGE_LIST_SMALL
);
879 il
->GetSize(0, w
, h
);
886 void SetDoubleClickAction(CallBackAction action
, void *data
) {
887 doubleClickAction
= action
;
888 doubleClickActionData
= data
;
892 void OnFocus(wxFocusEvent
& event
) {
893 GetParent()->SetFocus();
897 void OnSize(wxSizeEvent
& event
) {
899 wxSize sz
= GetSize();
902 lv
->SetSize(1, 1, sz
.x
, sz
.y
);
903 // reset the column widths
904 lv
->SetColumnWidth(0, IconWidth()+4);
905 lv
->SetColumnWidth(1, sz
.x
- 2 - lv
->GetColumnWidth(0) -
906 wxSystemSettings::GetMetric(wxSYS_VSCROLL_X
));
910 void OnActivate(wxListEvent
& WXUNUSED(event
)) {
911 doubleClickAction(doubleClickActionData
);
914 wxListView
* GetLB() { return lv
; }
917 DECLARE_EVENT_TABLE()
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
)
929 #else // !wxUSE_POPUPWIN -----------------------------------
930 #include "wx/frame.h"
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
{
937 CallBackAction doubleClickAction
;
938 void* doubleClickActionData
;
940 wxSTCListBoxWin(wxWindow
* parent
, wxWindowID id
, Point location
) :
941 wxFrame(parent
, id
, wxEmptyString
, wxPoint(location
.x
, location
.y
), wxSize(0,0),
943 | wxFRAME_FLOAT_ON_PARENT
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
);
959 // Eventhough we immediately reset the focus to the parent, this helps
960 // things to look right...
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
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
);
981 if ( !wxPendingDelete
.Member(this) )
982 wxPendingDelete
.Append(this);
989 wxImageList
* il
= lv
->GetImageList(wxIMAGE_LIST_SMALL
);
992 il
->GetSize(0, w
, h
);
999 void SetDoubleClickAction(CallBackAction action
, void *data
)
1001 doubleClickAction
= action
;
1002 doubleClickActionData
= data
;
1006 void OnFocus(wxFocusEvent
& event
)
1009 GetParent()->SetFocus();
1013 void OnSize(wxSizeEvent
& event
)
1016 wxSize sz
= GetClientSize();
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
));
1025 void ActivateParent()
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
);
1036 virtual void DoSetSize(int x
, int y
,
1037 int width
, int height
,
1038 int sizeFlags
= wxSIZE_AUTO
)
1040 // convert coords to screen coords since we're a top-level window
1041 if (x
!= wxDefaultCoord
) {
1042 GetParent()->ClientToScreen(&x
, NULL
);
1044 if (y
!= wxDefaultCoord
) {
1045 GetParent()->ClientToScreen(NULL
, &y
);
1047 wxFrame::DoSetSize(x
, y
, width
, height
, sizeFlags
);
1050 virtual bool Show(bool show
= true)
1052 bool rv
= wxFrame::Show(show
);
1056 GetParent()->Refresh(false);
1061 void OnActivate(wxListEvent
& WXUNUSED(event
))
1063 doubleClickAction(doubleClickActionData
);
1066 wxListView
* GetLB() { return lv
; }
1069 DECLARE_EVENT_TABLE()
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
)
1079 #endif // wxUSE_POPUPWIN -----------------------------------
1082 inline wxSTCListBoxWin
* GETLBW(WindowID win
) {
1083 return ((wxSTCListBoxWin
*)win
);
1086 inline wxListView
* GETLB(WindowID win
) {
1087 return GETLBW(win
)->GetLB();
1090 //----------------------------------------------------------------------
1092 class ListBoxImpl
: public ListBox
{
1096 int desiredVisibleRows
;
1099 Point location
; // Caret location at which the list is opened
1100 wxImageList
* imgList
;
1101 wxArrayInt
* imgTypeMap
;
1107 virtual void SetFont(Font
&font
);
1108 virtual void Create(Window
&parent
, int ctrlID
, Point location_
, int lineHeight_
, bool unicodeMode_
);
1109 virtual void SetAverageCharWidth(int width
);
1110 virtual void SetVisibleRows(int rows
);
1111 virtual int GetVisibleRows() const;
1112 virtual PRectangle
GetDesiredRect();
1113 virtual int CaretFromEdge();
1114 virtual void Clear();
1115 virtual void Append(char *s
, int type
= -1);
1116 void Append(const wxString
& text
, int type
);
1117 virtual int Length();
1118 virtual void Select(int n
);
1119 virtual int GetSelection();
1120 virtual int Find(const char *prefix
);
1121 virtual void GetValue(int n
, char *value
, int len
);
1122 virtual void RegisterImage(int type
, const char *xpm_data
);
1123 virtual void ClearRegisteredImages();
1124 virtual void SetDoubleClickAction(CallBackAction
, void *);
1125 virtual void SetList(const char* list
, char separator
, char typesep
);
1129 ListBoxImpl::ListBoxImpl()
1130 : lineHeight(10), unicodeMode(false),
1131 desiredVisibleRows(5), aveCharWidth(8), maxStrWidth(0),
1132 imgList(NULL
), imgTypeMap(NULL
)
1136 ListBoxImpl::~ListBoxImpl() {
1148 void ListBoxImpl::SetFont(Font
&font
) {
1149 GETLB(id
)->SetFont(*((wxFont
*)font
.GetID()));
1153 void ListBoxImpl::Create(Window
&parent
, int ctrlID
, Point location_
, int lineHeight_
, bool unicodeMode_
) {
1154 location
= location_
;
1155 lineHeight
= lineHeight_
;
1156 unicodeMode
= unicodeMode_
;
1158 id
= new wxSTCListBoxWin(GETWIN(parent
.GetID()), ctrlID
, location
);
1159 if (imgList
!= NULL
)
1160 GETLB(id
)->SetImageList(imgList
, wxIMAGE_LIST_SMALL
);
1164 void ListBoxImpl::SetAverageCharWidth(int width
) {
1165 aveCharWidth
= width
;
1169 void ListBoxImpl::SetVisibleRows(int rows
) {
1170 desiredVisibleRows
= rows
;
1174 int ListBoxImpl::GetVisibleRows() const {
1175 return desiredVisibleRows
;
1178 PRectangle
ListBoxImpl::GetDesiredRect() {
1179 // wxListCtrl doesn't have a DoGetBestSize, so instead we kept track of
1180 // the max size in Append and calculate it here...
1181 int maxw
= maxStrWidth
* aveCharWidth
;
1184 // give it a default if there are no lines, and/or add a bit more
1185 if (maxw
== 0) maxw
= 100;
1186 maxw
+= aveCharWidth
* 3 +
1187 GETLBW(id
)->IconWidth() + wxSystemSettings::GetMetric(wxSYS_VSCROLL_X
);
1191 // estimate a desired height
1192 int count
= GETLB(id
)->GetItemCount();
1195 GETLB(id
)->GetItemRect(0, rect
);
1196 maxh
= count
* rect
.GetHeight();
1197 if (maxh
> 140) // TODO: Use desiredVisibleRows??
1200 // Try to make the size an exact multiple of some number of lines
1201 int lines
= maxh
/ rect
.GetHeight();
1202 maxh
= (lines
+ 1) * rect
.GetHeight() + 2;
1216 int ListBoxImpl::CaretFromEdge() {
1217 return 4 + GETLBW(id
)->IconWidth();
1221 void ListBoxImpl::Clear() {
1222 GETLB(id
)->DeleteAllItems();
1226 void ListBoxImpl::Append(char *s
, int type
) {
1227 Append(stc2wx(s
), type
);
1230 void ListBoxImpl::Append(const wxString
& text
, int type
) {
1231 long count
= GETLB(id
)->GetItemCount();
1232 long itemID
= GETLB(id
)->InsertItem(count
, wxEmptyString
);
1234 GETLB(id
)->SetItem(itemID
, 1, text
);
1235 maxStrWidth
= wxMax(maxStrWidth
, text
.length());
1237 wxCHECK_RET(imgTypeMap
, wxT("Unexpected NULL imgTypeMap"));
1238 idx
= imgTypeMap
->Item(type
);
1240 GETLB(id
)->SetItemImage(itemID
, idx
, idx
);
1243 void ListBoxImpl::SetList(const char* list
, char separator
, char typesep
) {
1244 GETLB(id
)->Freeze();
1246 wxStringTokenizer
tkzr(stc2wx(list
), (wxChar
)separator
);
1247 while ( tkzr
.HasMoreTokens() ) {
1248 wxString token
= tkzr
.GetNextToken();
1250 int pos
= token
.Find(typesep
);
1252 token
.Mid(pos
+1).ToLong(&type
);
1253 token
.Truncate(pos
);
1255 Append(token
, (int)type
);
1261 int ListBoxImpl::Length() {
1262 return GETLB(id
)->GetItemCount();
1266 void ListBoxImpl::Select(int n
) {
1272 GETLB(id
)->EnsureVisible(n
);
1273 GETLB(id
)->Select(n
, select
);
1277 int ListBoxImpl::GetSelection() {
1278 return GETLB(id
)->GetFirstSelected();
1282 int ListBoxImpl::Find(const char *WXUNUSED(prefix
)) {
1288 void ListBoxImpl::GetValue(int n
, char *value
, int len
) {
1292 item
.SetMask(wxLIST_MASK_TEXT
);
1293 GETLB(id
)->GetItem(item
);
1294 strncpy(value
, wx2stc(item
.GetText()), len
);
1295 value
[len
-1] = '\0';
1299 void ListBoxImpl::RegisterImage(int type
, const char *xpm_data
) {
1300 wxMemoryInputStream
stream(xpm_data
, strlen(xpm_data
)+1);
1301 wxImage
img(stream
, wxBITMAP_TYPE_XPM
);
1305 // assumes all images are the same size
1306 imgList
= new wxImageList(bmp
.GetWidth(), bmp
.GetHeight(), true);
1307 imgTypeMap
= new wxArrayInt
;
1310 int idx
= imgList
->Add(bmp
);
1312 // do we need to extend the mapping array?
1313 wxArrayInt
& itm
= *imgTypeMap
;
1314 if ( itm
.GetCount() < (size_t)type
+1)
1315 itm
.Add(-1, type
- itm
.GetCount() + 1);
1317 // Add an item that maps type to the image index
1321 void ListBoxImpl::ClearRegisteredImages() {
1331 GETLB(id
)->SetImageList(NULL
, wxIMAGE_LIST_SMALL
);
1335 void ListBoxImpl::SetDoubleClickAction(CallBackAction action
, void *data
) {
1336 GETLBW(id
)->SetDoubleClickAction(action
, data
);
1340 ListBox::ListBox() {
1343 ListBox::~ListBox() {
1346 ListBox
*ListBox::Allocate() {
1347 return new ListBoxImpl();
1350 //----------------------------------------------------------------------
1352 Menu::Menu() : id(0) {
1355 void Menu::CreatePopUp() {
1360 void Menu::Destroy() {
1366 void Menu::Show(Point pt
, Window
&w
) {
1367 GETWIN(w
.GetID())->PopupMenu((wxMenu
*)id
, pt
.x
- 4, pt
.y
);
1371 //----------------------------------------------------------------------
1373 DynamicLibrary
*DynamicLibrary::Load(const char *WXUNUSED(modulePath
)) {
1374 wxFAIL_MSG(wxT("Dynamic lexer loading not implemented yet"));
1378 //----------------------------------------------------------------------
1380 ColourDesired
Platform::Chrome() {
1382 c
= wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE
);
1383 return ColourDesired(c
.Red(), c
.Green(), c
.Blue());
1386 ColourDesired
Platform::ChromeHighlight() {
1388 c
= wxSystemSettings::GetColour(wxSYS_COLOUR_3DHIGHLIGHT
);
1389 return ColourDesired(c
.Red(), c
.Green(), c
.Blue());
1392 const char *Platform::DefaultFont() {
1393 static char buf
[128];
1394 strcpy(buf
, wxNORMAL_FONT
->GetFaceName().mbc_str());
1398 int Platform::DefaultFontSize() {
1399 return wxNORMAL_FONT
->GetPointSize();
1402 unsigned int Platform::DoubleClickTime() {
1403 return 500; // **** ::GetDoubleClickTime();
1406 bool Platform::MouseButtonBounce() {
1410 bool Platform::IsKeyDown(int WXUNUSED(key
)) {
1411 return false; // I don't think we'll need this.
1414 long Platform::SendScintilla(WindowID w
,
1416 unsigned long wParam
,
1419 wxStyledTextCtrl
* stc
= (wxStyledTextCtrl
*)w
;
1420 return stc
->SendMsg(msg
, wParam
, lParam
);
1423 long Platform::SendScintillaPointer(WindowID w
,
1425 unsigned long wParam
,
1428 wxStyledTextCtrl
* stc
= (wxStyledTextCtrl
*)w
;
1429 return stc
->SendMsg(msg
, wParam
, (wxIntPtr
)lParam
);
1433 // These are utility functions not really tied to a platform
1435 int Platform::Minimum(int a
, int b
) {
1442 int Platform::Maximum(int a
, int b
) {
1451 void Platform::DebugDisplay(const char *s
) {
1453 wxLogDebug(stc2wx(s
));
1459 void Platform::DebugPrintf(const char *format
, ...) {
1463 va_start(pArguments
, format
);
1464 vsprintf(buffer
,format
,pArguments
);
1466 Platform::DebugDisplay(buffer
);
1468 wxUnusedVar(format
);
1473 static bool assertionPopUps
= true;
1475 bool Platform::ShowAssertionPopUps(bool assertionPopUps_
) {
1476 bool ret
= assertionPopUps
;
1477 assertionPopUps
= assertionPopUps_
;
1481 void Platform::Assert(const char *c
, const char *file
, int line
) {
1484 sprintf(buffer
, "Assertion [%s] failed at %s %d", c
, file
, line
);
1485 if (assertionPopUps
) {
1487 wxMessageBox(stc2wx(buffer
),
1488 wxT("Assertion failure"),
1489 wxICON_HAND
| wxOK
);
1491 strcat(buffer
, "\r\n");
1492 Platform::DebugDisplay(buffer
);
1503 int Platform::Clamp(int val
, int minVal
, int maxVal
) {
1512 bool Platform::IsDBCSLeadByte(int WXUNUSED(codePage
), char WXUNUSED(ch
)) {
1516 int Platform::DBCSCharLength(int WXUNUSED(codePage
), const char *WXUNUSED(s
)) {
1520 int Platform::DBCSCharMaxLength() {
1525 //----------------------------------------------------------------------
1527 ElapsedTime::ElapsedTime() {
1528 wxLongLong localTime
= wxGetLocalTimeMillis();
1529 littleBit
= localTime
.GetLo();
1530 bigBit
= localTime
.GetHi();
1533 double ElapsedTime::Duration(bool reset
) {
1534 wxLongLong
prevTime(bigBit
, littleBit
);
1535 wxLongLong localTime
= wxGetLocalTimeMillis();
1537 littleBit
= localTime
.GetLo();
1538 bigBit
= localTime
.GetHi();
1540 wxLongLong duration
= localTime
- prevTime
;
1541 double result
= duration
.ToDouble();
1547 //----------------------------------------------------------------------
1551 #include "UniConversion.h"
1553 // Convert using Scintilla's functions instead of wx's, Scintilla's are more
1554 // forgiving and won't assert...
1556 wxString
stc2wx(const char* str
, size_t len
)
1559 return wxEmptyString
;
1561 size_t wclen
= UTF16Length(str
, len
);
1562 wxWCharBuffer
buffer(wclen
+1);
1564 size_t actualLen
= UTF16FromUTF8(str
, len
, buffer
.data(), wclen
+1);
1565 return wxString(buffer
.data(), actualLen
);
1570 wxString
stc2wx(const char* str
)
1572 return stc2wx(str
, strlen(str
));
1576 const wxWX2MBbuf
wx2stc(const wxString
& str
)
1578 const wchar_t* wcstr
= str
.c_str();
1579 size_t wclen
= str
.length();
1580 size_t len
= UTF8Length(wcstr
, wclen
);
1582 wxCharBuffer
buffer(len
+1);
1583 UTF8FromUTF16(wcstr
, wclen
, buffer
.data(), len
);
1585 // TODO check NULL termination!!