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