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