src/msw/textctrl.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        msw/textctrl.cpp
   3 // Purpose:     wxTextCtrl
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  17     #pragma implementation "textctrl.h"
  18 #endif
  19
  20 // ----------------------------------------------------------------------------
  21 // headers
  22 // ----------------------------------------------------------------------------
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #if wxUSE_TEXTCTRL && !(defined(__SMARTPHONE__) && defined(__WXWINCE__))
  32
  33 #ifndef WX_PRECOMP
  34     #include "wx/textctrl.h"
  35     #include "wx/settings.h"
  36     #include "wx/brush.h"
  37     #include "wx/utils.h"
  38     #include "wx/intl.h"
  39     #include "wx/log.h"
  40     #include "wx/app.h"
  41     #include "wx/menu.h"
  42 #endif
  43
  44 #include "wx/module.h"
  45
  46 #if wxUSE_CLIPBOARD
  47     #include "wx/clipbrd.h"
  48 #endif
  49
  50 #include "wx/textfile.h"
  51
  52 #include <windowsx.h>
  53
  54 #include "wx/msw/private.h"
  55 #include "wx/msw/winundef.h"
  56
  57 #include <string.h>
  58 #include <stdlib.h>
  59
  60 #ifndef __WXWINCE__
  61 #include <sys/types.h>
  62 #endif
  63
  64 #if wxUSE_RICHEDIT
  65
  66 // old mingw32 has richedit stuff directly in windows.h and doesn't have
  67 // richedit.h at all
  68 #if !defined(__GNUWIN32_OLD__) || defined(__CYGWIN10__)
  69     #include <richedit.h>
  70 #endif
  71
  72 #include "wx/msw/missing.h"
  73
  74 #endif // wxUSE_RICHEDIT
  75
  76 // ----------------------------------------------------------------------------
  77 // private classes
  78 // ----------------------------------------------------------------------------
  79
  80 #if wxUSE_RICHEDIT
  81
  82 // this module initializes RichEdit DLL(s) if needed
  83 class wxRichEditModule : public wxModule
  84 {
  85 public:
  86     virtual bool OnInit();
  87     virtual void OnExit();
  88
  89     // load the richedit DLL of at least of required version
  90     static bool Load(int version = 1);
  91
  92 private:
  93     // the handles to richedit 1.0 and 2.0 (or 3.0) DLLs
  94     static HINSTANCE ms_hRichEdit[2];
  95
  96     DECLARE_DYNAMIC_CLASS(wxRichEditModule)
  97 };
  98
  99 HINSTANCE wxRichEditModule::ms_hRichEdit[2] = { NULL, NULL };
 100
 101 IMPLEMENT_DYNAMIC_CLASS(wxRichEditModule, wxModule)
 102
 103 #endif // wxUSE_RICHEDIT
 104
 105 // ----------------------------------------------------------------------------
 106 // event tables and other macros
 107 // ----------------------------------------------------------------------------
 108
 109 #if wxUSE_EXTENDED_RTTI
 110 WX_DEFINE_FLAGS( wxTextCtrlStyle )
 111
 112 wxBEGIN_FLAGS( wxTextCtrlStyle )
 113     // new style border flags, we put them first to
 114     // use them for streaming out
 115     wxFLAGS_MEMBER(wxBORDER_SIMPLE)
 116     wxFLAGS_MEMBER(wxBORDER_SUNKEN)
 117     wxFLAGS_MEMBER(wxBORDER_DOUBLE)
 118     wxFLAGS_MEMBER(wxBORDER_RAISED)
 119     wxFLAGS_MEMBER(wxBORDER_STATIC)
 120     wxFLAGS_MEMBER(wxBORDER_NONE)
 121
 122     // old style border flags
 123     wxFLAGS_MEMBER(wxSIMPLE_BORDER)
 124     wxFLAGS_MEMBER(wxSUNKEN_BORDER)
 125     wxFLAGS_MEMBER(wxDOUBLE_BORDER)
 126     wxFLAGS_MEMBER(wxRAISED_BORDER)
 127     wxFLAGS_MEMBER(wxSTATIC_BORDER)
 128     wxFLAGS_MEMBER(wxBORDER)
 129
 130     // standard window styles
 131     wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
 132     wxFLAGS_MEMBER(wxCLIP_CHILDREN)
 133     wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
 134     wxFLAGS_MEMBER(wxWANTS_CHARS)
 135     wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
 136     wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
 137     wxFLAGS_MEMBER(wxVSCROLL)
 138     wxFLAGS_MEMBER(wxHSCROLL)
 139
 140     wxFLAGS_MEMBER(wxTE_PROCESS_ENTER)
 141     wxFLAGS_MEMBER(wxTE_PROCESS_TAB)
 142     wxFLAGS_MEMBER(wxTE_MULTILINE)
 143     wxFLAGS_MEMBER(wxTE_PASSWORD)
 144     wxFLAGS_MEMBER(wxTE_READONLY)
 145     wxFLAGS_MEMBER(wxHSCROLL)
 146     wxFLAGS_MEMBER(wxTE_RICH)
 147     wxFLAGS_MEMBER(wxTE_RICH2)
 148     wxFLAGS_MEMBER(wxTE_AUTO_URL)
 149     wxFLAGS_MEMBER(wxTE_NOHIDESEL)
 150     wxFLAGS_MEMBER(wxTE_LEFT)
 151     wxFLAGS_MEMBER(wxTE_CENTRE)
 152     wxFLAGS_MEMBER(wxTE_RIGHT)
 153     wxFLAGS_MEMBER(wxTE_DONTWRAP)
 154     wxFLAGS_MEMBER(wxTE_LINEWRAP)
 155     wxFLAGS_MEMBER(wxTE_WORDWRAP)
 156
 157 wxEND_FLAGS( wxTextCtrlStyle )
 158
 159 IMPLEMENT_DYNAMIC_CLASS_XTI(wxTextCtrl, wxControl,"wx/textctrl.h")
 160
 161 wxBEGIN_PROPERTIES_TABLE(wxTextCtrl)
 162     wxEVENT_PROPERTY( TextUpdated , wxEVT_COMMAND_TEXT_UPDATED , wxCommandEvent )
 163     wxEVENT_PROPERTY( TextEnter , wxEVT_COMMAND_TEXT_ENTER , wxCommandEvent )
 164
 165     wxPROPERTY( Font , wxFont , SetFont , GetFont  , EMPTY_MACROVALUE, 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
 166     wxPROPERTY( Value , wxString , SetValue, GetValue, wxString() , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 167     wxPROPERTY_FLAGS( WindowStyle , wxTextCtrlStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
 168 wxEND_PROPERTIES_TABLE()
 169
 170 wxBEGIN_HANDLERS_TABLE(wxTextCtrl)
 171 wxEND_HANDLERS_TABLE()
 172
 173 wxCONSTRUCTOR_6( wxTextCtrl , wxWindow* , Parent , wxWindowID , Id , wxString , Value , wxPoint , Position , wxSize , Size , long , WindowStyle)
 174 #else
 175 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)
 176 #endif
 177
 178
 179 BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
 180     EVT_CHAR(wxTextCtrl::OnChar)
 181     EVT_DROP_FILES(wxTextCtrl::OnDropFiles)
 182
 183 #if wxUSE_RICHEDIT
 184     EVT_RIGHT_UP(wxTextCtrl::OnRightClick)
 185 #endif
 186
 187     EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
 188     EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
 189     EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
 190     EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
 191     EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
 192     EVT_MENU(wxID_CLEAR, wxTextCtrl::OnDelete)
 193     EVT_MENU(wxID_SELECTALL, wxTextCtrl::OnSelectAll)
 194
 195     EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
 196     EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
 197     EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
 198     EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
 199     EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
 200     EVT_UPDATE_UI(wxID_CLEAR, wxTextCtrl::OnUpdateDelete)
 201     EVT_UPDATE_UI(wxID_SELECTALL, wxTextCtrl::OnUpdateSelectAll)
 202
 203     EVT_SET_FOCUS(wxTextCtrl::OnSetFocus)
 204 END_EVENT_TABLE()
 205
 206 // ============================================================================
 207 // implementation
 208 // ============================================================================
 209
 210 // ----------------------------------------------------------------------------
 211 // creation
 212 // ----------------------------------------------------------------------------
 213
 214 void wxTextCtrl::Init()
 215 {
 216 #if wxUSE_RICHEDIT
 217     m_verRichEdit = 0;
 218 #endif // wxUSE_RICHEDIT
 219
 220     m_privateContextMenu = NULL;
 221     m_suppressNextUpdate = false;
 222     m_isNativeCaretShown = true;
 223     m_isCaretAtEnd = true;
 224 }
 225
 226 wxTextCtrl::~wxTextCtrl()
 227 {
 228     delete m_privateContextMenu;
 229 }
 230
 231 bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,
 232                         const wxString& value,
 233                         const wxPoint& pos,
 234                         const wxSize& size,
 235                         long style,
 236                         const wxValidator& validator,
 237                         const wxString& name)
 238 {
 239 #ifdef __WXWINCE__
 240     if ((style & wxBORDER_MASK) == 0)
 241         style |= wxBORDER_SIMPLE;
 242 #endif
 243
 244     // base initialization
 245     if ( !CreateControl(parent, id, pos, size, style, validator, name) )
 246         return false;
 247
 248     // translate wxWin style flags to MSW ones
 249     WXDWORD msStyle = MSWGetCreateWindowFlags();
 250
 251     // do create the control - either an EDIT or RICHEDIT
 252     wxString windowClass = wxT("EDIT");
 253
 254 #if wxUSE_RICHEDIT
 255     if ( m_windowStyle & wxTE_AUTO_URL )
 256     {
 257         // automatic URL detection only works in RichEdit 2.0+
 258         m_windowStyle |= wxTE_RICH2;
 259     }
 260
 261     if ( m_windowStyle & wxTE_RICH2 )
 262     {
 263         // using richedit 2.0 implies using wxTE_RICH
 264         m_windowStyle |= wxTE_RICH;
 265     }
 266
 267     // we need to load the richedit DLL before creating the rich edit control
 268     if ( m_windowStyle & wxTE_RICH )
 269     {
 270         static bool s_errorGiven = false;// MT-FIXME
 271
 272         // Which version do we need? Use 1.0 by default because it is much more
 273         // like the the standard EDIT or 2.0 if explicitly requested, but use
 274         // only 2.0 in Unicode mode as 1.0 doesn't support Unicode at all
 275         //
 276         // TODO: RichEdit 3.0 is apparently capable of emulating RichEdit 1.0
 277         //       (and thus EDIT) much better than RichEdit 2.0 so we probably
 278         //       should use 3.0 if available as it is the best of both worlds -
 279         //       but as I can't test it right now I don't do it (VZ)
 280 #if wxUSE_UNICODE
 281         const int verRichEdit = 2;
 282 #else // !wxUSE_UNICODE
 283         int verRichEdit = m_windowStyle & wxTE_RICH2 ? 2 : 1;
 284 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
 285
 286         // only give the error msg once if the DLL can't be loaded
 287         if ( !s_errorGiven )
 288         {
 289             // try to load the RichEdit DLL (will do nothing if already done)
 290             if ( !wxRichEditModule::Load(verRichEdit) )
 291             {
 292 #if !wxUSE_UNICODE
 293                 // try another version?
 294                 verRichEdit = 3 - verRichEdit; // 1 <-> 2
 295
 296                 if ( !wxRichEditModule::Load(verRichEdit) )
 297 #endif // wxUSE_UNICODE
 298                 {
 299                     wxLogError(_("Impossible to create a rich edit control, using simple text control instead. Please reinstall riched32.dll"));
 300
 301                     s_errorGiven = true;
 302                 }
 303             }
 304         }
 305
 306         // have we managed to load any richedit version?
 307         if ( !s_errorGiven )
 308         {
 309             m_verRichEdit = verRichEdit;
 310             if ( m_verRichEdit == 1 )
 311             {
 312                 windowClass = wxT("RICHEDIT");
 313             }
 314             else
 315             {
 316 #ifndef RICHEDIT_CLASS
 317                 wxString RICHEDIT_CLASS;
 318                 RICHEDIT_CLASS.Printf(_T("RichEdit%d0"), m_verRichEdit);
 319 #if wxUSE_UNICODE
 320                 RICHEDIT_CLASS += _T('W');
 321 #else // ANSI
 322                 RICHEDIT_CLASS += _T('A');
 323 #endif // Unicode/ANSI
 324 #endif // !RICHEDIT_CLASS
 325
 326                 windowClass = RICHEDIT_CLASS;
 327             }
 328         }
 329     }
 330 #endif // wxUSE_RICHEDIT
 331
 332     // we need to turn '\n's into "\r\n"s for the multiline controls
 333     wxString valueWin;
 334     if ( m_windowStyle & wxTE_MULTILINE )
 335     {
 336         valueWin = wxTextFile::Translate(value, wxTextFileType_Dos);
 337     }
 338     else // single line
 339     {
 340         valueWin = value;
 341     }
 342
 343     if ( !MSWCreateControl(windowClass, msStyle, pos, size, valueWin) )
 344         return false;
 345
 346 #if wxUSE_RICHEDIT
 347     if ( IsRich() )
 348     {
 349         // enable the events we're interested in: we want to get EN_CHANGE as
 350         // for the normal controls
 351         LPARAM mask = ENM_CHANGE;
 352
 353         if ( GetRichVersion() == 1 )
 354         {
 355             // we also need EN_MSGFILTER for richedit 1.0 for the reasons
 356             // explained in its handler
 357            mask |= ENM_MOUSEEVENTS;
 358         }
 359         else if ( m_windowStyle & wxTE_AUTO_URL )
 360         {
 361             mask |= ENM_LINK;
 362
 363             ::SendMessage(GetHwnd(), EM_AUTOURLDETECT, TRUE, 0);
 364         }
 365
 366         ::SendMessage(GetHwnd(), EM_SETEVENTMASK, 0, mask);
 367     }
 368 #endif // wxUSE_RICHEDIT
 369
 370     return true;
 371 }
 372
 373 // Make sure the window style (etc.) reflects the HWND style (roughly)
 374 void wxTextCtrl::AdoptAttributesFromHWND()
 375 {
 376     wxWindow::AdoptAttributesFromHWND();
 377
 378     HWND hWnd = GetHwnd();
 379     long style = ::GetWindowLong(hWnd, GWL_STYLE);
 380
 381     // retrieve the style to see whether this is an edit or richedit ctrl
 382 #if wxUSE_RICHEDIT
 383     wxString classname = wxGetWindowClass(GetHWND());
 384
 385     if ( classname.IsSameAs(_T("EDIT"), false /* no case */) )
 386     {
 387         m_verRichEdit = 0;
 388     }
 389     else // rich edit?
 390     {
 391         wxChar c;
 392         if ( wxSscanf(classname, _T("RichEdit%d0%c"), &m_verRichEdit, &c) != 2 )
 393         {
 394             wxLogDebug(_T("Unknown edit control '%s'."), classname.c_str());
 395
 396             m_verRichEdit = 0;
 397         }
 398     }
 399 #endif // wxUSE_RICHEDIT
 400
 401     if (style & ES_MULTILINE)
 402         m_windowStyle |= wxTE_MULTILINE;
 403     if (style & ES_PASSWORD)
 404         m_windowStyle |= wxTE_PASSWORD;
 405     if (style & ES_READONLY)
 406         m_windowStyle |= wxTE_READONLY;
 407     if (style & ES_WANTRETURN)
 408         m_windowStyle |= wxTE_PROCESS_ENTER;
 409     if (style & ES_CENTER)
 410         m_windowStyle |= wxTE_CENTRE;
 411     if (style & ES_RIGHT)
 412         m_windowStyle |= wxTE_RIGHT;
 413 }
 414
 415 WXDWORD wxTextCtrl::MSWGetStyle(long style, WXDWORD *exstyle) const
 416 {
 417     long msStyle = wxControl::MSWGetStyle(style, exstyle);
 418
 419     // styles which we alaways add by default
 420     if ( style & wxTE_MULTILINE )
 421     {
 422         wxASSERT_MSG( !(style & wxTE_PROCESS_ENTER),
 423                       wxT("wxTE_PROCESS_ENTER style is ignored for multiline text controls (they always process it)") );
 424
 425         msStyle |= ES_MULTILINE | ES_WANTRETURN;
 426         if ( !(style & wxTE_NO_VSCROLL) )
 427         {
 428             // always adjust the vertical scrollbar automatically if we have it
 429             msStyle |= WS_VSCROLL | ES_AUTOVSCROLL;
 430
 431 #if wxUSE_RICHEDIT
 432             // we have to use this style for the rich edit controls because
 433             // without it the vertical scrollbar never appears at all in
 434             // richedit 3.0 because of our ECO_NOHIDESEL hack (search for it)
 435             if ( style & wxTE_RICH2 )
 436             {
 437                 msStyle |= ES_DISABLENOSCROLL;
 438             }
 439 #endif // wxUSE_RICHEDIT
 440         }
 441
 442         style |= wxTE_PROCESS_ENTER;
 443     }
 444     else // !multiline
 445     {
 446         // there is really no reason to not have this style for single line
 447         // text controls
 448         msStyle |= ES_AUTOHSCROLL;
 449     }
 450
 451     // note that wxTE_DONTWRAP is the same as wxHSCROLL so if we have a horz
 452     // scrollbar, there is no wrapping -- which makes sense
 453     if ( style & wxTE_DONTWRAP )
 454     {
 455         // automatically scroll the control horizontally as necessary
 456         //
 457         // NB: ES_AUTOHSCROLL is needed for richedit controls or they don't
 458         //     show horz scrollbar at all, even in spite of WS_HSCROLL, and as
 459         //     it doesn't seem to do any harm for plain edit controls, add it
 460         //     always
 461         msStyle |= WS_HSCROLL | ES_AUTOHSCROLL;
 462     }
 463
 464     if ( style & wxTE_READONLY )
 465         msStyle |= ES_READONLY;
 466
 467     if ( style & wxTE_PASSWORD )
 468         msStyle |= ES_PASSWORD;
 469
 470     if ( style & wxTE_NOHIDESEL )
 471         msStyle |= ES_NOHIDESEL;
 472
 473     // note that we can't do do "& wxTE_LEFT" as wxTE_LEFT == 0
 474     if ( style & wxTE_CENTRE )
 475         msStyle |= ES_CENTER;
 476     else if ( style & wxTE_RIGHT )
 477         msStyle |= ES_RIGHT;
 478     else
 479         msStyle |= ES_LEFT; // ES_LEFT is 0 as well but for consistency...
 480
 481     return msStyle;
 482 }
 483
 484 void wxTextCtrl::SetWindowStyleFlag(long style)
 485 {
 486 #if wxUSE_RICHEDIT
 487     // we have to deal with some styles separately because they can't be
 488     // changed by simply calling SetWindowLong(GWL_STYLE) but can be changed
 489     // using richedit-specific EM_SETOPTIONS
 490     if ( IsRich() &&
 491             ((style & wxTE_NOHIDESEL) != (GetWindowStyle() & wxTE_NOHIDESEL)) )
 492     {
 493         bool set = (style & wxTE_NOHIDESEL) != 0;
 494
 495         ::SendMessage(GetHwnd(), EM_SETOPTIONS, set ? ECOOP_OR : ECOOP_AND,
 496                       set ? ECO_NOHIDESEL : ~ECO_NOHIDESEL);
 497     }
 498 #endif // wxUSE_RICHEDIT
 499
 500     wxControl::SetWindowStyleFlag(style);
 501 }
 502
 503 // ----------------------------------------------------------------------------
 504 // set/get the controls text
 505 // ----------------------------------------------------------------------------
 506
 507 wxString wxTextCtrl::GetValue() const
 508 {
 509     // range 0..-1 is special for GetRange() and means to retrieve all text
 510     return GetRange(0, -1);
 511 }
 512
 513 wxString wxTextCtrl::GetRange(long from, long to) const
 514 {
 515     wxString str;
 516
 517     if ( from >= to && to != -1 )
 518     {
 519         // nothing to retrieve
 520         return str;
 521     }
 522
 523 #if wxUSE_RICHEDIT
 524     if ( IsRich() )
 525     {
 526         int len = GetWindowTextLength(GetHwnd());
 527         if ( len > from )
 528         {
 529             if ( to == -1 )
 530                 to = len;
 531
 532 #if !wxUSE_UNICODE
 533             // we must use EM_STREAMOUT if we don't want to lose all characters
 534             // not representable in the current character set (EM_GETTEXTRANGE
 535             // simply replaces them with question marks...)
 536             if ( GetRichVersion() > 1 )
 537             {
 538                 // we must have some encoding, otherwise any 8bit chars in the
 539                 // control are simply *lost* (replaced by '?')
 540                 wxFontEncoding encoding = wxFONTENCODING_SYSTEM;
 541
 542                 wxFont font = m_defaultStyle.GetFont();
 543                 if ( !font.Ok() )
 544                     font = GetFont();
 545
 546                 if ( font.Ok() )
 547                 {
 548                    encoding = font.GetEncoding();
 549                 }
 550
 551                 if ( encoding == wxFONTENCODING_SYSTEM )
 552                 {
 553                     encoding = wxLocale::GetSystemEncoding();
 554                 }
 555
 556                 if ( encoding == wxFONTENCODING_SYSTEM )
 557                 {
 558                     encoding = wxFONTENCODING_ISO8859_1;
 559                 }
 560
 561                 str = StreamOut(encoding);
 562
 563                 if ( !str.empty() )
 564                 {
 565                     // we have to manually extract the required part, luckily
 566                     // this is easy in this case as EOL characters in str are
 567                     // just LFs because we remove CRs in wxRichEditStreamOut
 568                     str = str.Mid(from, to - from);
 569                 }
 570             }
 571
 572             // StreamOut() wasn't used or failed, try to do it in normal way
 573             if ( str.empty() )
 574 #endif // !wxUSE_UNICODE
 575             {
 576                 // alloc one extra WORD as needed by the control
 577                 wxStringBuffer tmp(str, ++len);
 578                 wxChar *p = tmp;
 579
 580                 TEXTRANGE textRange;
 581                 textRange.chrg.cpMin = from;
 582                 textRange.chrg.cpMax = to;
 583                 textRange.lpstrText = p;
 584
 585                 (void)::SendMessage(GetHwnd(), EM_GETTEXTRANGE,
 586                                     0, (LPARAM)&textRange);
 587
 588                 if ( m_verRichEdit > 1 )
 589                 {
 590                     // RichEdit 2.0 uses just CR ('\r') for the
 591                     // newlines which is neither Unix nor Windows
 592                     // style - convert it to something reasonable
 593                     for ( ; *p; p++ )
 594                     {
 595                         if ( *p == _T('\r') )
 596                             *p = _T('\n');
 597                     }
 598                 }
 599             }
 600
 601             if ( m_verRichEdit == 1 )
 602             {
 603                 // convert to the canonical form - see comment below
 604                 str = wxTextFile::Translate(str, wxTextFileType_Unix);
 605             }
 606         }
 607         //else: no text at all, leave the string empty
 608     }
 609     else
 610 #endif // wxUSE_RICHEDIT
 611     {
 612         // retrieve all text
 613         str = wxGetWindowText(GetHWND());
 614
 615         // need only a range?
 616         if ( from < to )
 617         {
 618             str = str.Mid(from, to - from);
 619         }
 620
 621         // WM_GETTEXT uses standard DOS CR+LF (\r\n) convention - convert to the
 622         // canonical one (same one as above) for consistency with the other kinds
 623         // of controls and, more importantly, with the other ports
 624         str = wxTextFile::Translate(str, wxTextFileType_Unix);
 625     }
 626
 627     return str;
 628 }
 629
 630 void wxTextCtrl::SetValue(const wxString& value)
 631 {
 632     // if the text is long enough, it's faster to just set it instead of first
 633     // comparing it with the old one (chances are that it will be different
 634     // anyhow, this comparison is there to avoid flicker for small single-line
 635     // edit controls mostly)
 636     if ( (value.length() > 0x400) || (value != GetValue()) )
 637     {
 638         DoWriteText(value, false /* not selection only */);
 639
 640         // for compatibility, don't move the cursor when doing SetValue()
 641         SetInsertionPoint(0);
 642     }
 643     else // same text
 644     {
 645         // still send an event for consistency
 646         SendUpdateEvent();
 647     }
 648
 649     // we should reset the modified flag even if the value didn't really change
 650
 651     // mark the control as being not dirty - we changed its text, not the
 652     // user
 653     DiscardEdits();
 654 }
 655
 656 #if wxUSE_RICHEDIT && (!wxUSE_UNICODE || wxUSE_UNICODE_MSLU)
 657
 658 // TODO: using memcpy() would improve performance a lot for big amounts of text
 659
 660 DWORD CALLBACK
 661 wxRichEditStreamIn(DWORD dwCookie, BYTE *buf, LONG cb, LONG *pcb)
 662 {
 663     *pcb = 0;
 664
 665     const wchar_t ** const ppws = (const wchar_t **)dwCookie;
 666
 667     wchar_t *wbuf = (wchar_t *)buf;
 668     const wchar_t *wpc = *ppws;
 669     while ( cb && *wpc )
 670     {
 671         *wbuf++ = *wpc++;
 672
 673         cb -= sizeof(wchar_t);
 674         (*pcb) += sizeof(wchar_t);
 675     }
 676
 677     *ppws = wpc;
 678
 679     return 0;
 680 }
 681
 682 // helper struct used to pass parameters from wxTextCtrl to wxRichEditStreamOut
 683 struct wxStreamOutData
 684 {
 685     wchar_t *wpc;
 686     size_t len;
 687 };
 688
 689 DWORD CALLBACK
 690 wxRichEditStreamOut(DWORD_PTR dwCookie, BYTE *buf, LONG cb, LONG *pcb)
 691 {
 692     *pcb = 0;
 693
 694     wxStreamOutData *data = (wxStreamOutData *)dwCookie;
 695
 696     const wchar_t *wbuf = (const wchar_t *)buf;
 697     wchar_t *wpc = data->wpc;
 698     while ( cb )
 699     {
 700         wchar_t wch = *wbuf++;
 701
 702         // turn "\r\n" into "\n" on the fly
 703         if ( wch != L'\r' )
 704             *wpc++ = wch;
 705         else
 706             data->len--;
 707
 708         cb -= sizeof(wchar_t);
 709         (*pcb) += sizeof(wchar_t);
 710     }
 711
 712     data->wpc = wpc;
 713
 714     return 0;
 715 }
 716
 717
 718 #if wxUSE_UNICODE_MSLU
 719     #define UNUSED_IF_MSLU(param)
 720 #else
 721     #define UNUSED_IF_MSLU(param) param
 722 #endif
 723
 724 bool
 725 wxTextCtrl::StreamIn(const wxString& value,
 726                      wxFontEncoding UNUSED_IF_MSLU(encoding),
 727                      bool selectionOnly)
 728 {
 729 #if wxUSE_UNICODE_MSLU
 730     const wchar_t *wpc = value.c_str();
 731 #else // !wxUSE_UNICODE_MSLU
 732     wxCSConv conv(encoding);
 733
 734     const size_t len = conv.MB2WC(NULL, value, value.length());
 735
 736 #if wxUSE_WCHAR_T
 737     wxWCharBuffer wchBuf(len);
 738     wchar_t *wpc = wchBuf.data();
 739 #else
 740     wchar_t *wchBuf = (wchar_t *)malloc((len + 1)*sizeof(wchar_t));
 741     wchar_t *wpc = wchBuf;
 742 #endif
 743
 744     conv.MB2WC(wpc, value, value.length());
 745 #endif // wxUSE_UNICODE_MSLU
 746
 747     // finally, stream it in the control
 748     EDITSTREAM eds;
 749     wxZeroMemory(eds);
 750     eds.dwCookie = (DWORD)&wpc;
 751     // the cast below is needed for broken (very) old mingw32 headers
 752     eds.pfnCallback = (EDITSTREAMCALLBACK)wxRichEditStreamIn;
 753
 754     // we're going to receive 2 EN_CHANGE notifications if we got any selection
 755     // (same problem as in DoWriteText())
 756     if ( selectionOnly && HasSelection() )
 757     {
 758         // so suppress one of them
 759         m_suppressNextUpdate = true;
 760     }
 761
 762     ::SendMessage(GetHwnd(), EM_STREAMIN,
 763                   SF_TEXT |
 764                   SF_UNICODE |
 765                   (selectionOnly ? SFF_SELECTION : 0),
 766                   (LPARAM)&eds);
 767
 768     if ( eds.dwError )
 769     {
 770         wxLogLastError(_T("EM_STREAMIN"));
 771     }
 772
 773 #if !wxUSE_WCHAR_T
 774     free(wchBuf);
 775 #endif // !wxUSE_WCHAR_T
 776
 777     return true;
 778 }
 779
 780 #if !wxUSE_UNICODE_MSLU
 781
 782 wxString
 783 wxTextCtrl::StreamOut(wxFontEncoding encoding, bool selectionOnly) const
 784 {
 785     wxString out;
 786
 787     const int len = GetWindowTextLength(GetHwnd());
 788
 789 #if wxUSE_WCHAR_T
 790     wxWCharBuffer wchBuf(len);
 791     wchar_t *wpc = wchBuf.data();
 792 #else
 793     wchar_t *wchBuf = (wchar_t *)malloc((len + 1)*sizeof(wchar_t));
 794     wchar_t *wpc = wchBuf;
 795 #endif
 796
 797     wxStreamOutData data;
 798     data.wpc = wpc;
 799     data.len = len;
 800
 801     EDITSTREAM eds;
 802     wxZeroMemory(eds);
 803     eds.dwCookie = (DWORD)&data;
 804     eds.pfnCallback = wxRichEditStreamOut;
 805
 806     ::SendMessage
 807       (
 808         GetHwnd(),
 809         EM_STREAMOUT,
 810         SF_TEXT | SF_UNICODE | (selectionOnly ? SFF_SELECTION : 0),
 811         (LPARAM)&eds
 812       );
 813
 814     if ( eds.dwError )
 815     {
 816         wxLogLastError(_T("EM_STREAMOUT"));
 817     }
 818     else // streamed out ok
 819     {
 820         // NUL-terminate the string because its length could have been
 821         // decreased by wxRichEditStreamOut
 822         *(wchBuf.data() + data.len) = L'\0';
 823
 824         // now convert to the given encoding (this is a possibly lossful
 825         // conversion but what else can we do)
 826         wxCSConv conv(encoding);
 827         size_t lenNeeded = conv.WC2MB(NULL, wchBuf, 0);
 828         if ( lenNeeded++ )
 829         {
 830             conv.WC2MB(wxStringBuffer(out, lenNeeded), wchBuf, lenNeeded);
 831         }
 832     }
 833
 834 #if !wxUSE_WCHAR_T
 835     free(wchBuf);
 836 #endif // !wxUSE_WCHAR_T
 837
 838     return out;
 839 }
 840
 841 #endif // !wxUSE_UNICODE_MSLU
 842
 843 #endif // wxUSE_RICHEDIT
 844
 845 void wxTextCtrl::WriteText(const wxString& value)
 846 {
 847     DoWriteText(value);
 848 }
 849
 850 void wxTextCtrl::DoWriteText(const wxString& value, bool selectionOnly)
 851 {
 852     wxString valueDos;
 853     if ( m_windowStyle & wxTE_MULTILINE )
 854         valueDos = wxTextFile::Translate(value, wxTextFileType_Dos);
 855     else
 856         valueDos = value;
 857
 858 #if wxUSE_RICHEDIT
 859     // there are several complications with the rich edit controls here
 860     bool done = false;
 861     if ( IsRich() )
 862     {
 863         // first, ensure that the new text will be in the default style
 864         if ( !m_defaultStyle.IsDefault() )
 865         {
 866             long start, end;
 867             GetSelection(&start, &end);
 868             SetStyle(start, end, m_defaultStyle);
 869         }
 870
 871 #if wxUSE_UNICODE_MSLU
 872         // RichEdit doesn't have Unicode version of EM_REPLACESEL on Win9x,
 873         // but EM_STREAMIN works
 874         if ( wxUsingUnicowsDll() && GetRichVersion() > 1 )
 875         {
 876            done = StreamIn(valueDos, wxFONTENCODING_SYSTEM, selectionOnly);
 877         }
 878 #endif // wxUSE_UNICODE_MSLU
 879
 880 #if !wxUSE_UNICODE
 881         // next check if the text we're inserting must be shown in a non
 882         // default charset -- this only works for RichEdit > 1.0
 883         if ( GetRichVersion() > 1 )
 884         {
 885             wxFont font = m_defaultStyle.GetFont();
 886             if ( !font.Ok() )
 887                 font = GetFont();
 888
 889             if ( font.Ok() )
 890             {
 891                wxFontEncoding encoding = font.GetEncoding();
 892                if ( encoding != wxFONTENCODING_SYSTEM )
 893                {
 894                    // we have to use EM_STREAMIN to force richedit control 2.0+
 895                    // to show any text in the non default charset -- otherwise
 896                    // it thinks it knows better than we do and always shows it
 897                    // in the default one
 898                    done = StreamIn(valueDos, encoding, selectionOnly);
 899                }
 900             }
 901         }
 902 #endif // !wxUSE_UNICODE
 903     }
 904
 905     if ( !done )
 906 #endif // wxUSE_RICHEDIT
 907     {
 908         // in some cases we get 2 EN_CHANGE notifications after the SendMessage
 909         // call below which is confusing for the client code and so should be
 910         // avoided
 911         //
 912         // these cases are: (a) plain EDIT controls if EM_REPLACESEL is used
 913         // and there is a non empty selection currently and (b) rich text
 914         // controls in any case
 915         if (
 916 #if wxUSE_RICHEDIT
 917             IsRich() ||
 918 #endif // wxUSE_RICHEDIT
 919             (selectionOnly && HasSelection()) )
 920         {
 921             m_suppressNextUpdate = true;
 922         }
 923
 924         ::SendMessage(GetHwnd(), selectionOnly ? EM_REPLACESEL : WM_SETTEXT,
 925                       0, (LPARAM)valueDos.c_str());
 926
 927         // OTOH, non rich text controls don't generate any events at all when
 928         // we use WM_SETTEXT -- have to emulate them here
 929         if ( !selectionOnly
 930 #if wxUSE_RICHEDIT
 931                 && !IsRich()
 932 #endif // wxUSE_RICHEDIT
 933            )
 934         {
 935             // Windows already sends an update event for single-line
 936             // controls.
 937             if ( m_windowStyle & wxTE_MULTILINE )
 938                 SendUpdateEvent();
 939         }
 940     }
 941 }
 942
 943 void wxTextCtrl::AppendText(const wxString& text)
 944 {
 945     SetInsertionPointEnd();
 946
 947     WriteText(text);
 948
 949 #if wxUSE_RICHEDIT
 950     // don't do this if we're frozen, saves some time
 951     if ( !IsFrozen() && IsMultiLine() && GetRichVersion() > 1 )
 952     {
 953         // setting the caret to the end and showing it simply doesn't work for
 954         // RichEdit 2.0 -- force it to still do what we want
 955         ::SendMessage(GetHwnd(), EM_LINESCROLL, 0, GetNumberOfLines());
 956     }
 957 #endif // wxUSE_RICHEDIT
 958 }
 959
 960 void wxTextCtrl::Clear()
 961 {
 962     ::SetWindowText(GetHwnd(), wxEmptyString);
 963
 964 #if wxUSE_RICHEDIT
 965     if ( !IsRich() )
 966 #endif // wxUSE_RICHEDIT
 967     {
 968         // rich edit controls send EN_UPDATE from WM_SETTEXT handler themselves
 969         // but the normal ones don't -- make Clear() behaviour consistent by
 970         // always sending this event
 971
 972         // Windows already sends an update event for single-line
 973         // controls.
 974         if ( m_windowStyle & wxTE_MULTILINE )
 975             SendUpdateEvent();
 976     }
 977 }
 978
 979 #ifdef __WIN32__
 980
 981 bool wxTextCtrl::EmulateKeyPress(const wxKeyEvent& event)
 982 {
 983     SetFocus();
 984
 985     size_t lenOld = GetValue().length();
 986
 987     wxUint32 code = event.GetRawKeyCode();
 988     ::keybd_event((BYTE)code, 0, 0 /* key press */, 0);
 989     ::keybd_event((BYTE)code, 0, KEYEVENTF_KEYUP, 0);
 990
 991     // assume that any alphanumeric key changes the total number of characters
 992     // in the control - this should work in 99% of cases
 993     return GetValue().length() != lenOld;
 994 }
 995
 996 #endif // __WIN32__
 997
 998 // ----------------------------------------------------------------------------
 999 // Clipboard operations
1000 // ----------------------------------------------------------------------------
1001
1002 void wxTextCtrl::Copy()
1003 {
1004     if (CanCopy())
1005     {
1006         ::SendMessage(GetHwnd(), WM_COPY, 0, 0L);
1007     }
1008 }
1009
1010 void wxTextCtrl::Cut()
1011 {
1012     if (CanCut())
1013     {
1014         ::SendMessage(GetHwnd(), WM_CUT, 0, 0L);
1015     }
1016 }
1017
1018 void wxTextCtrl::Paste()
1019 {
1020     if (CanPaste())
1021     {
1022         ::SendMessage(GetHwnd(), WM_PASTE, 0, 0L);
1023     }
1024 }
1025
1026 bool wxTextCtrl::HasSelection() const
1027 {
1028     long from, to;
1029     GetSelection(&from, &to);
1030     return from != to;
1031 }
1032
1033 bool wxTextCtrl::CanCopy() const
1034 {
1035     // Can copy if there's a selection
1036     return HasSelection();
1037 }
1038
1039 bool wxTextCtrl::CanCut() const
1040 {
1041     return CanCopy() && IsEditable();
1042 }
1043
1044 bool wxTextCtrl::CanPaste() const
1045 {
1046     if ( !IsEditable() )
1047         return false;
1048
1049 #if wxUSE_RICHEDIT
1050     if ( IsRich() )
1051     {
1052         UINT cf = 0; // 0 == any format
1053
1054         return ::SendMessage(GetHwnd(), EM_CANPASTE, cf, 0) != 0;
1055     }
1056 #endif // wxUSE_RICHEDIT
1057
1058     // Standard edit control: check for straight text on clipboard
1059     if ( !::OpenClipboard(GetHwndOf(wxTheApp->GetTopWindow())) )
1060         return false;
1061
1062     bool isTextAvailable = ::IsClipboardFormatAvailable(CF_TEXT) != 0;
1063     ::CloseClipboard();
1064
1065     return isTextAvailable;
1066 }
1067
1068 // ----------------------------------------------------------------------------
1069 // Accessors
1070 // ----------------------------------------------------------------------------
1071
1072 void wxTextCtrl::SetEditable(bool editable)
1073 {
1074     HWND hWnd = GetHwnd();
1075     ::SendMessage(hWnd, EM_SETREADONLY, (WPARAM)!editable, (LPARAM)0L);
1076 }
1077
1078 void wxTextCtrl::SetInsertionPoint(long pos)
1079 {
1080     DoSetSelection(pos, pos);
1081
1082     m_isCaretAtEnd = pos == GetLastPosition();
1083 }
1084
1085 void wxTextCtrl::SetInsertionPointEnd()
1086 {
1087     // we must not do anything if the caret is already there because calling
1088     // SetInsertionPoint() thaws the controls if Freeze() had been called even
1089     // if it doesn't actually move the caret anywhere and so the simple fact of
1090     // doing it results in horrible flicker when appending big amounts of text
1091     // to the control in a few chunks (see DoAddText() test in the text sample)
1092     if ( m_isCaretAtEnd || GetInsertionPoint() == GetLastPosition() )
1093     {
1094         m_isCaretAtEnd = true;
1095         return;
1096     }
1097
1098     long pos;
1099
1100 #if wxUSE_RICHEDIT
1101     if ( m_verRichEdit == 1 )
1102     {
1103         // we don't have to waste time calling GetLastPosition() in this case
1104         pos = -1;
1105     }
1106     else // !RichEdit 1.0
1107 #endif // wxUSE_RICHEDIT
1108     {
1109         pos = GetLastPosition();
1110     }
1111
1112     SetInsertionPoint(pos);
1113 }
1114
1115 long wxTextCtrl::GetInsertionPoint() const
1116 {
1117 #if wxUSE_RICHEDIT
1118     if ( IsRich() )
1119     {
1120         CHARRANGE range;
1121         range.cpMin = 0;
1122         range.cpMax = 0;
1123         ::SendMessage(GetHwnd(), EM_EXGETSEL, 0, (LPARAM) &range);
1124         return range.cpMin;
1125     }
1126 #endif // wxUSE_RICHEDIT
1127
1128     DWORD Pos = (DWORD)::SendMessage(GetHwnd(), EM_GETSEL, 0, 0L);
1129     return Pos & 0xFFFF;
1130 }
1131
1132 long wxTextCtrl::GetLastPosition() const
1133 {
1134     int numLines = GetNumberOfLines();
1135     long posStartLastLine = XYToPosition(0, numLines - 1);
1136
1137     long lenLastLine = GetLengthOfLineContainingPos(posStartLastLine);
1138
1139     return posStartLastLine + lenLastLine;
1140 }
1141
1142 // If the return values from and to are the same, there is no
1143 // selection.
1144 void wxTextCtrl::GetSelection(long* from, long* to) const
1145 {
1146 #if wxUSE_RICHEDIT
1147     if ( IsRich() )
1148     {
1149         CHARRANGE charRange;
1150         ::SendMessage(GetHwnd(), EM_EXGETSEL, 0, (LPARAM) &charRange);
1151
1152         *from = charRange.cpMin;
1153         *to = charRange.cpMax;
1154     }
1155     else
1156 #endif // !wxUSE_RICHEDIT
1157     {
1158         DWORD dwStart, dwEnd;
1159         ::SendMessage(GetHwnd(), EM_GETSEL, (WPARAM)&dwStart, (LPARAM)&dwEnd);
1160
1161         *from = dwStart;
1162         *to = dwEnd;
1163     }
1164 }
1165
1166 bool wxTextCtrl::IsEditable() const
1167 {
1168     // strangely enough, we may be called before the control is created: our
1169     // own Create() calls MSWGetStyle() which calls AcceptsFocus() which calls
1170     // us
1171     if ( !m_hWnd )
1172         return true;
1173
1174     long style = ::GetWindowLong(GetHwnd(), GWL_STYLE);
1175
1176     return (style & ES_READONLY) == 0;
1177 }
1178
1179 // ----------------------------------------------------------------------------
1180 // selection
1181 // ----------------------------------------------------------------------------
1182
1183 void wxTextCtrl::SetSelection(long from, long to)
1184 {
1185     // if from and to are both -1, it means (in wxWidgets) that all text should
1186     // be selected - translate into Windows convention
1187     if ( (from == -1) && (to == -1) )
1188     {
1189         from = 0;
1190         to = -1;
1191     }
1192
1193     DoSetSelection(from, to);
1194 }
1195
1196 void wxTextCtrl::DoSetSelection(long from, long to, bool scrollCaret)
1197 {
1198     HWND hWnd = GetHwnd();
1199
1200 #if wxUSE_RICHEDIT
1201     if ( IsRich() )
1202     {
1203         CHARRANGE range;
1204         range.cpMin = from;
1205         range.cpMax = to;
1206         ::SendMessage(hWnd, EM_EXSETSEL, 0, (LPARAM) &range);
1207     }
1208     else
1209 #endif // wxUSE_RICHEDIT
1210     {
1211         ::SendMessage(hWnd, EM_SETSEL, (WPARAM)from, (LPARAM)to);
1212     }
1213
1214     if ( scrollCaret && !IsFrozen() )
1215     {
1216 #if wxUSE_RICHEDIT
1217         // richedit 3.0 (i.e. the version living in riched20.dll distributed
1218         // with Windows 2000 and beyond) doesn't honour EM_SCROLLCARET when
1219         // emulating richedit 2.0 unless the control has focus or ECO_NOHIDESEL
1220         // option is set (but it does work ok in richedit 1.0 mode...)
1221         //
1222         // so to make it work we either need to give focus to it here which
1223         // will probably create many problems (dummy focus events; window
1224         // containing the text control being brought to foreground
1225         // unexpectedly; ...) or to temporarily set ECO_NOHIDESEL which may
1226         // create other problems too -- and in fact it does because if we turn
1227         // on/off this style while appending the text to the control, the
1228         // vertical scrollbar never appears in it even if we append tons of
1229         // text and to work around this the only solution I found was to use
1230         // ES_DISABLENOSCROLL
1231         //
1232         // this is very ugly but I don't see any other way to make this work
1233         if ( GetRichVersion() > 1 )
1234         {
1235             if ( !HasFlag(wxTE_NOHIDESEL) )
1236             {
1237                 ::SendMessage(GetHwnd(), EM_SETOPTIONS,
1238                               ECOOP_OR, ECO_NOHIDESEL);
1239             }
1240             //else: everything is already ok
1241         }
1242 #endif // wxUSE_RICHEDIT
1243
1244         ::SendMessage(hWnd, EM_SCROLLCARET, (WPARAM)0, (LPARAM)0);
1245
1246 #if wxUSE_RICHEDIT
1247         // restore ECO_NOHIDESEL if we changed it
1248         if ( GetRichVersion() > 1 && !HasFlag(wxTE_NOHIDESEL) )
1249         {
1250             ::SendMessage(GetHwnd(), EM_SETOPTIONS,
1251                           ECOOP_AND, ~ECO_NOHIDESEL);
1252         }
1253 #endif // wxUSE_RICHEDIT
1254     }
1255 }
1256
1257 // ----------------------------------------------------------------------------
1258 // Working with files
1259 // ----------------------------------------------------------------------------
1260
1261 bool wxTextCtrl::LoadFile(const wxString& file)
1262 {
1263     if ( wxTextCtrlBase::LoadFile(file) )
1264     {
1265         // update the size limit if needed
1266         AdjustSpaceLimit();
1267
1268         return true;
1269     }
1270
1271     return false;
1272 }
1273
1274 // ----------------------------------------------------------------------------
1275 // Editing
1276 // ----------------------------------------------------------------------------
1277
1278 void wxTextCtrl::Replace(long from, long to, const wxString& value)
1279 {
1280     // Set selection and remove it
1281     DoSetSelection(from, to, false /* don't scroll caret into view */);
1282
1283     DoWriteText(value, true /* selection only */);
1284 }
1285
1286 void wxTextCtrl::Remove(long from, long to)
1287 {
1288     Replace(from, to, wxEmptyString);
1289 }
1290
1291 bool wxTextCtrl::IsModified() const
1292 {
1293     return ::SendMessage(GetHwnd(), EM_GETMODIFY, 0, 0) != 0;
1294 }
1295
1296 void wxTextCtrl::MarkDirty()
1297 {
1298     ::SendMessage(GetHwnd(), EM_SETMODIFY, TRUE, 0L);
1299 }
1300
1301 void wxTextCtrl::DiscardEdits()
1302 {
1303     ::SendMessage(GetHwnd(), EM_SETMODIFY, FALSE, 0L);
1304 }
1305
1306 int wxTextCtrl::GetNumberOfLines() const
1307 {
1308     return (int)::SendMessage(GetHwnd(), EM_GETLINECOUNT, (WPARAM)0, (LPARAM)0);
1309 }
1310
1311 // ----------------------------------------------------------------------------
1312 // Positions <-> coords
1313 // ----------------------------------------------------------------------------
1314
1315 long wxTextCtrl::XYToPosition(long x, long y) const
1316 {
1317     // This gets the char index for the _beginning_ of this line
1318     long charIndex = ::SendMessage(GetHwnd(), EM_LINEINDEX, (WPARAM)y, (LPARAM)0);
1319
1320     return charIndex + x;
1321 }
1322
1323 bool wxTextCtrl::PositionToXY(long pos, long *x, long *y) const
1324 {
1325     HWND hWnd = GetHwnd();
1326
1327     // This gets the line number containing the character
1328     long lineNo;
1329 #if wxUSE_RICHEDIT
1330     if ( IsRich() )
1331     {
1332         lineNo = ::SendMessage(hWnd, EM_EXLINEFROMCHAR, 0, (LPARAM)pos);
1333     }
1334     else
1335 #endif // wxUSE_RICHEDIT
1336     {
1337         lineNo = ::SendMessage(hWnd, EM_LINEFROMCHAR, (WPARAM)pos, 0);
1338     }
1339
1340     if ( lineNo == -1 )
1341     {
1342         // no such line
1343         return false;
1344     }
1345
1346     // This gets the char index for the _beginning_ of this line
1347     long charIndex = ::SendMessage(hWnd, EM_LINEINDEX, (WPARAM)lineNo, (LPARAM)0);
1348     if ( charIndex == -1 )
1349     {
1350         return false;
1351     }
1352
1353     // The X position must therefore be the different between pos and charIndex
1354     if ( x )
1355         *x = pos - charIndex;
1356     if ( y )
1357         *y = lineNo;
1358
1359     return true;
1360 }
1361
1362 wxTextCtrlHitTestResult
1363 wxTextCtrl::HitTest(const wxPoint& pt, long *posOut) const
1364 {
1365     // first get the position from Windows
1366     LPARAM lParam;
1367
1368 #if wxUSE_RICHEDIT
1369     POINTL ptl;
1370     if ( IsRich() )
1371     {
1372         // for rich edit controls the position is passed iva the struct fields
1373         ptl.x = pt.x;
1374         ptl.y = pt.y;
1375         lParam = (LPARAM)&ptl;
1376     }
1377     else
1378 #endif // wxUSE_RICHEDIT
1379     {
1380         // for the plain ones, we are limited to 16 bit positions which are
1381         // combined in a single 32 bit value
1382         lParam = MAKELPARAM(pt.x, pt.y);
1383     }
1384
1385     LRESULT pos = ::SendMessage(GetHwnd(), EM_CHARFROMPOS, 0, lParam);
1386
1387     if ( pos == -1 )
1388     {
1389         // this seems to indicate an error...
1390         return wxTE_HT_UNKNOWN;
1391     }
1392
1393 #if wxUSE_RICHEDIT
1394     if ( !IsRich() )
1395 #endif // wxUSE_RICHEDIT
1396     {
1397         // for plain EDIT controls the higher word contains something else
1398         pos = LOWORD(pos);
1399     }
1400
1401
1402     // next determine where it is relatively to our point: EM_CHARFROMPOS
1403     // always returns the closest character but we need to be more precise, so
1404     // double check that we really are where it pretends
1405     POINTL ptReal;
1406
1407 #if wxUSE_RICHEDIT
1408     // FIXME: we need to distinguish between richedit 2 and 3 here somehow but
1409     //        we don't know how to do it
1410     if ( IsRich() )
1411     {
1412         ::SendMessage(GetHwnd(), EM_POSFROMCHAR, (WPARAM)&ptReal, pos);
1413     }
1414     else
1415 #endif // wxUSE_RICHEDIT
1416     {
1417         LRESULT lRc = ::SendMessage(GetHwnd(), EM_POSFROMCHAR, pos, 0);
1418
1419         if ( lRc == -1 )
1420         {
1421             // this is apparently returned when pos corresponds to the last
1422             // position
1423             ptReal.x =
1424             ptReal.y = 0;
1425         }
1426         else
1427         {
1428             ptReal.x = LOWORD(lRc);
1429             ptReal.y = HIWORD(lRc);
1430         }
1431     }
1432
1433     wxTextCtrlHitTestResult rc;
1434
1435     if ( pt.y > ptReal.y + GetCharHeight() )
1436         rc = wxTE_HT_BELOW;
1437     else if ( pt.x > ptReal.x + GetCharWidth() )
1438         rc = wxTE_HT_BEYOND;
1439     else
1440         rc = wxTE_HT_ON_TEXT;
1441
1442     if ( posOut )
1443         *posOut = pos;
1444
1445     return rc;
1446 }
1447
1448 // ----------------------------------------------------------------------------
1449 //
1450 // ----------------------------------------------------------------------------
1451
1452 void wxTextCtrl::ShowPosition(long pos)
1453 {
1454     HWND hWnd = GetHwnd();
1455
1456     // To scroll to a position, we pass the number of lines and characters
1457     // to scroll *by*. This means that we need to:
1458     // (1) Find the line position of the current line.
1459     // (2) Find the line position of pos.
1460     // (3) Scroll by (pos - current).
1461     // For now, ignore the horizontal scrolling.
1462
1463     // Is this where scrolling is relative to - the line containing the caret?
1464     // Or is the first visible line??? Try first visible line.
1465 //    int currentLineLineNo1 = (int)::SendMessage(hWnd, EM_LINEFROMCHAR, (WPARAM)-1, (LPARAM)0L);
1466
1467     int currentLineLineNo = (int)::SendMessage(hWnd, EM_GETFIRSTVISIBLELINE, (WPARAM)0, (LPARAM)0L);
1468
1469     int specifiedLineLineNo = (int)::SendMessage(hWnd, EM_LINEFROMCHAR, (WPARAM)pos, (LPARAM)0L);
1470
1471     int linesToScroll = specifiedLineLineNo - currentLineLineNo;
1472
1473     if (linesToScroll != 0)
1474       (void)::SendMessage(hWnd, EM_LINESCROLL, (WPARAM)0, (LPARAM)linesToScroll);
1475
1476     // be pessimistic
1477     m_isCaretAtEnd = false;
1478 }
1479
1480 long wxTextCtrl::GetLengthOfLineContainingPos(long pos) const
1481 {
1482     return ::SendMessage(GetHwnd(), EM_LINELENGTH, (WPARAM)pos, 0);
1483 }
1484
1485 int wxTextCtrl::GetLineLength(long lineNo) const
1486 {
1487     long pos = XYToPosition(0, lineNo);
1488
1489     return GetLengthOfLineContainingPos(pos);
1490 }
1491
1492 wxString wxTextCtrl::GetLineText(long lineNo) const
1493 {
1494     size_t len = (size_t)GetLineLength(lineNo) + 1;
1495
1496     // there must be at least enough place for the length WORD in the
1497     // buffer
1498     len += sizeof(WORD);
1499
1500     wxString str;
1501     {
1502         wxStringBufferLength tmp(str, len);
1503         wxChar *buf = tmp;
1504
1505         *(WORD *)buf = (WORD)len;
1506         len = (size_t)::SendMessage(GetHwnd(), EM_GETLINE, lineNo, (LPARAM)buf);
1507
1508 #if wxUSE_RICHEDIT
1509         if ( IsRich() )
1510         {
1511             // remove the '\r' returned by the rich edit control, the user code
1512             // should never see it
1513             if ( buf[len - 2] == _T('\r') && buf[len - 1] == _T('\n') )
1514             {
1515                 buf[len - 2] = _T('\n');
1516                 len--;
1517             }
1518         }
1519 #endif // wxUSE_RICHEDIT
1520
1521         // remove the '\n' at the end, if any (this is how this function is
1522         // supposed to work according to the docs)
1523         if ( buf[len - 1] == _T('\n') )
1524         {
1525             len--;
1526         }
1527
1528         buf[len] = 0;
1529         tmp.SetLength(len);
1530     }
1531
1532     return str;
1533 }
1534
1535 void wxTextCtrl::SetMaxLength(unsigned long len)
1536 {
1537 #if wxUSE_RICHEDIT
1538     if (IsRich())
1539         ::SendMessage(GetHwnd(), EM_EXLIMITTEXT, 0, (LPARAM) (DWORD) len);
1540     else
1541 #endif
1542     ::SendMessage(GetHwnd(), EM_LIMITTEXT, len, 0);
1543 }
1544
1545 // ----------------------------------------------------------------------------
1546 // Undo/redo
1547 // ----------------------------------------------------------------------------
1548
1549 void wxTextCtrl::Undo()
1550 {
1551     if (CanUndo())
1552     {
1553         ::SendMessage(GetHwnd(), EM_UNDO, 0, 0);
1554
1555         // it's not necessarily at the end any more
1556         m_isCaretAtEnd = false;
1557     }
1558 }
1559
1560 void wxTextCtrl::Redo()
1561 {
1562     if (CanRedo())
1563     {
1564 #if wxUSE_RICHEDIT
1565         if (GetRichVersion() > 1)
1566             ::SendMessage(GetHwnd(), EM_REDO, 0, 0);
1567         else
1568 #endif
1569         // Same as Undo, since Undo undoes the undo, i.e. a redo.
1570         ::SendMessage(GetHwnd(), EM_UNDO, 0, 0);
1571
1572         // it's not necessarily at the end any more
1573         m_isCaretAtEnd = false;
1574     }
1575 }
1576
1577 bool wxTextCtrl::CanUndo() const
1578 {
1579     return ::SendMessage(GetHwnd(), EM_CANUNDO, 0, 0) != 0;
1580 }
1581
1582 bool wxTextCtrl::CanRedo() const
1583 {
1584 #if wxUSE_RICHEDIT
1585     if (GetRichVersion() > 1)
1586         return ::SendMessage(GetHwnd(), EM_CANREDO, 0, 0) != 0;
1587     else
1588 #endif
1589     return ::SendMessage(GetHwnd(), EM_CANUNDO, 0, 0) != 0;
1590 }
1591
1592 // ----------------------------------------------------------------------------
1593 // caret handling (Windows only)
1594 // ----------------------------------------------------------------------------
1595
1596 bool wxTextCtrl::ShowNativeCaret(bool show)
1597 {
1598     if ( show != m_isNativeCaretShown )
1599     {
1600         if ( !(show ? ::ShowCaret(GetHwnd()) : ::HideCaret(GetHwnd())) )
1601         {
1602             // not an error, may simply indicate that it's not shown/hidden
1603             // yet (i.e. it had been hidden/showh 2 times before)
1604             return false;
1605         }
1606
1607         m_isNativeCaretShown = show;
1608     }
1609
1610     return true;
1611 }
1612
1613 // ----------------------------------------------------------------------------
1614 // implemenation details
1615 // ----------------------------------------------------------------------------
1616
1617 void wxTextCtrl::Command(wxCommandEvent & event)
1618 {
1619     SetValue(event.GetString());
1620     ProcessCommand (event);
1621 }
1622
1623 void wxTextCtrl::OnDropFiles(wxDropFilesEvent& event)
1624 {
1625     // By default, load the first file into the text window.
1626     if (event.GetNumberOfFiles() > 0)
1627     {
1628         LoadFile(event.GetFiles()[0]);
1629     }
1630 }
1631
1632 // ----------------------------------------------------------------------------
1633 // kbd input processing
1634 // ----------------------------------------------------------------------------
1635
1636 bool wxTextCtrl::MSWShouldPreProcessMessage(WXMSG* pMsg)
1637 {
1638     MSG *msg = (MSG *)pMsg;
1639
1640     // check for our special keys here: if we don't do it and the parent frame
1641     // uses them as accelerators, they wouldn't work at all, so we disable
1642     // usual preprocessing for them
1643     if ( msg->message == WM_KEYDOWN )
1644     {
1645         WORD vkey = (WORD) msg->wParam;
1646         if ( (HIWORD(msg->lParam) & KF_ALTDOWN) == KF_ALTDOWN )
1647         {
1648             if ( vkey == VK_BACK )
1649                 return false;
1650         }
1651         else // no Alt
1652         {
1653             // we want to process some Ctrl-foo and Shift-bar but no key
1654             // combinations without either Ctrl or Shift nor with both of them
1655             // pressed
1656             const int ctrl = wxIsCtrlDown(),
1657                       shift = wxIsShiftDown();
1658             switch ( ctrl + shift )
1659             {
1660                 default:
1661                     wxFAIL_MSG( _T("how many modifiers have we got?") );
1662                     // fall through
1663
1664                 case 0:
1665                 case 2:
1666                     break;
1667
1668                 case 1:
1669                     // either Ctrl or Shift pressed
1670                     if ( ctrl )
1671                     {
1672                         switch ( vkey )
1673                         {
1674                             case 'C':
1675                             case 'V':
1676                             case 'X':
1677                             case VK_INSERT:
1678                             case VK_DELETE:
1679                             case VK_HOME:
1680                             case VK_END:
1681                                 return false;
1682                         }
1683                     }
1684                     else // Shift is pressed
1685                     {
1686                         if ( vkey == VK_INSERT || vkey == VK_DELETE )
1687                             return false;
1688                     }
1689             }
1690         }
1691     }
1692
1693     return wxControl::MSWShouldPreProcessMessage(pMsg);
1694 }
1695
1696 void wxTextCtrl::OnChar(wxKeyEvent& event)
1697 {
1698     switch ( event.GetKeyCode() )
1699     {
1700         case WXK_RETURN:
1701             if ( !HasFlag(wxTE_MULTILINE) )
1702             {
1703                 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
1704                 InitCommandEvent(event);
1705                 event.SetString(GetValue());
1706                 if ( GetEventHandler()->ProcessEvent(event) )
1707                     return;
1708             }
1709             //else: multiline controls need Enter for themselves
1710
1711             break;
1712
1713         case WXK_TAB:
1714             // ok, so this is getting absolutely ridiculous but I don't see
1715             // any other way to fix this bug: when a multiline text control is
1716             // inside a wxFrame, we need to generate the navigation event as
1717             // otherwise nothing happens at all, but when the same control is
1718             // created inside a dialog, IsDialogMessage() *does* switch focus
1719             // all by itself and so if we do it here as well, it is advanced
1720             // twice and goes to the next control... to prevent this from
1721             // happening we're doing this ugly check, the logic being that if
1722             // we don't have focus then it had been already changed to the next
1723             // control
1724             //
1725             // the right thing to do would, of course, be to understand what
1726             // the hell is IsDialogMessage() doing but this is beyond my feeble
1727             // forces at the moment unfortunately
1728             if ( !(m_windowStyle & wxTE_PROCESS_TAB))
1729             {
1730                 if ( FindFocus() == this )
1731                 {
1732                     int flags = 0;
1733                     if (!event.ShiftDown())
1734                         flags |= wxNavigationKeyEvent::IsForward ;
1735                     if (event.ControlDown())
1736                         flags |= wxNavigationKeyEvent::WinChange ;
1737                     if (Navigate(flags))
1738                         return;
1739                 }
1740             }
1741             else
1742             {
1743                 // Insert tab since calling the default Windows handler
1744                 // doesn't seem to do it
1745                 WriteText(wxT("\t"));
1746             }
1747             break;
1748     }
1749
1750     // no, we didn't process it
1751     event.Skip();
1752 }
1753
1754 WXLRESULT wxTextCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
1755 {
1756     WXLRESULT lRc = wxTextCtrlBase::MSWWindowProc(nMsg, wParam, lParam);
1757
1758     if ( nMsg == WM_GETDLGCODE )
1759     {
1760         // we always want the chars and the arrows: the arrows for navigation
1761         // and the chars because we want Ctrl-C to work even in a read only
1762         // control
1763         long lDlgCode = DLGC_WANTCHARS | DLGC_WANTARROWS;
1764
1765         if ( IsEditable() )
1766         {
1767             // we may have several different cases:
1768             // 1. normal case: both TAB and ENTER are used for dlg navigation
1769             // 2. ctrl which wants TAB for itself: ENTER is used to pass to the
1770             //    next control in the dialog
1771             // 3. ctrl which wants ENTER for itself: TAB is used for dialog
1772             //    navigation
1773             // 4. ctrl which wants both TAB and ENTER: Ctrl-ENTER is used to go
1774             //    to the next control
1775
1776             // the multiline edit control should always get <Return> for itself
1777             if ( HasFlag(wxTE_PROCESS_ENTER) || HasFlag(wxTE_MULTILINE) )
1778                 lDlgCode |= DLGC_WANTMESSAGE;
1779
1780             if ( HasFlag(wxTE_PROCESS_TAB) )
1781                 lDlgCode |= DLGC_WANTTAB;
1782
1783             lRc |= lDlgCode;
1784         }
1785         else // !editable
1786         {
1787             // NB: use "=", not "|=" as the base class version returns the
1788             //     same flags is this state as usual (i.e. including
1789             //     DLGC_WANTMESSAGE). This is strange (how does it work in the
1790             //     native Win32 apps?) but for now live with it.
1791             lRc = lDlgCode;
1792         }
1793     }
1794
1795     return lRc;
1796 }
1797
1798 // ----------------------------------------------------------------------------
1799 // text control event processing
1800 // ----------------------------------------------------------------------------
1801
1802 bool wxTextCtrl::SendUpdateEvent()
1803 {
1804     // is event reporting suspended?
1805     if ( m_suppressNextUpdate )
1806     {
1807         // do process the next one
1808         m_suppressNextUpdate = false;
1809
1810         return false;
1811     }
1812
1813     wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, GetId());
1814     InitCommandEvent(event);
1815     event.SetString(GetValue());
1816
1817     return ProcessCommand(event);
1818 }
1819
1820 bool wxTextCtrl::MSWCommand(WXUINT param, WXWORD WXUNUSED(id))
1821 {
1822     switch ( param )
1823     {
1824         case EN_SETFOCUS:
1825         case EN_KILLFOCUS:
1826             {
1827                 wxFocusEvent event(param == EN_KILLFOCUS ? wxEVT_KILL_FOCUS
1828                                                          : wxEVT_SET_FOCUS,
1829                                    m_windowId);
1830                 event.SetEventObject(this);
1831                 GetEventHandler()->ProcessEvent(event);
1832             }
1833             break;
1834
1835         case EN_CHANGE:
1836             SendUpdateEvent();
1837             break;
1838
1839         case EN_MAXTEXT:
1840             // the text size limit has been hit -- try to increase it
1841             if ( !AdjustSpaceLimit() )
1842             {
1843                 wxCommandEvent event(wxEVT_COMMAND_TEXT_MAXLEN, m_windowId);
1844                 InitCommandEvent(event);
1845                 event.SetString(GetValue());
1846                 ProcessCommand(event);
1847             }
1848             break;
1849
1850             // the other edit notification messages are not processed
1851         default:
1852             return false;
1853     }
1854
1855     // processed
1856     return true;
1857 }
1858
1859 WXHBRUSH wxTextCtrl::OnCtlColor(WXHDC pDC, WXHWND WXUNUSED(pWnd), WXUINT WXUNUSED(nCtlColor),
1860 #if wxUSE_CTL3D
1861                                WXUINT message,
1862                                WXWPARAM wParam,
1863                                WXLPARAM lParam
1864 #else
1865                                WXUINT WXUNUSED(message),
1866                                WXWPARAM WXUNUSED(wParam),
1867                                WXLPARAM WXUNUSED(lParam)
1868 #endif
1869     )
1870 {
1871 #if wxUSE_CTL3D
1872     if ( m_useCtl3D )
1873     {
1874         HBRUSH hbrush = Ctl3dCtlColorEx(message, wParam, lParam);
1875         return (WXHBRUSH) hbrush;
1876     }
1877 #endif // wxUSE_CTL3D
1878
1879     HDC hdc = (HDC)pDC;
1880     wxColour colBack = GetBackgroundColour();
1881
1882     if (!IsEnabled() && (GetWindowStyle() & wxTE_MULTILINE) == 0)
1883         colBack = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
1884
1885     ::SetBkColor(hdc, wxColourToRGB(colBack));
1886     ::SetTextColor(hdc, wxColourToRGB(GetForegroundColour()));
1887
1888     wxBrush *brush = wxTheBrushList->FindOrCreateBrush(colBack, wxSOLID);
1889
1890     return (WXHBRUSH)brush->GetResourceHandle();
1891 }
1892
1893 bool wxTextCtrl::AdjustSpaceLimit()
1894 {
1895     unsigned int limit = ::SendMessage(GetHwnd(), EM_GETLIMITTEXT, 0, 0);
1896
1897     // HACK: we try to automatically extend the limit for the amount of text
1898     //       to allow (interactively) entering more than 64Kb of text under
1899     //       Win9x but we shouldn't reset the text limit which was previously
1900     //       set explicitly with SetMaxLength()
1901     //
1902     //       we could solve this by storing the limit we set in wxTextCtrl but
1903     //       to save space we prefer to simply test here the actual limit
1904     //       value: we consider that SetMaxLength() can only be called for
1905     //       values < 32Kb
1906     if ( limit < 0x8000 )
1907     {
1908         // we've got more text than limit set by SetMaxLength()
1909         return false;
1910     }
1911
1912     unsigned int len = ::GetWindowTextLength(GetHwnd());
1913     if ( len >= limit )
1914     {
1915         limit = len + 0x8000;    // 32Kb
1916
1917 #if wxUSE_RICHEDIT
1918         if ( IsRich() )
1919         {
1920             // as a nice side effect, this also allows passing limit > 64Kb
1921             ::SendMessage(GetHwnd(), EM_EXLIMITTEXT, 0, limit);
1922         }
1923         else
1924 #endif // wxUSE_RICHEDIT
1925         {
1926             if ( limit > 0xffff )
1927             {
1928                 // this will set it to a platform-dependent maximum (much more
1929                 // than 64Kb under NT)
1930                 limit = 0;
1931             }
1932
1933             ::SendMessage(GetHwnd(), EM_LIMITTEXT, limit, 0);
1934         }
1935     }
1936
1937     // we changed the limit
1938     return true;
1939 }
1940
1941 bool wxTextCtrl::AcceptsFocus() const
1942 {
1943     // we don't want focus if we can't be edited unless we're a multiline
1944     // control because then it might be still nice to get focus from keyboard
1945     // to be able to scroll it without mouse
1946     return (IsEditable() || IsMultiLine()) && wxControl::AcceptsFocus();
1947 }
1948
1949 wxSize wxTextCtrl::DoGetBestSize() const
1950 {
1951     int cx, cy;
1952     wxGetCharSize(GetHWND(), &cx, &cy, GetFont());
1953
1954     int wText = DEFAULT_ITEM_WIDTH;
1955
1956     int hText = cy;
1957     if ( m_windowStyle & wxTE_MULTILINE )
1958     {
1959         hText *= wxMax(GetNumberOfLines(), 5);
1960     }
1961     //else: for single line control everything is ok
1962
1963     // we have to add the adjustments for the control height only once, not
1964     // once per line, so do it after multiplication above
1965     hText += EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy) - cy;
1966
1967     return wxSize(wText, hText);
1968 }
1969
1970 // ----------------------------------------------------------------------------
1971 // standard handlers for standard edit menu events
1972 // ----------------------------------------------------------------------------
1973
1974 void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
1975 {
1976     Cut();
1977 }
1978
1979 void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
1980 {
1981     Copy();
1982 }
1983
1984 void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
1985 {
1986     Paste();
1987 }
1988
1989 void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
1990 {
1991     Undo();
1992 }
1993
1994 void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
1995 {
1996     Redo();
1997 }
1998
1999 void wxTextCtrl::OnDelete(wxCommandEvent& WXUNUSED(event))
2000 {
2001     long from, to;
2002     GetSelection(& from, & to);
2003     if (from != -1 && to != -1)
2004         Remove(from, to);
2005 }
2006
2007 void wxTextCtrl::OnSelectAll(wxCommandEvent& WXUNUSED(event))
2008 {
2009     SetSelection(-1, -1);
2010 }
2011
2012 void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
2013 {
2014     event.Enable( CanCut() );
2015 }
2016
2017 void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
2018 {
2019     event.Enable( CanCopy() );
2020 }
2021
2022 void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
2023 {
2024     event.Enable( CanPaste() );
2025 }
2026
2027 void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
2028 {
2029     event.Enable( CanUndo() );
2030 }
2031
2032 void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
2033 {
2034     event.Enable( CanRedo() );
2035 }
2036
2037 void wxTextCtrl::OnUpdateDelete(wxUpdateUIEvent& event)
2038 {
2039     long from, to;
2040     GetSelection(& from, & to);
2041     event.Enable(from != -1 && to != -1 && from != to && IsEditable()) ;
2042 }
2043
2044 void wxTextCtrl::OnUpdateSelectAll(wxUpdateUIEvent& event)
2045 {
2046     event.Enable(GetLastPosition() > 0);
2047 }
2048
2049 void wxTextCtrl::OnRightClick(wxMouseEvent& event)
2050 {
2051 #if wxUSE_RICHEDIT
2052     if (IsRich())
2053     {
2054         if (!m_privateContextMenu)
2055         {
2056             m_privateContextMenu = new wxMenu;
2057             m_privateContextMenu->Append(wxID_UNDO, _("&Undo"));
2058             m_privateContextMenu->Append(wxID_REDO, _("&Redo"));
2059             m_privateContextMenu->AppendSeparator();
2060             m_privateContextMenu->Append(wxID_CUT, _("Cu&t"));
2061             m_privateContextMenu->Append(wxID_COPY, _("&Copy"));
2062             m_privateContextMenu->Append(wxID_PASTE, _("&Paste"));
2063             m_privateContextMenu->Append(wxID_CLEAR, _("&Delete"));
2064             m_privateContextMenu->AppendSeparator();
2065             m_privateContextMenu->Append(wxID_SELECTALL, _("Select &All"));
2066         }
2067         PopupMenu(m_privateContextMenu, event.GetPosition());
2068         return;
2069     }
2070     else
2071 #endif
2072     event.Skip();
2073 }
2074
2075 void wxTextCtrl::OnSetFocus(wxFocusEvent& WXUNUSED(event))
2076 {
2077     // be sure the caret remains invisible if the user had hidden it
2078     if ( !m_isNativeCaretShown )
2079     {
2080         ::HideCaret(GetHwnd());
2081     }
2082 }
2083
2084 // the rest of the file only deals with the rich edit controls
2085 #if wxUSE_RICHEDIT
2086
2087 // ----------------------------------------------------------------------------
2088 // EN_LINK processing
2089 // ----------------------------------------------------------------------------
2090
2091 bool wxTextCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
2092 {
2093     NMHDR *hdr = (NMHDR* )lParam;
2094     switch ( hdr->code )
2095     {
2096        case EN_MSGFILTER:
2097             {
2098                 const MSGFILTER *msgf = (MSGFILTER *)lParam;
2099                 UINT msg = msgf->msg;
2100
2101                 // this is a bit crazy but richedit 1.0 sends us all mouse
2102                 // events _except_ WM_LBUTTONUP (don't ask me why) so we have
2103                 // generate the wxWin events for this message manually
2104                 //
2105                 // NB: in fact, this is still not totally correct as it does
2106                 //     send us WM_LBUTTONUP if the selection was cleared by the
2107                 //     last click -- so currently we get 2 events in this case,
2108                 //     but as I don't see any obvious way to check for this I
2109                 //     leave this code in place because it's still better than
2110                 //     not getting left up events at all
2111                 if ( msg == WM_LBUTTONUP )
2112                 {
2113                     WXUINT flags = msgf->wParam;
2114                     int x = GET_X_LPARAM(msgf->lParam),
2115                         y = GET_Y_LPARAM(msgf->lParam);
2116
2117                     HandleMouseEvent(msg, x, y, flags);
2118                 }
2119             }
2120
2121             // return true to process the event (and false to ignore it)
2122             return true;
2123
2124         case EN_LINK:
2125             {
2126                 const ENLINK *enlink = (ENLINK *)hdr;
2127
2128                 switch ( enlink->msg )
2129                 {
2130                     case WM_SETCURSOR:
2131                         // ok, so it is hardcoded - do we really nee to
2132                         // customize it?
2133                         {
2134                             wxCursor cur(wxCURSOR_HAND);
2135                             ::SetCursor(GetHcursorOf(cur));
2136                             *result = TRUE;
2137                             break;
2138                         }
2139
2140                     case WM_MOUSEMOVE:
2141                     case WM_LBUTTONDOWN:
2142                     case WM_LBUTTONUP:
2143                     case WM_LBUTTONDBLCLK:
2144                     case WM_RBUTTONDOWN:
2145                     case WM_RBUTTONUP:
2146                     case WM_RBUTTONDBLCLK:
2147                         // send a mouse event
2148                         {
2149                             static const wxEventType eventsMouse[] =
2150                             {
2151                                 wxEVT_MOTION,
2152                                 wxEVT_LEFT_DOWN,
2153                                 wxEVT_LEFT_UP,
2154                                 wxEVT_LEFT_DCLICK,
2155                                 wxEVT_RIGHT_DOWN,
2156                                 wxEVT_RIGHT_UP,
2157                                 wxEVT_RIGHT_DCLICK,
2158                             };
2159
2160                             // the event ids are consecutive
2161                             wxMouseEvent
2162                                 evtMouse(eventsMouse[enlink->msg - WM_MOUSEMOVE]);
2163
2164                             InitMouseEvent(evtMouse,
2165                                            GET_X_LPARAM(enlink->lParam),
2166                                            GET_Y_LPARAM(enlink->lParam),
2167                                            enlink->wParam);
2168
2169                             wxTextUrlEvent event(m_windowId, evtMouse,
2170                                                  enlink->chrg.cpMin,
2171                                                  enlink->chrg.cpMax);
2172
2173                             InitCommandEvent(event);
2174
2175                             *result = ProcessCommand(event);
2176                         }
2177                         break;
2178                 }
2179             }
2180             return true;
2181     }
2182
2183     // not processed, leave it to the base class
2184     return wxTextCtrlBase::MSWOnNotify(idCtrl, lParam, result);
2185 }
2186
2187 // ----------------------------------------------------------------------------
2188 // Default colors for MSW text control
2189 //
2190 // Set default background color to the native white instead of
2191 // the default wxSYS_COLOUR_BTNFACE (is triggered with wxNullColour).
2192 // ----------------------------------------------------------------------------
2193
2194 wxVisualAttributes wxTextCtrl::GetDefaultAttributes() const
2195 {
2196     wxVisualAttributes attrs;
2197     attrs.font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
2198     attrs.colFg = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
2199     attrs.colBg = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW); //white
2200
2201     return attrs;
2202 }
2203
2204 // ----------------------------------------------------------------------------
2205 // colour setting for the rich edit controls
2206 // ----------------------------------------------------------------------------
2207
2208 bool wxTextCtrl::SetBackgroundColour(const wxColour& colour)
2209 {
2210     if ( !wxTextCtrlBase::SetBackgroundColour(colour) )
2211     {
2212         // colour didn't really change
2213         return false;
2214     }
2215
2216     if ( IsRich() )
2217     {
2218         // rich edit doesn't use WM_CTLCOLOR, hence we need to send
2219         // EM_SETBKGNDCOLOR additionally
2220         ::SendMessage(GetHwnd(), EM_SETBKGNDCOLOR, 0, wxColourToRGB(colour));
2221     }
2222
2223     return true;
2224 }
2225
2226 bool wxTextCtrl::SetForegroundColour(const wxColour& colour)
2227 {
2228     if ( !wxTextCtrlBase::SetForegroundColour(colour) )
2229     {
2230         // colour didn't really change
2231         return false;
2232     }
2233
2234     if ( IsRich() )
2235     {
2236         // change the colour of everything
2237         CHARFORMAT cf;
2238         wxZeroMemory(cf);
2239         cf.cbSize = sizeof(cf);
2240         cf.dwMask = CFM_COLOR;
2241         cf.crTextColor = wxColourToRGB(colour);
2242         ::SendMessage(GetHwnd(), EM_SETCHARFORMAT, SCF_ALL, (LPARAM)&cf);
2243     }
2244
2245     return true;
2246 }
2247
2248 // ----------------------------------------------------------------------------
2249 // styling support for rich edit controls
2250 // ----------------------------------------------------------------------------
2251
2252 #if wxUSE_RICHEDIT
2253
2254 bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style)
2255 {
2256     if ( !IsRich() )
2257     {
2258         // can't do it with normal text control
2259         return false;
2260     }
2261
2262     // the richedit 1.0 doesn't handle setting background colour, so don't
2263     // even try to do anything if it's the only thing we want to change
2264     if ( m_verRichEdit == 1 && !style.HasFont() && !style.HasTextColour() &&
2265         !style.HasLeftIndent() && !style.HasRightIndent() && !style.HasAlignment() &&
2266         !style.HasTabs() )
2267     {
2268         // nothing to do: return true if there was really nothing to do and
2269         // false if we failed to set bg colour
2270         return !style.HasBackgroundColour();
2271     }
2272
2273     // order the range if needed
2274     if ( start > end )
2275     {
2276         long tmp = start;
2277         start = end;
2278         end = tmp;
2279     }
2280
2281     // we can only change the format of the selection, so select the range we
2282     // want and restore the old selection later
2283     long startOld, endOld;
2284     GetSelection(&startOld, &endOld);
2285
2286     // but do we really have to change the selection?
2287     bool changeSel = start != startOld || end != endOld;
2288
2289     if ( changeSel )
2290     {
2291         DoSetSelection(start, end, false /* don't scroll caret into view */);
2292     }
2293
2294     // initialize CHARFORMAT struct
2295 #if wxUSE_RICHEDIT2
2296     CHARFORMAT2 cf;
2297 #else
2298     CHARFORMAT cf;
2299 #endif
2300
2301     wxZeroMemory(cf);
2302
2303     // we can't use CHARFORMAT2 with RichEdit 1.0, so pretend it is a simple
2304     // CHARFORMAT in that case
2305 #if wxUSE_RICHEDIT2
2306     if ( m_verRichEdit == 1 )
2307     {
2308         // this is the only thing the control is going to grok
2309         cf.cbSize = sizeof(CHARFORMAT);
2310     }
2311     else
2312 #endif
2313     {
2314         // CHARFORMAT or CHARFORMAT2
2315         cf.cbSize = sizeof(cf);
2316     }
2317
2318     if ( style.HasFont() )
2319     {
2320         // VZ: CFM_CHARSET doesn't seem to do anything at all in RichEdit 2.0
2321         //     but using it doesn't seem to hurt neither so leaving it for now
2322
2323         cf.dwMask |= CFM_FACE | CFM_SIZE | CFM_CHARSET |
2324                      CFM_ITALIC | CFM_BOLD | CFM_UNDERLINE;
2325
2326         // fill in data from LOGFONT but recalculate lfHeight because we need
2327         // the real height in twips and not the negative number which
2328         // wxFillLogFont() returns (this is correct in general and works with
2329         // the Windows font mapper, but not here)
2330         LOGFONT lf;
2331         wxFillLogFont(&lf, &style.GetFont());
2332         cf.yHeight = 20*style.GetFont().GetPointSize(); // 1 pt = 20 twips
2333         cf.bCharSet = lf.lfCharSet;
2334         cf.bPitchAndFamily = lf.lfPitchAndFamily;
2335         wxStrncpy( cf.szFaceName, lf.lfFaceName, WXSIZEOF(cf.szFaceName) );
2336
2337         // also deal with underline/italic/bold attributes: note that we must
2338         // always set CFM_ITALIC &c bits in dwMask, even if we don't set the
2339         // style to allow clearing it
2340         if ( lf.lfItalic )
2341         {
2342             cf.dwEffects |= CFE_ITALIC;
2343         }
2344
2345         if ( lf.lfWeight == FW_BOLD )
2346         {
2347             cf.dwEffects |= CFE_BOLD;
2348         }
2349
2350         if ( lf.lfUnderline )
2351         {
2352             cf.dwEffects |= CFE_UNDERLINE;
2353         }
2354
2355         // strikeout fonts are not supported by wxWidgets
2356     }
2357
2358     if ( style.HasTextColour() )
2359     {
2360         cf.dwMask |= CFM_COLOR;
2361         cf.crTextColor = wxColourToRGB(style.GetTextColour());
2362     }
2363
2364 #if wxUSE_RICHEDIT2
2365     if ( m_verRichEdit != 1 && style.HasBackgroundColour() )
2366     {
2367         cf.dwMask |= CFM_BACKCOLOR;
2368         cf.crBackColor = wxColourToRGB(style.GetBackgroundColour());
2369     }
2370 #endif // wxUSE_RICHEDIT2
2371
2372     // do format the selection
2373     bool ok = ::SendMessage(GetHwnd(), EM_SETCHARFORMAT,
2374                             SCF_SELECTION, (LPARAM)&cf) != 0;
2375     if ( !ok )
2376     {
2377         wxLogDebug(_T("SendMessage(EM_SETCHARFORMAT, SCF_SELECTION) failed"));
2378     }
2379
2380     // now do the paragraph formatting
2381     PARAFORMAT2 pf;
2382     wxZeroMemory(pf);
2383     // we can't use PARAFORMAT2 with RichEdit 1.0, so pretend it is a simple
2384     // PARAFORMAT in that case
2385 #if wxUSE_RICHEDIT2
2386     if ( m_verRichEdit == 1 )
2387     {
2388         // this is the only thing the control is going to grok
2389         pf.cbSize = sizeof(PARAFORMAT);
2390     }
2391     else
2392 #endif
2393     {
2394         // PARAFORMAT or PARAFORMAT2
2395         pf.cbSize = sizeof(pf);
2396     }
2397
2398     if (style.HasAlignment())
2399     {
2400         pf.dwMask |= PFM_ALIGNMENT;
2401         if (style.GetAlignment() == wxTEXT_ALIGNMENT_RIGHT)
2402             pf.wAlignment = PFA_RIGHT;
2403         else if (style.GetAlignment() == wxTEXT_ALIGNMENT_CENTRE)
2404             pf.wAlignment = PFA_CENTER;
2405         else if (style.GetAlignment() == wxTEXT_ALIGNMENT_JUSTIFIED)
2406             pf.wAlignment = PFA_JUSTIFY;
2407         else
2408             pf.wAlignment = PFA_LEFT;
2409     }
2410
2411     if (style.HasLeftIndent())
2412     {
2413         pf.dwMask |= PFM_STARTINDENT | PFM_OFFSET;
2414
2415         // Convert from 1/10 mm to TWIPS
2416         pf.dxStartIndent = (int) (((double) style.GetLeftIndent()) * mm2twips / 10.0) ;
2417         pf.dxOffset = (int) (((double) style.GetLeftSubIndent()) * mm2twips / 10.0) ;
2418     }
2419
2420     if (style.HasRightIndent())
2421     {
2422         pf.dwMask |= PFM_RIGHTINDENT;
2423
2424         // Convert from 1/10 mm to TWIPS
2425         pf.dxRightIndent = (int) (((double) style.GetRightIndent()) * mm2twips / 10.0) ;
2426     }
2427
2428     if (style.HasTabs())
2429     {
2430         pf.dwMask |= PFM_TABSTOPS;
2431
2432         const wxArrayInt& tabs = style.GetTabs();
2433
2434         pf.cTabCount = (SHORT)wxMin(tabs.GetCount(), MAX_TAB_STOPS);
2435         size_t i;
2436         for (i = 0; i < (size_t) pf.cTabCount; i++)
2437         {
2438             // Convert from 1/10 mm to TWIPS
2439             pf.rgxTabs[i] = (int) (((double) tabs[i]) * mm2twips / 10.0) ;
2440         }
2441     }
2442
2443     if (pf.dwMask != 0)
2444     {
2445         // do format the selection
2446         bool ok = ::SendMessage(GetHwnd(), EM_SETPARAFORMAT,
2447             0, (LPARAM) &pf) != 0;
2448         if ( !ok )
2449         {
2450             wxLogDebug(_T("SendMessage(EM_SETPARAFORMAT, 0) failed"));
2451         }
2452     }
2453
2454     if ( changeSel )
2455     {
2456         // restore the original selection
2457         DoSetSelection(startOld, endOld, false);
2458     }
2459
2460     return ok;
2461 }
2462
2463 bool wxTextCtrl::SetDefaultStyle(const wxTextAttr& style)
2464 {
2465     if ( !wxTextCtrlBase::SetDefaultStyle(style) )
2466         return false;
2467
2468     if ( IsEditable() )
2469     {
2470         // we have to do this or the style wouldn't apply for the text typed by
2471         // the user
2472         long posLast = GetLastPosition();
2473         SetStyle(posLast, posLast, m_defaultStyle);
2474     }
2475
2476     return true;
2477 }
2478
2479 bool wxTextCtrl::GetStyle(long position, wxTextAttr& style)
2480 {
2481     if ( !IsRich() )
2482     {
2483         // can't do it with normal text control
2484         return false;
2485     }
2486
2487     // initialize CHARFORMAT struct
2488 #if wxUSE_RICHEDIT2
2489     CHARFORMAT2 cf;
2490 #else
2491     CHARFORMAT cf;
2492 #endif
2493
2494     wxZeroMemory(cf);
2495
2496     // we can't use CHARFORMAT2 with RichEdit 1.0, so pretend it is a simple
2497     // CHARFORMAT in that case
2498 #if wxUSE_RICHEDIT2
2499     if ( m_verRichEdit == 1 )
2500     {
2501         // this is the only thing the control is going to grok
2502         cf.cbSize = sizeof(CHARFORMAT);
2503     }
2504     else
2505 #endif
2506     {
2507         // CHARFORMAT or CHARFORMAT2
2508         cf.cbSize = sizeof(cf);
2509     }
2510     // we can only change the format of the selection, so select the range we
2511     // want and restore the old selection later
2512     long startOld, endOld;
2513     GetSelection(&startOld, &endOld);
2514
2515     // but do we really have to change the selection?
2516     bool changeSel = position != startOld || position != endOld;
2517
2518     if ( changeSel )
2519     {
2520         DoSetSelection(position, position, false /* don't scroll caret into view */);
2521     }
2522
2523     // get the selection formatting
2524     (void) ::SendMessage(GetHwnd(), EM_GETCHARFORMAT,
2525                             SCF_SELECTION, (LPARAM)&cf) ;
2526
2527
2528     LOGFONT lf;
2529     lf.lfHeight = cf.yHeight;
2530     lf.lfWidth = 0;
2531     lf.lfCharSet = ANSI_CHARSET; // FIXME: how to get correct charset?
2532     lf.lfClipPrecision = 0;
2533     lf.lfEscapement = 0;
2534     wxStrcpy(lf.lfFaceName, cf.szFaceName);
2535
2536     //NOTE:  we _MUST_ set each of these values to _something_ since we
2537     //do not call wxZeroMemory on the LOGFONT lf
2538     if (cf.dwEffects & CFE_ITALIC)
2539         lf.lfItalic = TRUE;
2540     else
2541         lf.lfItalic = FALSE;
2542
2543     lf.lfOrientation = 0;
2544     lf.lfPitchAndFamily = cf.bPitchAndFamily;
2545     lf.lfQuality = 0;
2546
2547     if (cf.dwEffects & CFE_STRIKEOUT)
2548         lf.lfStrikeOut = TRUE;
2549     else
2550         lf.lfStrikeOut = FALSE;
2551
2552     if (cf.dwEffects & CFE_UNDERLINE)
2553         lf.lfUnderline = TRUE;
2554     else
2555         lf.lfUnderline = FALSE;
2556
2557     if (cf.dwEffects & CFE_BOLD)
2558         lf.lfWeight = FW_BOLD;
2559     else
2560         lf.lfWeight = FW_NORMAL;
2561
2562     wxFont font = wxCreateFontFromLogFont(& lf);
2563     if (font.Ok())
2564     {
2565         style.SetFont(font);
2566     }
2567     style.SetTextColour(wxColour(cf.crTextColor));
2568
2569 #if wxUSE_RICHEDIT2
2570     if ( m_verRichEdit != 1 )
2571     {
2572         // cf.dwMask |= CFM_BACKCOLOR;
2573         style.SetBackgroundColour(wxColour(cf.crBackColor));
2574     }
2575 #endif // wxUSE_RICHEDIT2
2576
2577     // now get the paragraph formatting
2578     PARAFORMAT2 pf;
2579     wxZeroMemory(pf);
2580     // we can't use PARAFORMAT2 with RichEdit 1.0, so pretend it is a simple
2581     // PARAFORMAT in that case
2582 #if wxUSE_RICHEDIT2
2583     if ( m_verRichEdit == 1 )
2584     {
2585         // this is the only thing the control is going to grok
2586         pf.cbSize = sizeof(PARAFORMAT);
2587     }
2588     else
2589 #endif
2590     {
2591         // PARAFORMAT or PARAFORMAT2
2592         pf.cbSize = sizeof(pf);
2593     }
2594
2595     // do format the selection
2596     (void) ::SendMessage(GetHwnd(), EM_GETPARAFORMAT, 0, (LPARAM) &pf) ;
2597
2598     style.SetLeftIndent( (int) ((double) pf.dxStartIndent * twips2mm * 10.0), (int) ((double) pf.dxOffset * twips2mm * 10.0) );
2599     style.SetRightIndent( (int) ((double) pf.dxRightIndent * twips2mm * 10.0) );
2600
2601     if (pf.wAlignment == PFA_CENTER)
2602         style.SetAlignment(wxTEXT_ALIGNMENT_CENTRE);
2603     else if (pf.wAlignment == PFA_RIGHT)
2604         style.SetAlignment(wxTEXT_ALIGNMENT_RIGHT);
2605     else if (pf.wAlignment == PFA_JUSTIFY)
2606         style.SetAlignment(wxTEXT_ALIGNMENT_JUSTIFIED);
2607     else
2608         style.SetAlignment(wxTEXT_ALIGNMENT_LEFT);
2609
2610     wxArrayInt tabStops;
2611     size_t i;
2612     for (i = 0; i < (size_t) pf.cTabCount; i++)
2613     {
2614         tabStops.Add( (int) ((double) (pf.rgxTabs[i] & 0xFFFF) * twips2mm * 10.0) );
2615     }
2616
2617     if ( changeSel )
2618     {
2619         // restore the original selection
2620         DoSetSelection(startOld, endOld, false);
2621     }
2622
2623     return true;
2624 }
2625
2626 #endif
2627
2628 // ----------------------------------------------------------------------------
2629 // wxRichEditModule
2630 // ----------------------------------------------------------------------------
2631
2632 bool wxRichEditModule::OnInit()
2633 {
2634     // don't do anything - we will load it when needed
2635     return true;
2636 }
2637
2638 void wxRichEditModule::OnExit()
2639 {
2640     for ( size_t i = 0; i < WXSIZEOF(ms_hRichEdit); i++ )
2641     {
2642         if ( ms_hRichEdit[i] )
2643         {
2644             ::FreeLibrary(ms_hRichEdit[i]);
2645             ms_hRichEdit[i] = NULL;
2646         }
2647     }
2648 }
2649
2650 /* static */
2651 bool wxRichEditModule::Load(int version)
2652 {
2653     // we don't support loading richedit 3.0 as I don't know how to distinguish
2654     // it from 2.0 anyhow
2655     wxCHECK_MSG( version == 1 || version == 2, false,
2656                  _T("incorrect richedit control version requested") );
2657
2658     // make it the index in the array
2659     version--;
2660
2661     if ( ms_hRichEdit[version] == (HINSTANCE)-1 )
2662     {
2663         // we had already tried to load it and failed
2664         return false;
2665     }
2666
2667     if ( ms_hRichEdit[version] )
2668     {
2669         // we've already got this one
2670         return true;
2671     }
2672
2673     wxString dllname = version ? _T("riched20") : _T("riched32");
2674     dllname += _T(".dll");
2675
2676     ms_hRichEdit[version] = ::LoadLibrary(dllname);
2677
2678     if ( !ms_hRichEdit[version] )
2679     {
2680         wxLogSysError(_("Could not load Rich Edit DLL '%s'"), dllname.c_str());
2681
2682         ms_hRichEdit[version] = (HINSTANCE)-1;
2683
2684         return false;
2685     }
2686
2687     return true;
2688 }
2689
2690 #endif // wxUSE_RICHEDIT
2691
2692 #endif // wxUSE_TEXTCTRL && !(__SMARTPHONE__ && __WXWINCE__)