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