no 68k macs more to support...

[wxWidgets.git] / src / stc / stc.cpp.in

diff --git a/src/stc/stc.cpp.in b/src/stc/stc.cpp.in
index 7459ffa401ed44758d28da62f1087e280ba8effd..592e6da131fda58cd00dedd231adecd199b02e4f 100644 (file)
--- a/src/stc/stc.cpp.in
+++ b/src/stc/stc.cpp.in
@@ -1,6 +1,6 @@
 ////////////////////////////////////////////////////////////////////////////
 // Name:        stc.cpp
 ////////////////////////////////////////////////////////////////////////////
 // Name:        stc.cpp

-// Purpose:     A wxWindows implementation of Scintilla.  This class is the
+// Purpose:     A wxWidgets implementation of Scintilla.  This class is the

 //              one meant to be used directly by wx applications.  It does not
 //              derive directly from the Scintilla classes, but instead
 //              delegates most things to the real Scintilla class.
 //              one meant to be used directly by wx applications.  It does not
 //              derive directly from the Scintilla classes, but instead
 //              delegates most things to the real Scintilla class.


@@ -15,17 +15,29 @@
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 

-#include <ctype.h>
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+    #pragma hdrstop
+#endif
+
+#if wxUSE_STC

 
 #include "wx/stc/stc.h"
 
 #include "wx/stc/stc.h"

-#include "ScintillaWX.h"

 
 

-#include <wx/wx.h>
-#include <wx/tokenzr.h>
-#include <wx/mstream.h>
-#include <wx/image.h>
-#include <wx/file.h>
+#ifndef WX_PRECOMP
+    #include "wx/wx.h"
+#endif // WX_PRECOMP
+
+#include <ctype.h>

 
 

+#include "wx/tokenzr.h"
+#include "wx/mstream.h"
+#include "wx/image.h"
+#include "wx/file.h"
+
+#include "ScintillaWX.h"

 
 //----------------------------------------------------------------------
 
 
 //----------------------------------------------------------------------
 


@@ -46,19 +58,28 @@ static long wxColourAsLong(const wxColour& co) {
 
 static wxColour wxColourFromLong(long c) {
     wxColour clr;
 
 static wxColour wxColourFromLong(long c) {
     wxColour clr;

-    clr.Set(c & 0xff, (c >> 8) & 0xff, (c >> 16) & 0xff);
+    clr.Set((unsigned char)(c & 0xff),
+            (unsigned char)((c >> 8) & 0xff),
+            (unsigned char)((c >> 16) & 0xff));

     return clr;
 }
 
 
 static wxColour wxColourFromSpec(const wxString& spec) {
     return clr;
 }
 
 
 static wxColour wxColourFromSpec(const wxString& spec) {

-    // spec should be "#RRGGBB"
-    long red, green, blue;
-    red = green = blue = 0;
-    spec.Mid(1,2).ToLong(&red,   16);
-    spec.Mid(3,2).ToLong(&green, 16);
-    spec.Mid(5,2).ToLong(&blue,  16);
-    return wxColour(red, green, blue);
+    // spec should be a colour name or "#RRGGBB"
+    if (spec.GetChar(0) == wxT('#')) {
+
+        long red, green, blue;
+        red = green = blue = 0;
+        spec.Mid(1,2).ToLong(&red,   16);
+        spec.Mid(3,2).ToLong(&green, 16);
+        spec.Mid(5,2).ToLong(&blue,  16);
+        return wxColour((unsigned char)red,
+                        (unsigned char)green,
+                        (unsigned char)blue);
+    }
+    else
+        return wxColour(spec);

 }
 
 //----------------------------------------------------------------------
 }
 
 //----------------------------------------------------------------------


@@ -76,7 +97,6 @@ DEFINE_EVENT_TYPE( wxEVT_STC_MODIFIED )
 DEFINE_EVENT_TYPE( wxEVT_STC_MACRORECORD )
 DEFINE_EVENT_TYPE( wxEVT_STC_MARGINCLICK )
 DEFINE_EVENT_TYPE( wxEVT_STC_NEEDSHOWN )
 DEFINE_EVENT_TYPE( wxEVT_STC_MACRORECORD )
 DEFINE_EVENT_TYPE( wxEVT_STC_MARGINCLICK )
 DEFINE_EVENT_TYPE( wxEVT_STC_NEEDSHOWN )

-DEFINE_EVENT_TYPE( wxEVT_STC_POSCHANGED )

 DEFINE_EVENT_TYPE( wxEVT_STC_PAINTED )
 DEFINE_EVENT_TYPE( wxEVT_STC_USERLISTSELECTION )
 DEFINE_EVENT_TYPE( wxEVT_STC_URIDROPPED )
 DEFINE_EVENT_TYPE( wxEVT_STC_PAINTED )
 DEFINE_EVENT_TYPE( wxEVT_STC_USERLISTSELECTION )
 DEFINE_EVENT_TYPE( wxEVT_STC_URIDROPPED )


@@ -89,6 +109,7 @@ DEFINE_EVENT_TYPE( wxEVT_STC_ZOOM )
 DEFINE_EVENT_TYPE( wxEVT_STC_HOTSPOT_CLICK )
 DEFINE_EVENT_TYPE( wxEVT_STC_HOTSPOT_DCLICK )
 DEFINE_EVENT_TYPE( wxEVT_STC_CALLTIP_CLICK )
 DEFINE_EVENT_TYPE( wxEVT_STC_HOTSPOT_CLICK )
 DEFINE_EVENT_TYPE( wxEVT_STC_HOTSPOT_DCLICK )
 DEFINE_EVENT_TYPE( wxEVT_STC_CALLTIP_CLICK )

+DEFINE_EVENT_TYPE( wxEVT_STC_AUTOCOMP_SELECTION )    

 
 
 
 
 
 


@@ -116,7 +137,7 @@ BEGIN_EVENT_TABLE(wxStyledTextCtrl, wxControl)
     EVT_SYS_COLOUR_CHANGED      (wxStyledTextCtrl::OnSysColourChanged)
     EVT_ERASE_BACKGROUND        (wxStyledTextCtrl::OnEraseBackground)
     EVT_MENU_RANGE              (10, 16, wxStyledTextCtrl::OnMenu)
     EVT_SYS_COLOUR_CHANGED      (wxStyledTextCtrl::OnSysColourChanged)
     EVT_ERASE_BACKGROUND        (wxStyledTextCtrl::OnEraseBackground)
     EVT_MENU_RANGE              (10, 16, wxStyledTextCtrl::OnMenu)

-    EVT_LISTBOX_DCLICK          (-1, wxStyledTextCtrl::OnListBox)
+    EVT_LISTBOX_DCLICK          (wxID_ANY, wxStyledTextCtrl::OnListBox)

 END_EVENT_TABLE()
 
 
 END_EVENT_TABLE()
 
 


@@ -143,32 +164,37 @@ wxStyledTextCtrl::wxStyledTextCtrl(wxWindow *parent,
 }
 
 
 }
 
 

-void wxStyledTextCtrl::Create(wxWindow *parent,
-                                   wxWindowID id,
-                                   const wxPoint& pos,
-                                   const wxSize& size,
-                                   long style,
-                                   const wxString& name)
+bool wxStyledTextCtrl::Create(wxWindow *parent,
+                              wxWindowID id,
+                              const wxPoint& pos,
+                              const wxSize& size,
+                              long style,
+                              const wxString& name)

 {
 {

-#ifdef __WXMAC__

     style |= wxVSCROLL | wxHSCROLL;
     style |= wxVSCROLL | wxHSCROLL;

-#endif
-    wxControl::Create(parent, id, pos, size,
-              style | wxWANTS_CHARS | wxCLIP_CHILDREN,
-              wxDefaultValidator, name);
+    if (!wxControl::Create(parent, id, pos, size,
+                           style | wxWANTS_CHARS | wxCLIP_CHILDREN,
+                           wxDefaultValidator, name))
+        return false;

 
 #ifdef LINK_LEXERS
     Scintilla_LinkLexers();
 #endif
     m_swx = new ScintillaWX(this);
     m_stopWatch.Start();
 
 #ifdef LINK_LEXERS
     Scintilla_LinkLexers();
 #endif
     m_swx = new ScintillaWX(this);
     m_stopWatch.Start();

-    m_lastKeyDownConsumed = FALSE;
+    m_lastKeyDownConsumed = false;

     m_vScrollBar = NULL;
     m_hScrollBar = NULL;
 #if wxUSE_UNICODE
     // Put Scintilla into unicode (UTF-8) mode
     SetCodePage(wxSTC_CP_UTF8);
 #endif
     m_vScrollBar = NULL;
     m_hScrollBar = NULL;
 #if wxUSE_UNICODE
     // Put Scintilla into unicode (UTF-8) mode
     SetCodePage(wxSTC_CP_UTF8);
 #endif

+
+    SetInitialSize(size);
+
+    // Reduces flicker on GTK+/X11
+    SetBackgroundStyle(wxBG_STYLE_CUSTOM);
+    return true;

 }
 
 
 }
 
 


@@ -184,7 +210,26 @@ long wxStyledTextCtrl::SendMsg(int msg, long wp, long lp) {
     return m_swx->WndProc(msg, wp, lp);
 }
 
     return m_swx->WndProc(msg, wp, lp);
 }
 

+//----------------------------------------------------------------------
+
+// Set the vertical scrollbar to use instead of the ont that's built-in.
+void wxStyledTextCtrl::SetVScrollBar(wxScrollBar* bar)  {
+    m_vScrollBar = bar;
+    if (bar != NULL) {
+        // ensure that the built-in scrollbar is not visible
+        SetScrollbar(wxVERTICAL, 0, 0, 0);
+    }
+}
+

 
 

+// Set the horizontal scrollbar to use instead of the ont that's built-in.
+void wxStyledTextCtrl::SetHScrollBar(wxScrollBar* bar)  {
+    m_hScrollBar = bar;
+    if (bar != NULL) {
+        // ensure that the built-in scrollbar is not visible
+        SetScrollbar(wxHORIZONTAL, 0, 0, 0);
+    }
+}

 
 //----------------------------------------------------------------------
 // BEGIN generated section.  The following code is automatically generated
 
 //----------------------------------------------------------------------
 // BEGIN generated section.  The following code is automatically generated


@@ -209,8 +254,8 @@ int wxStyledTextCtrl::GetCurrentLine() {
 //
 //      bold                    turns on bold
 //      italic                  turns on italics
 //
 //      bold                    turns on bold
 //      italic                  turns on italics

-//      fore:#RRGGBB            sets the foreground colour
-//      back:#RRGGBB            sets the background colour
+//      fore:[name or #RRGGBB]  sets the foreground colour
+//      back:[name or #RRGGBB]  sets the background colour

 //      face:[facename]         sets the font face name to use
 //      size:[num]              sets the font size in points
 //      eol                     turns on eol filling
 //      face:[facename]         sets the font face name to use
 //      size:[num]              sets the font size in points
 //      eol                     turns on eol filling


@@ -263,28 +308,135 @@ void wxStyledTextCtrl::StyleSetFont(int styleNum, wxFont& font) {
     int x, y;
     GetTextExtent(wxT("X"), &x, &y, NULL, NULL, &font);
 #endif
     int x, y;
     GetTextExtent(wxT("X"), &x, &y, NULL, NULL, &font);
 #endif

-    int      size     = font.GetPointSize();
-    wxString faceName = font.GetFaceName();
-    bool     bold     = font.GetWeight() == wxBOLD;
-    bool     italic   = font.GetStyle() != wxNORMAL;
-    bool     under    = font.GetUnderlined();
-
-    // TODO: add encoding/charset mapping
-    StyleSetFontAttr(styleNum, size, faceName, bold, italic, under);
+    int            size     = font.GetPointSize();
+    wxString       faceName = font.GetFaceName();
+    bool           bold     = font.GetWeight() == wxBOLD;
+    bool           italic   = font.GetStyle() != wxNORMAL;
+    bool           under    = font.GetUnderlined();
+    wxFontEncoding encoding = font.GetEncoding();
+    
+    StyleSetFontAttr(styleNum, size, faceName, bold, italic, under, encoding);

 }
 
 // Set all font style attributes at once.
 void wxStyledTextCtrl::StyleSetFontAttr(int styleNum, int size,
                                         const wxString& faceName,
                                         bool bold, bool italic,
 }
 
 // Set all font style attributes at once.
 void wxStyledTextCtrl::StyleSetFontAttr(int styleNum, int size,
                                         const wxString& faceName,
                                         bool bold, bool italic,

-                                        bool underline) {
+                                        bool underline,
+                                        wxFontEncoding encoding) {

     StyleSetSize(styleNum, size);
     StyleSetFaceName(styleNum, faceName);
     StyleSetBold(styleNum, bold);
     StyleSetItalic(styleNum, italic);
     StyleSetUnderline(styleNum, underline);
     StyleSetSize(styleNum, size);
     StyleSetFaceName(styleNum, faceName);
     StyleSetBold(styleNum, bold);
     StyleSetItalic(styleNum, italic);
     StyleSetUnderline(styleNum, underline);

+    StyleSetFontEncoding(styleNum, encoding);
+}

 
 

-    // TODO: add encoding/charset mapping
+
+// Set the character set of the font in a style.  Converts the Scintilla
+// character set values to a wxFontEncoding.
+void wxStyledTextCtrl::StyleSetCharacterSet(int style, int characterSet)
+{
+    wxFontEncoding encoding;
+
+    // Translate the Scintilla characterSet to a wxFontEncoding
+    switch (characterSet) {
+        default:
+        case wxSTC_CHARSET_ANSI:
+        case wxSTC_CHARSET_DEFAULT:
+            encoding = wxFONTENCODING_DEFAULT;
+            break;
+
+        case wxSTC_CHARSET_BALTIC:
+            encoding = wxFONTENCODING_ISO8859_13;
+            break;
+
+        case wxSTC_CHARSET_CHINESEBIG5:
+            encoding = wxFONTENCODING_CP950;
+            break;
+
+        case wxSTC_CHARSET_EASTEUROPE:
+            encoding = wxFONTENCODING_ISO8859_2;
+            break;
+
+        case wxSTC_CHARSET_GB2312:
+            encoding = wxFONTENCODING_CP936;
+            break;
+
+        case wxSTC_CHARSET_GREEK:
+            encoding = wxFONTENCODING_ISO8859_7;
+            break;
+
+        case wxSTC_CHARSET_HANGUL:
+            encoding = wxFONTENCODING_CP949;
+            break;
+
+        case wxSTC_CHARSET_MAC:
+            encoding = wxFONTENCODING_DEFAULT;
+            break;
+
+        case wxSTC_CHARSET_OEM:
+            encoding = wxFONTENCODING_DEFAULT;
+            break;
+
+        case wxSTC_CHARSET_RUSSIAN:
+            encoding = wxFONTENCODING_KOI8;
+            break;
+
+        case wxSTC_CHARSET_SHIFTJIS:
+            encoding = wxFONTENCODING_CP932;
+            break;
+
+        case wxSTC_CHARSET_SYMBOL:
+            encoding = wxFONTENCODING_DEFAULT;
+            break;
+
+        case wxSTC_CHARSET_TURKISH:
+            encoding = wxFONTENCODING_ISO8859_9;
+            break;
+
+        case wxSTC_CHARSET_JOHAB:
+            encoding = wxFONTENCODING_DEFAULT;
+            break;
+
+        case wxSTC_CHARSET_HEBREW:
+            encoding = wxFONTENCODING_ISO8859_8;
+            break;
+
+        case wxSTC_CHARSET_ARABIC:
+            encoding = wxFONTENCODING_ISO8859_6;
+            break;
+
+        case wxSTC_CHARSET_VIETNAMESE:
+            encoding = wxFONTENCODING_DEFAULT;
+            break;
+
+        case wxSTC_CHARSET_THAI:
+            encoding = wxFONTENCODING_ISO8859_11;
+            break;
+
+        case wxSTC_CHARSET_CYRILLIC:
+            encoding = wxFONTENCODING_ISO8859_5;
+            break;
+                
+        case wxSTC_CHARSET_8859_15:
+            encoding = wxFONTENCODING_ISO8859_15;;
+            break;
+    }
+
+    // We just have Scintilla track the wxFontEncoding for us.  It gets used
+    // in Font::Create in PlatWX.cpp.  We add one to the value so that the
+    // effective wxFONENCODING_DEFAULT == SC_SHARSET_DEFAULT and so when
+    // Scintilla internally uses SC_CHARSET_DEFAULT we will translate it back
+    // to wxFONENCODING_DEFAULT in Font::Create.
+    SendMsg(SCI_STYLESETCHARACTERSET, style, encoding+1);
+}
+
+
+// Set the font encoding to be used by a style.
+void wxStyledTextCtrl::StyleSetFontEncoding(int style, wxFontEncoding encoding)
+{
+    SendMsg(SCI_STYLESETCHARACTERSET, style, encoding+1);

 }
 
 
 }
 
 


@@ -334,7 +486,7 @@ bool wxStyledTextCtrl::SaveFile(const wxString& filename)
     wxFile file(filename, wxFile::write);
 
     if (!file.IsOpened())
     wxFile file(filename, wxFile::write);
 
     if (!file.IsOpened())

-        return FALSE;
+        return false;

 
     bool success = file.Write(GetText(), *wxConvCurrent);
 
 
     bool success = file.Write(GetText(), *wxConvCurrent);
 


@@ -352,13 +504,18 @@ bool wxStyledTextCtrl::LoadFile(const wxString& filename)
     if (file.IsOpened())
     {
         wxString contents;
     if (file.IsOpened())
     {
         wxString contents;

-        off_t len = file.Length();
+        // get the file size (assume it is not huge file...)
+        ssize_t len = (ssize_t)file.Length();
+

         if (len > 0)
         {
 #if wxUSE_UNICODE
         if (len > 0)
         {
 #if wxUSE_UNICODE

-            wxMemoryBuffer buffer(len);
+            wxMemoryBuffer buffer(len+1);

             success = (file.Read(buffer.GetData(), len) == len);
             success = (file.Read(buffer.GetData(), len) == len);

-            contents = wxString(buffer, *wxConvCurrent);
+            if (success) {
+                ((char*)buffer.GetData())[len] = 0;
+                contents = wxString(buffer, *wxConvCurrent, len);
+            }

 #else
             wxString buffer;
             success = (file.Read(wxStringBuffer(buffer, len), len) == len);
 #else
             wxString buffer;
             success = (file.Read(wxStringBuffer(buffer, len), len) == len);


@@ -366,7 +523,12 @@ bool wxStyledTextCtrl::LoadFile(const wxString& filename)
 #endif
         }
         else
 #endif
         }
         else

-            success = true;            // empty file is ok
+        {
+            if (len == 0)
+                success = true;  // empty file is ok
+            else
+                success = false; // len == wxInvalidOffset
+        }

 
         if (success)
         {
 
         if (success)
         {


@@ -381,12 +543,12 @@ bool wxStyledTextCtrl::LoadFile(const wxString& filename)
 
 
 #if wxUSE_DRAG_AND_DROP
 
 
 #if wxUSE_DRAG_AND_DROP

-wxDragResult wxStyledTextCtrl::DoDragOver(wxCoord x, wxCoord y, wxDragResult def) { 
-        return m_swx->DoDragOver(x, y, def); 
-} 
+wxDragResult wxStyledTextCtrl::DoDragOver(wxCoord x, wxCoord y, wxDragResult def) {
+        return m_swx->DoDragOver(x, y, def);
+}

 
 
 
 

-bool wxStyledTextCtrl::DoDropText(long x, long y, const wxString& data) { 
+bool wxStyledTextCtrl::DoDropText(long x, long y, const wxString& data) {

     return m_swx->DoDropText(x, y, data);
 }
 #endif
     return m_swx->DoDropText(x, y, data);
 }
 #endif


@@ -400,6 +562,109 @@ bool wxStyledTextCtrl::GetUseAntiAliasing() {
     return m_swx->GetUseAntiAliasing();
 }
 
     return m_swx->GetUseAntiAliasing();
 }
 

+
+
+
+
+void wxStyledTextCtrl::AddTextRaw(const char* text)
+{
+    SendMsg(SCI_ADDTEXT, strlen(text), (long)text);
+}
+
+void wxStyledTextCtrl::InsertTextRaw(int pos, const char* text)
+{
+    SendMsg(SCI_INSERTTEXT, pos, (long)text);
+}
+
+wxCharBuffer wxStyledTextCtrl::GetCurLineRaw(int* linePos)
+{
+    int len = LineLength(GetCurrentLine());
+    if (!len) {
+        if (linePos)  *linePos = 0;
+        wxCharBuffer empty;
+        return empty;
+    }
+
+    wxCharBuffer buf(len);
+    int pos = SendMsg(SCI_GETCURLINE, len, (long)buf.data());
+    if (linePos)  *linePos = pos;
+    return buf;
+}
+
+wxCharBuffer wxStyledTextCtrl::GetLineRaw(int line)
+{
+    int len = LineLength(line);
+    if (!len) {
+        wxCharBuffer empty;
+        return empty;
+    }
+
+    wxCharBuffer buf(len);
+    SendMsg(SCI_GETLINE, line, (long)buf.data());
+    return buf;
+}
+
+wxCharBuffer wxStyledTextCtrl::GetSelectedTextRaw()
+{
+    int   start;
+    int   end;
+
+    GetSelection(&start, &end);
+    int   len  = end - start;
+    if (!len) {
+        wxCharBuffer empty;
+        return empty;
+    }        
+
+    wxCharBuffer buf(len);
+    SendMsg(SCI_GETSELTEXT, 0, (long)buf.data());
+    return buf;
+}
+
+wxCharBuffer wxStyledTextCtrl::GetTextRangeRaw(int startPos, int endPos)
+{
+    if (endPos < startPos) {
+        int temp = startPos;
+        startPos = endPos;
+        endPos = temp;
+    }
+    int len  = endPos - startPos;
+    if (!len) {
+        wxCharBuffer empty;
+        return empty;
+    }        
+
+    wxCharBuffer buf(len);
+    TextRange tr;
+    tr.lpstrText = buf.data();
+    tr.chrg.cpMin = startPos;
+    tr.chrg.cpMax = endPos;
+    SendMsg(SCI_GETTEXTRANGE, 0, (long)&tr);
+    return buf;
+}
+
+void wxStyledTextCtrl::SetTextRaw(const char* text)
+{
+    SendMsg(SCI_SETTEXT, 0, (long)text);
+}
+
+wxCharBuffer wxStyledTextCtrl::GetTextRaw()
+{
+    int len  = GetTextLength();
+    wxCharBuffer buf(len);
+    SendMsg(SCI_GETTEXT, len, (long)buf.data());
+    return buf;
+}
+
+void wxStyledTextCtrl::AppendTextRaw(const char* text)
+{
+    SendMsg(SCI_APPENDTEXT, strlen(text), (long)text);
+}
+
+
+
+
+

 //----------------------------------------------------------------------
 // Event handlers
 
 //----------------------------------------------------------------------
 // Event handlers
 


@@ -487,40 +752,60 @@ void wxStyledTextCtrl::OnMouseWheel(wxMouseEvent& evt) {
 
 
 void wxStyledTextCtrl::OnChar(wxKeyEvent& evt) {
 
 
 void wxStyledTextCtrl::OnChar(wxKeyEvent& evt) {

-    // On (some?) non-US keyboards the AltGr key is required to enter some
+    // On (some?) non-US PC keyboards the AltGr key is required to enter some

     // common characters.  It comes to us as both Alt and Ctrl down so we need
     // to let the char through in that case, otherwise if only ctrl or only
     // alt let's skip it.
     bool ctrl = evt.ControlDown();
     // common characters.  It comes to us as both Alt and Ctrl down so we need
     // to let the char through in that case, otherwise if only ctrl or only
     // alt let's skip it.
     bool ctrl = evt.ControlDown();

+#ifdef __WXMAC__
+    // On the Mac the Alt key is just a modifier key (like Shift) so we need
+    // to allow the char events to be processed when Alt is pressed.
+    // TODO:  Should we check MetaDown instead in this case?
+    bool alt = false;
+#else

     bool alt  = evt.AltDown();
     bool alt  = evt.AltDown();

+#endif

     bool skip = ((ctrl || alt) && ! (ctrl && alt));
 
     bool skip = ((ctrl || alt) && ! (ctrl && alt));
 

-    int key = evt.GetKeyCode();
-
-//     printf("OnChar key:%%d  consumed:%%d  ctrl:%%d  alt:%%d  skip:%%d\n",
-//            key, m_lastKeyDownConsumed, ctrl, alt, skip);
+#if wxUSE_UNICODE
+    // apparently if we don't do this, Unicode keys pressed after non-char
+    // ASCII ones (e.g. Enter, Tab) are not taken into account (patch 1615989)
+    if (m_lastKeyDownConsumed && evt.GetUnicodeKey() > 255)
+        m_lastKeyDownConsumed = false;
+#endif

 
 

-    if ( (key <= WXK_START || key > WXK_COMMAND) &&
-         !m_lastKeyDownConsumed && !skip) {
-        m_swx->DoAddChar(key);
-        return;
+    if (!m_lastKeyDownConsumed && !skip) {
+#if wxUSE_UNICODE
+        int key = evt.GetUnicodeKey();
+        bool keyOk = true;
+
+        // if the unicode key code is not really a unicode character (it may
+        // be a function key or etc., the platforms appear to always give us a
+        // small value in this case) then fallback to the ascii key code but
+        // don't do anything for function keys or etc.
+        if (key <= 127) {
+            key = evt.GetKeyCode();
+            keyOk = (key <= 127);
+        }
+        if (keyOk) {
+            m_swx->DoAddChar(key);
+            return;
+        }
+#else
+        int key = evt.GetKeyCode();
+        if (key <= WXK_START || key > WXK_COMMAND) {
+            m_swx->DoAddChar(key);
+            return;
+        }
+#endif

     }
     }

+    

     evt.Skip();
 }
 
 
 void wxStyledTextCtrl::OnKeyDown(wxKeyEvent& evt) {
     evt.Skip();
 }
 
 
 void wxStyledTextCtrl::OnKeyDown(wxKeyEvent& evt) {

-    int key = evt.GetKeyCode();
-    bool shift = evt.ShiftDown(),
-         ctrl  = evt.ControlDown(),
-         alt   = evt.AltDown(),
-         meta  = evt.MetaDown();
-
-    int processed = m_swx->DoKeyDown(key, shift, ctrl, alt, meta, &m_lastKeyDownConsumed);
-
-//     printf("KeyDn  key:%%d  shift:%%d  ctrl:%%d  alt:%%d  processed:%%d  consumed:%%d\n",
-//            key, shift, ctrl, alt, processed, m_lastKeyDownConsumed);
-
+    int processed = m_swx->DoKeyDown(evt, &m_lastKeyDownConsumed);

     if (!processed && !m_lastKeyDownConsumed)
         evt.Skip();
 }
     if (!processed && !m_lastKeyDownConsumed)
         evt.Skip();
 }


@@ -564,6 +849,14 @@ void wxStyledTextCtrl::OnIdle(wxIdleEvent& evt) {
 }
 
 
 }
 
 

+wxSize wxStyledTextCtrl::DoGetBestSize() const
+{
+    // What would be the best size for a wxSTC?
+    // Just give a reasonable minimum until something else can be figured out.
+    return wxSize(200,100);
+}
+
+

 //----------------------------------------------------------------------
 // Turn notifications from Scintilla into events
 
 //----------------------------------------------------------------------
 // Turn notifications from Scintilla into events
 


@@ -579,12 +872,7 @@ static void SetEventText(wxStyledTextEvent& evt, const char* text,
                          size_t length) {
     if(!text) return;
 
                          size_t length) {
     if(!text) return;
 

-    // The unicode conversion MUST have a null byte to terminate the
-    // string so move it into a buffer first and give it one.
-    wxMemoryBuffer buf(length+1);
-    buf.AppendData((void*)text, length);
-    buf.AppendByte(0);
-    evt.SetText(stc2wx(buf));
+    evt.SetText(stc2wx(text, length));

 }
 
 
 }
 
 


@@ -662,10 +950,18 @@ void wxStyledTextCtrl::NotifyParent(SCNotification* _scn) {
         evt.SetEventType(wxEVT_STC_PAINTED);
         break;
 
         evt.SetEventType(wxEVT_STC_PAINTED);
         break;
 

+    case SCN_AUTOCSELECTION:
+        evt.SetEventType(wxEVT_STC_AUTOCOMP_SELECTION);
+        evt.SetListType(scn.listType);
+        SetEventText(evt, scn.text, strlen(scn.text));
+        evt.SetPosition(scn.lParam);
+        break;
+        

     case SCN_USERLISTSELECTION:
         evt.SetEventType(wxEVT_STC_USERLISTSELECTION);
         evt.SetListType(scn.listType);
         SetEventText(evt, scn.text, strlen(scn.text));
     case SCN_USERLISTSELECTION:
         evt.SetEventType(wxEVT_STC_USERLISTSELECTION);
         evt.SetListType(scn.listType);
         SetEventText(evt, scn.text, strlen(scn.text));

+        evt.SetPosition(scn.lParam);

         break;
 
     case SCN_URIDROPPED:
         break;
 
     case SCN_URIDROPPED:


@@ -700,7 +996,7 @@ void wxStyledTextCtrl::NotifyParent(SCNotification* _scn) {
     case SCN_CALLTIPCLICK:
         evt.SetEventType(wxEVT_STC_CALLTIP_CLICK);
         break;
     case SCN_CALLTIPCLICK:
         evt.SetEventType(wxEVT_STC_CALLTIP_CLICK);
         break;

-
+       

     default:
         return;
     }
     default:
         return;
     }


@@ -732,7 +1028,7 @@ wxStyledTextEvent::wxStyledTextEvent(wxEventType commandType, int id)
     m_listType = 0;
     m_x = 0;
     m_y = 0;
     m_listType = 0;
     m_x = 0;
     m_y = 0;

-    m_dragAllowMove = FALSE;
+    m_dragAllowMove = false;

 #if wxUSE_DRAG_AND_DROP
     m_dragResult = wxDragNone;
 #endif
 #if wxUSE_DRAG_AND_DROP
     m_dragResult = wxDragNone;
 #endif


@@ -777,11 +1073,4 @@ wxStyledTextEvent::wxStyledTextEvent(const wxStyledTextEvent& event):
 //----------------------------------------------------------------------
 //----------------------------------------------------------------------
 
 //----------------------------------------------------------------------
 //----------------------------------------------------------------------
 

-
-
-
-
-
-
-
-
+#endif // wxUSE_STC