src/msw/textctrl.cpp

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