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