src/msw/textctrl.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        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 and Markus Holzem
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 #ifdef __GNUG__
  17     #pragma implementation "textctrl.h"
  18 #endif
  19
  20 // ----------------------------------------------------------------------------
  21 // headers
  22 // ----------------------------------------------------------------------------
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/textctrl.h"
  33     #include "wx/settings.h"
  34     #include "wx/brush.h"
  35     #include "wx/utils.h"
  36     #include "wx/log.h"
  37 #endif
  38
  39 #if wxUSE_CLIPBOARD
  40     #include "wx/app.h"
  41     #include "wx/clipbrd.h"
  42 #endif
  43
  44 #include "wx/textfile.h"
  45
  46 #include <windowsx.h>
  47
  48 #include "wx/msw/private.h"
  49
  50 #include <string.h>
  51 #include <stdlib.h>
  52 #include <sys/types.h>
  53
  54 #if wxUSE_IOSTREAMH
  55 #   include <fstream.h>
  56 #else
  57 #   include <fstream>
  58 #endif
  59
  60 #if wxUSE_RICHEDIT && (!defined(__GNUWIN32__) || defined(wxUSE_NORLANDER_HEADERS))
  61     #include <richedit.h>
  62 #endif
  63
  64 #if !USE_SHARED_LIBRARY
  65
  66 // ----------------------------------------------------------------------------
  67 // event tables and other macros
  68 // ----------------------------------------------------------------------------
  69
  70 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)
  71
  72 BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
  73     EVT_CHAR(wxTextCtrl::OnChar)
  74     EVT_DROP_FILES(wxTextCtrl::OnDropFiles)
  75
  76     EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
  77     EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
  78     EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
  79     EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
  80     EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
  81
  82     EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
  83     EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
  84     EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
  85     EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
  86     EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
  87 END_EVENT_TABLE()
  88
  89 #endif // USE_SHARED_LIBRARY
  90
  91 // ============================================================================
  92 // implementation
  93 // ============================================================================
  94
  95 // ----------------------------------------------------------------------------
  96 // creation
  97 // ----------------------------------------------------------------------------
  98
  99 wxTextCtrl::wxTextCtrl()
 100 {
 101 #if wxUSE_RICHEDIT
 102     m_isRich = FALSE;
 103 #endif
 104 }
 105
 106 bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,
 107                         const wxString& value,
 108                         const wxPoint& pos,
 109                         const wxSize& size,
 110                         long style,
 111                         const wxValidator& validator,
 112                         const wxString& name)
 113 {
 114     // base initialization
 115     if ( !CreateBase(parent, id, pos, size, style, validator, name) )
 116         return FALSE;
 117
 118     // Validator was set in CreateBase
 119     //SetValidator(validator);
 120     if ( parent )
 121         parent->AddChild(this);
 122
 123     // set colours
 124     SetupColours();
 125
 126     // translate wxWin style flags to MSW ones, checking for consistency while
 127     // doing it
 128     long msStyle = ES_LEFT | WS_VISIBLE | WS_CHILD | WS_TABSTOP;
 129     if ( m_windowStyle & wxTE_MULTILINE )
 130     {
 131         wxASSERT_MSG( !(m_windowStyle & wxTE_PROCESS_ENTER),
 132                       wxT("wxTE_PROCESS_ENTER style is ignored for multiline "
 133                          "text controls (they always process it)") );
 134
 135         msStyle |= ES_MULTILINE | ES_WANTRETURN;
 136         if ((m_windowStyle & wxTE_NO_VSCROLL) == 0)
 137             msStyle |= WS_VSCROLL;
 138         m_windowStyle |= wxTE_PROCESS_ENTER;
 139     }
 140     else
 141         msStyle |= ES_AUTOHSCROLL;
 142
 143     if (m_windowStyle & wxHSCROLL)
 144         msStyle |= (WS_HSCROLL | ES_AUTOHSCROLL);
 145
 146     if (m_windowStyle & wxTE_READONLY)
 147         msStyle |= ES_READONLY;
 148
 149     if (m_windowStyle & wxHSCROLL)
 150         msStyle |= (WS_HSCROLL | ES_AUTOHSCROLL);
 151     if (m_windowStyle & wxTE_PASSWORD) // hidden input
 152         msStyle |= ES_PASSWORD;
 153
 154     // we always want the characters and the arrows
 155     m_lDlgCode = DLGC_WANTCHARS | DLGC_WANTARROWS;
 156
 157     // we may have several different cases:
 158     // 1. normal case: both TAB and ENTER are used for dialog navigation
 159     // 2. ctrl which wants TAB for itself: ENTER is used to pass to the next
 160     //    control in the dialog
 161     // 3. ctrl which wants ENTER for itself: TAB is used for dialog navigation
 162     // 4. ctrl which wants both TAB and ENTER: Ctrl-ENTER is used to pass to
 163     //    the next control
 164     if ( m_windowStyle & wxTE_PROCESS_ENTER )
 165         m_lDlgCode |= DLGC_WANTMESSAGE;
 166     if ( m_windowStyle & wxTE_PROCESS_TAB )
 167         m_lDlgCode |= DLGC_WANTTAB;
 168
 169     // do create the control - either an EDIT or RICHEDIT
 170     const wxChar *windowClass = wxT("EDIT");
 171
 172 #if wxUSE_RICHEDIT
 173     if ( m_windowStyle & wxTE_RICH )
 174     {
 175         msStyle |= ES_AUTOVSCROLL;
 176         m_isRich = TRUE;
 177         windowClass = wxT("RICHEDIT");
 178     }
 179     else
 180         m_isRich = FALSE;
 181 #endif
 182
 183     bool want3D;
 184     WXDWORD exStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &want3D);
 185
 186     // Even with extended styles, need to combine with WS_BORDER for them to
 187     // look right.
 188     if ( want3D || wxStyleHasBorder(m_windowStyle) )
 189         msStyle |= WS_BORDER;
 190
 191     // NB: don't use pos and size as CreateWindowEx arguments because they
 192     //     might be -1 in which case we should use the default values (and
 193     //     SetSize called below takes care of it)
 194     m_hWnd = (WXHWND)::CreateWindowEx(exStyle,
 195                                       windowClass,
 196                                       NULL,
 197                                       msStyle,
 198                                       0, 0, 0, 0,
 199                                       GetHwndOf(parent),
 200                                       (HMENU)m_windowId,
 201                                       wxGetInstance(),
 202                                       NULL);
 203
 204     wxCHECK_MSG( m_hWnd, FALSE, wxT("Failed to create text ctrl") );
 205
 206 #if wxUSE_CTL3D
 207     if ( want3D )
 208     {
 209         Ctl3dSubclassCtl(GetHwnd());
 210         m_useCtl3D = TRUE;
 211     }
 212 #endif
 213
 214 #if wxUSE_RICHEDIT
 215     if (m_isRich)
 216     {
 217         // Have to enable events
 218         ::SendMessage(GetHwnd(), EM_SETEVENTMASK, 0,
 219                       ENM_CHANGE | ENM_DROPFILES | ENM_SELCHANGE | ENM_UPDATE);
 220     }
 221 #endif
 222
 223     SubclassWin(GetHWND());
 224
 225     // set font, position, size and initial value
 226     wxFont& fontParent = parent->GetFont();
 227     if ( fontParent.Ok() )
 228     {
 229         SetFont(fontParent);
 230     }
 231     else
 232     {
 233         SetFont(wxSystemSettings::GetSystemFont(wxSYS_SYSTEM_FONT));
 234     }
 235
 236     // Causes a crash for Symantec C++ and WIN32 for some reason
 237 #if !(defined(__SC__) && defined(__WIN32__))
 238     if ( !value.IsEmpty() )
 239     {
 240         SetValue(value);
 241     }
 242 #endif
 243
 244     SetSize(pos.x, pos.y, size.x, size.y);
 245
 246     return TRUE;
 247 }
 248
 249 // Make sure the window style (etc.) reflects the HWND style (roughly)
 250 void wxTextCtrl::AdoptAttributesFromHWND()
 251 {
 252   wxWindow::AdoptAttributesFromHWND();
 253
 254   HWND hWnd = GetHwnd();
 255   long style = GetWindowLong(hWnd, GWL_STYLE);
 256
 257   // retrieve the style to see whether this is an edit or richedit ctrl
 258 #if wxUSE_RICHEDIT
 259   wxChar buf[256];
 260
 261   GetClassName(hWnd, buf, WXSIZEOF(buf));
 262
 263   if ( wxStricmp(buf, wxT("EDIT")) == 0 )
 264     m_isRich = FALSE;
 265   else
 266     m_isRich = TRUE;
 267 #endif // wxUSE_RICHEDIT
 268
 269   if (style & ES_MULTILINE)
 270     m_windowStyle |= wxTE_MULTILINE;
 271   if (style & ES_PASSWORD)
 272     m_windowStyle |= wxTE_PASSWORD;
 273   if (style & ES_READONLY)
 274     m_windowStyle |= wxTE_READONLY;
 275   if (style & ES_WANTRETURN)
 276     m_windowStyle |= wxTE_PROCESS_ENTER;
 277 }
 278
 279 void wxTextCtrl::SetupColours()
 280 {
 281     // FIXME why is bg colour not inherited from parent?
 282     SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW));
 283     SetForegroundColour(GetParent()->GetForegroundColour());
 284 }
 285
 286 // ----------------------------------------------------------------------------
 287 // set/get the controls text
 288 // ----------------------------------------------------------------------------
 289
 290 wxString wxTextCtrl::GetValue() const
 291 {
 292     return wxGetWindowText(GetHWND());
 293 }
 294
 295 void wxTextCtrl::SetValue(const wxString& value)
 296 {
 297     wxString valueDos = wxTextFile::Translate(value, wxTextFileType_Dos);
 298
 299     if ( valueDos != GetValue() )
 300     {
 301         SetWindowText(GetHwnd(), valueDos);
 302
 303         AdjustSpaceLimit();
 304     }
 305 }
 306
 307 void wxTextCtrl::WriteText(const wxString& value)
 308 {
 309     wxString valueDos = wxTextFile::Translate(value, wxTextFileType_Dos);
 310
 311     SendMessage(GetHwnd(), EM_REPLACESEL, 0, (LPARAM)valueDos.c_str());
 312
 313     AdjustSpaceLimit();
 314 }
 315
 316 void wxTextCtrl::AppendText(const wxString& text)
 317 {
 318     SetInsertionPointEnd();
 319     WriteText(text);
 320 }
 321
 322 void wxTextCtrl::Clear()
 323 {
 324     SetWindowText(GetHwnd(), wxT(""));
 325 }
 326
 327 // ----------------------------------------------------------------------------
 328 // Clipboard operations
 329 // ----------------------------------------------------------------------------
 330
 331 void wxTextCtrl::Copy()
 332 {
 333     if (CanCopy())
 334     {
 335         HWND hWnd = GetHwnd();
 336         SendMessage(hWnd, WM_COPY, 0, 0L);
 337     }
 338 }
 339
 340 void wxTextCtrl::Cut()
 341 {
 342     if (CanCut())
 343     {
 344         HWND hWnd = GetHwnd();
 345         SendMessage(hWnd, WM_CUT, 0, 0L);
 346     }
 347 }
 348
 349 void wxTextCtrl::Paste()
 350 {
 351     if (CanPaste())
 352     {
 353         HWND hWnd = GetHwnd();
 354         SendMessage(hWnd, WM_PASTE, 0, 0L);
 355     }
 356 }
 357
 358 bool wxTextCtrl::CanCopy() const
 359 {
 360     // Can copy if there's a selection
 361     long from, to;
 362     GetSelection(& from, & to);
 363     return (from != to);
 364 }
 365
 366 bool wxTextCtrl::CanCut() const
 367 {
 368     // Can cut if there's a selection
 369     long from, to;
 370     GetSelection(& from, & to);
 371     return (from != to);
 372 }
 373
 374 bool wxTextCtrl::CanPaste() const
 375 {
 376 #if wxUSE_RICHEDIT
 377     if (m_isRich)
 378     {
 379         int dataFormat = 0; // 0 == any format
 380         return (::SendMessage( GetHwnd(), EM_CANPASTE, (WPARAM) (UINT) dataFormat, 0) != 0);
 381     }
 382 #endif
 383     if (!IsEditable())
 384         return FALSE;
 385
 386     // Standard edit control: check for straight text on clipboard
 387     bool isTextAvailable = FALSE;
 388     if ( ::OpenClipboard(GetHwndOf(wxTheApp->GetTopWindow())) )
 389     {
 390         isTextAvailable = (::IsClipboardFormatAvailable(CF_TEXT) != 0);
 391         ::CloseClipboard();
 392     }
 393
 394     return isTextAvailable;
 395 }
 396
 397 // ----------------------------------------------------------------------------
 398 // Accessors
 399 // ----------------------------------------------------------------------------
 400
 401 void wxTextCtrl::SetEditable(bool editable)
 402 {
 403     HWND hWnd = GetHwnd();
 404     SendMessage(hWnd, EM_SETREADONLY, (WPARAM)!editable, (LPARAM)0L);
 405 }
 406
 407 void wxTextCtrl::SetInsertionPoint(long pos)
 408 {
 409     HWND hWnd = GetHwnd();
 410 #ifdef __WIN32__
 411 #if wxUSE_RICHEDIT
 412     if ( m_isRich)
 413     {
 414         CHARRANGE range;
 415         range.cpMin = pos;
 416         range.cpMax = pos;
 417         SendMessage(hWnd, EM_EXSETSEL, 0, (LPARAM) &range);
 418         SendMessage(hWnd, EM_SCROLLCARET, (WPARAM)0, (LPARAM)0);
 419     }
 420     else
 421 #endif // wxUSE_RICHEDIT
 422     {
 423         SendMessage(hWnd, EM_SETSEL, pos, pos);
 424         SendMessage(hWnd, EM_SCROLLCARET, (WPARAM)0, (LPARAM)0);
 425     }
 426 #else // Win16
 427     SendMessage(hWnd, EM_SETSEL, 0, MAKELPARAM(pos, pos));
 428 #endif // Win32/16
 429
 430     static const char *nothing = "";
 431     SendMessage(hWnd, EM_REPLACESEL, 0, (LPARAM)nothing);
 432 }
 433
 434 void wxTextCtrl::SetInsertionPointEnd()
 435 {
 436     long pos = GetLastPosition();
 437     SetInsertionPoint(pos);
 438 }
 439
 440 long wxTextCtrl::GetInsertionPoint() const
 441 {
 442 #if wxUSE_RICHEDIT
 443     if (m_isRich)
 444     {
 445         CHARRANGE range;
 446         range.cpMin = 0;
 447         range.cpMax = 0;
 448         SendMessage(GetHwnd(), EM_EXGETSEL, 0, (LPARAM) &range);
 449         return range.cpMin;
 450     }
 451 #endif
 452
 453     DWORD Pos = (DWORD)SendMessage(GetHwnd(), EM_GETSEL, 0, 0L);
 454     return Pos & 0xFFFF;
 455 }
 456
 457 long wxTextCtrl::GetLastPosition() const
 458 {
 459     HWND hWnd = GetHwnd();
 460
 461     // Will always return a number > 0 (according to docs)
 462     int noLines = (int)SendMessage(hWnd, EM_GETLINECOUNT, (WPARAM)0, (LPARAM)0L);
 463
 464     // This gets the char index for the _beginning_ of the last line
 465     int charIndex = (int)SendMessage(hWnd, EM_LINEINDEX, (WPARAM)(noLines-1), (LPARAM)0L);
 466
 467     // Get number of characters in the last line. We'll add this to the character
 468     // index for the last line, 1st position.
 469     int lineLength = (int)SendMessage(hWnd, EM_LINELENGTH, (WPARAM)charIndex, (LPARAM)0L);
 470
 471     return (long)(charIndex + lineLength);
 472 }
 473
 474 // If the return values from and to are the same, there is no
 475 // selection.
 476 void wxTextCtrl::GetSelection(long* from, long* to) const
 477 {
 478 #if wxUSE_RICHEDIT
 479     if (m_isRich)
 480     {
 481         CHARRANGE charRange;
 482         ::SendMessage(GetHwnd(), EM_EXGETSEL, 0, (LPARAM) (CHARRANGE*) & charRange);
 483
 484         *from = charRange.cpMin;
 485         *to = charRange.cpMax;
 486
 487         return;
 488     }
 489 #endif
 490     DWORD dwStart, dwEnd;
 491     WPARAM wParam = (WPARAM) (DWORD*) & dwStart; // receives starting position
 492     LPARAM lParam = (LPARAM) (DWORD*) & dwEnd;   // receives ending position
 493
 494     ::SendMessage(GetHwnd(), EM_GETSEL, wParam, lParam);
 495
 496     *from = dwStart;
 497     *to = dwEnd;
 498 }
 499
 500 bool wxTextCtrl::IsEditable() const
 501 {
 502     long style = ::GetWindowLong(GetHwnd(), GWL_STYLE);
 503
 504     return ((style & ES_READONLY) == 0);
 505 }
 506
 507 // ----------------------------------------------------------------------------
 508 // Editing
 509 // ----------------------------------------------------------------------------
 510
 511 void wxTextCtrl::Replace(long from, long to, const wxString& value)
 512 {
 513 #if wxUSE_CLIPBOARD
 514     HWND hWnd = GetHwnd();
 515     long fromChar = from;
 516     long toChar = to;
 517
 518     // Set selection and remove it
 519 #ifdef __WIN32__
 520     SendMessage(hWnd, EM_SETSEL, fromChar, toChar);
 521 #else
 522     SendMessage(hWnd, EM_SETSEL, (WPARAM)0, (LPARAM)MAKELONG(fromChar, toChar));
 523 #endif
 524     SendMessage(hWnd, WM_CUT, (WPARAM)0, (LPARAM)0);
 525
 526     // Now replace with 'value', by pasting.
 527     wxSetClipboardData(wxDF_TEXT, (wxObject *) (const wxChar *)value, 0, 0);
 528
 529     // Paste into edit control
 530     SendMessage(hWnd, WM_PASTE, (WPARAM)0, (LPARAM)0L);
 531 #else
 532     wxFAIL_MSG("wxTextCtrl::Replace not implemented if wxUSE_CLIPBOARD is 0.");
 533 #endif
 534 }
 535
 536 void wxTextCtrl::Remove(long from, long to)
 537 {
 538     HWND hWnd = GetHwnd();
 539     long fromChar = from;
 540     long toChar = to;
 541
 542     // Cut all selected text
 543 #ifdef __WIN32__
 544     SendMessage(hWnd, EM_SETSEL, fromChar, toChar);
 545 #else
 546     SendMessage(hWnd, EM_SETSEL, (WPARAM)0, (LPARAM)MAKELONG(fromChar, toChar));
 547 #endif
 548     SendMessage(hWnd, WM_CUT, (WPARAM)0, (LPARAM)0);
 549 }
 550
 551 void wxTextCtrl::SetSelection(long from, long to)
 552 {
 553     HWND hWnd = GetHwnd();
 554     long fromChar = from;
 555     long toChar = to;
 556
 557     // if from and to are both -1, it means (in wxWindows) that all text should
 558     // be selected. Translate into Windows convention
 559     if ((from == -1) && (to == -1))
 560     {
 561       fromChar = 0;
 562       toChar = -1;
 563     }
 564
 565 #ifdef __WIN32__
 566     SendMessage(hWnd, EM_SETSEL, (WPARAM)fromChar, (LPARAM)toChar);
 567     SendMessage(hWnd, EM_SCROLLCARET, (WPARAM)0, (LPARAM)0);
 568 #else
 569     // WPARAM is 0: selection is scrolled into view
 570     SendMessage(hWnd, EM_SETSEL, (WPARAM)0, (LPARAM)MAKELONG(fromChar, toChar));
 571 #endif
 572 }
 573
 574 bool wxTextCtrl::LoadFile(const wxString& file)
 575 {
 576     if ( wxTextCtrlBase::LoadFile(file) )
 577     {
 578         // update the size limit if needed
 579         AdjustSpaceLimit();
 580
 581         return TRUE;
 582     }
 583
 584     return FALSE;
 585 }
 586
 587 bool wxTextCtrl::IsModified() const
 588 {
 589     return (SendMessage(GetHwnd(), EM_GETMODIFY, 0, 0) != 0);
 590 }
 591
 592 // Makes 'unmodified'
 593 void wxTextCtrl::DiscardEdits()
 594 {
 595     SendMessage(GetHwnd(), EM_SETMODIFY, FALSE, 0L);
 596 }
 597
 598 int wxTextCtrl::GetNumberOfLines() const
 599 {
 600     return (int)SendMessage(GetHwnd(), EM_GETLINECOUNT, (WPARAM)0, (LPARAM)0);
 601 }
 602
 603 long wxTextCtrl::XYToPosition(long x, long y) const
 604 {
 605     HWND hWnd = GetHwnd();
 606
 607     // This gets the char index for the _beginning_ of this line
 608     int charIndex = (int)SendMessage(hWnd, EM_LINEINDEX, (WPARAM)y, (LPARAM)0);
 609     return (long)(x + charIndex);
 610 }
 611
 612 bool wxTextCtrl::PositionToXY(long pos, long *x, long *y) const
 613 {
 614     HWND hWnd = GetHwnd();
 615
 616     // This gets the line number containing the character
 617     int lineNo;
 618 #if wxUSE_RICHEDIT
 619     if ( m_isRich )
 620     {
 621         lineNo = (int)SendMessage(hWnd, EM_EXLINEFROMCHAR, 0, (LPARAM)pos);
 622     }
 623     else
 624 #endif // wxUSE_RICHEDIT
 625         lineNo = (int)SendMessage(hWnd, EM_LINEFROMCHAR, (WPARAM)pos, 0);
 626
 627     if ( lineNo == -1 )
 628     {
 629         // no such line
 630         return FALSE;
 631     }
 632
 633     // This gets the char index for the _beginning_ of this line
 634     int charIndex = (int)SendMessage(hWnd, EM_LINEINDEX, (WPARAM)lineNo, (LPARAM)0);
 635     if ( charIndex == -1 )
 636     {
 637         return FALSE;
 638     }
 639
 640     // The X position must therefore be the different between pos and charIndex
 641     if ( x )
 642         *x = (long)(pos - charIndex);
 643     if ( y )
 644         *y = (long)lineNo;
 645
 646     return TRUE;
 647 }
 648
 649 void wxTextCtrl::ShowPosition(long pos)
 650 {
 651     HWND hWnd = GetHwnd();
 652
 653     // To scroll to a position, we pass the number of lines and characters
 654     // to scroll *by*. This means that we need to:
 655     // (1) Find the line position of the current line.
 656     // (2) Find the line position of pos.
 657     // (3) Scroll by (pos - current).
 658     // For now, ignore the horizontal scrolling.
 659
 660     // Is this where scrolling is relative to - the line containing the caret?
 661     // Or is the first visible line??? Try first visible line.
 662 //    int currentLineLineNo1 = (int)SendMessage(hWnd, EM_LINEFROMCHAR, (WPARAM)-1, (LPARAM)0L);
 663
 664     int currentLineLineNo = (int)SendMessage(hWnd, EM_GETFIRSTVISIBLELINE, (WPARAM)0, (LPARAM)0L);
 665
 666     int specifiedLineLineNo = (int)SendMessage(hWnd, EM_LINEFROMCHAR, (WPARAM)pos, (LPARAM)0L);
 667
 668     int linesToScroll = specifiedLineLineNo - currentLineLineNo;
 669
 670     if (linesToScroll != 0)
 671       (void)SendMessage(hWnd, EM_LINESCROLL, (WPARAM)0, (LPARAM)linesToScroll);
 672 }
 673
 674 int wxTextCtrl::GetLineLength(long lineNo) const
 675 {
 676     long charIndex = XYToPosition(0, lineNo);
 677     int len = (int)SendMessage(GetHwnd(), EM_LINELENGTH, charIndex, 0);
 678     return len;
 679 }
 680
 681 wxString wxTextCtrl::GetLineText(long lineNo) const
 682 {
 683     size_t len = (size_t)GetLineLength(lineNo) + 1;
 684     char *buf = (char *)malloc(len);
 685     *(WORD *)buf = len;
 686     int noChars = (int)SendMessage(GetHwnd(), EM_GETLINE, lineNo, (LPARAM)buf);
 687     buf[noChars] = 0;
 688
 689     wxString str(buf);
 690
 691     free(buf);
 692
 693     return str;
 694 }
 695
 696 // ----------------------------------------------------------------------------
 697 // Undo/redo
 698 // ----------------------------------------------------------------------------
 699
 700 void wxTextCtrl::Undo()
 701 {
 702     if (CanUndo())
 703     {
 704         ::SendMessage(GetHwnd(), EM_UNDO, 0, 0);
 705     }
 706 }
 707
 708 void wxTextCtrl::Redo()
 709 {
 710     if (CanRedo())
 711     {
 712         // Same as Undo, since Undo undoes the undo, i.e. a redo.
 713         ::SendMessage(GetHwnd(), EM_UNDO, 0, 0);
 714     }
 715 }
 716
 717 bool wxTextCtrl::CanUndo() const
 718 {
 719     return (::SendMessage(GetHwnd(), EM_CANUNDO, 0, 0) != 0);
 720 }
 721
 722 bool wxTextCtrl::CanRedo() const
 723 {
 724     return (::SendMessage(GetHwnd(), EM_CANUNDO, 0, 0) != 0);
 725 }
 726
 727 // ----------------------------------------------------------------------------
 728 // implemenation details
 729 // ----------------------------------------------------------------------------
 730
 731 void wxTextCtrl::Command(wxCommandEvent & event)
 732 {
 733     SetValue(event.GetString());
 734     ProcessCommand (event);
 735 }
 736
 737 void wxTextCtrl::OnDropFiles(wxDropFilesEvent& event)
 738 {
 739     // By default, load the first file into the text window.
 740     if (event.GetNumberOfFiles() > 0)
 741     {
 742         LoadFile(event.GetFiles()[0]);
 743     }
 744 }
 745
 746 WXHBRUSH wxTextCtrl::OnCtlColor(WXHDC pDC, WXHWND pWnd, WXUINT nCtlColor,
 747                                 WXUINT message, WXWPARAM wParam,
 748                                 WXLPARAM lParam)
 749 {
 750 #if wxUSE_CTL3D
 751     if ( m_useCtl3D )
 752     {
 753         HBRUSH hbrush = Ctl3dCtlColorEx(message, wParam, lParam);
 754         return (WXHBRUSH) hbrush;
 755     }
 756 #endif
 757
 758     HDC hdc = (HDC)pDC;
 759     SetBkMode(hdc, GetParent()->GetTransparentBackground() ? TRANSPARENT
 760                                                            : OPAQUE);
 761
 762     ::SetBkColor(hdc, RGB(GetBackgroundColour().Red(), GetBackgroundColour().Green(), GetBackgroundColour().Blue()));
 763     ::SetTextColor(hdc, RGB(GetForegroundColour().Red(), GetForegroundColour().Green(), GetForegroundColour().Blue()));
 764
 765     wxBrush *backgroundBrush = wxTheBrushList->FindOrCreateBrush(GetBackgroundColour(), wxSOLID);
 766
 767     return (WXHBRUSH) backgroundBrush->GetResourceHandle();
 768 }
 769
 770 void wxTextCtrl::OnChar(wxKeyEvent& event)
 771 {
 772     switch ( event.KeyCode() )
 773     {
 774         case WXK_RETURN:
 775             if ( !(m_windowStyle & wxTE_MULTILINE) )
 776             {
 777                 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
 778                 event.SetEventObject( this );
 779                 if ( GetEventHandler()->ProcessEvent(event) )
 780                     return;
 781             }
 782             //else: multiline controls need Enter for themselves
 783
 784             break;
 785
 786         case WXK_TAB:
 787             // always produce navigation event - even if we process TAB
 788             // ourselves the fact that we got here means that the user code
 789             // decided to skip processing of this TAB - probably to let it
 790             // do its default job.
 791             //
 792             // NB: Notice that Ctrl-Tab is handled elsewhere and Alt-Tab is
 793             //     handled by Windows
 794             {
 795                 wxNavigationKeyEvent eventNav;
 796                 eventNav.SetDirection(!event.ShiftDown());
 797                 eventNav.SetWindowChange(FALSE);
 798                 eventNav.SetEventObject(this);
 799
 800                 if ( GetEventHandler()->ProcessEvent(eventNav) )
 801                     return;
 802             }
 803             break;
 804
 805         default:
 806             event.Skip();
 807             return;
 808     }
 809
 810     // don't just call event.Skip() because this will cause TABs and ENTERs
 811     // be passed upwards and we don't always want this - instead process it
 812     // right here
 813
 814     // FIXME
 815     event.Skip();
 816 }
 817
 818 bool wxTextCtrl::MSWCommand(WXUINT param, WXWORD WXUNUSED(id))
 819 {
 820     switch (param)
 821     {
 822         case EN_SETFOCUS:
 823         case EN_KILLFOCUS:
 824             {
 825                 wxFocusEvent event(param == EN_KILLFOCUS ? wxEVT_KILL_FOCUS
 826                         : wxEVT_SET_FOCUS,
 827                         m_windowId);
 828                 event.SetEventObject( this );
 829                 GetEventHandler()->ProcessEvent(event);
 830             }
 831             break;
 832
 833         case EN_CHANGE:
 834             {
 835                 wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
 836                 wxString val(GetValue());
 837                 if ( !val.IsNull() )
 838                     event.m_commandString = WXSTRINGCAST val;
 839                 event.SetEventObject( this );
 840                 ProcessCommand(event);
 841             }
 842             break;
 843
 844         case EN_ERRSPACE:
 845             // the text size limit has been hit - increase it
 846             AdjustSpaceLimit();
 847             break;
 848
 849             // the other notification messages are not processed
 850         case EN_UPDATE:
 851         case EN_MAXTEXT:
 852         case EN_HSCROLL:
 853         case EN_VSCROLL:
 854         default:
 855             return FALSE;
 856     }
 857
 858     // processed
 859     return TRUE;
 860 }
 861
 862 void wxTextCtrl::AdjustSpaceLimit()
 863 {
 864 #ifndef __WIN16__
 865     unsigned int len = ::GetWindowTextLength(GetHwnd()),
 866     limit = ::SendMessage(GetHwnd(), EM_GETLIMITTEXT, 0, 0);
 867     if ( len > limit )
 868     {
 869         limit = len + 0x8000;    // 32Kb
 870
 871 #if wxUSE_RICHEDIT
 872         if ( m_isRich || limit > 0xffff )
 873 #else
 874         if ( limit > 0xffff )
 875 #endif
 876             ::SendMessage(GetHwnd(), EM_LIMITTEXT, 0, limit);
 877         else
 878             ::SendMessage(GetHwnd(), EM_LIMITTEXT, limit, 0);
 879     }
 880 #endif
 881 }
 882
 883 bool wxTextCtrl::AcceptsFocus() const
 884 {
 885     // we don't want focus if we can't be edited
 886     return IsEditable() && wxControl::AcceptsFocus();
 887 }
 888
 889 wxSize wxTextCtrl::DoGetBestSize()
 890 {
 891     int cx, cy;
 892     wxGetCharSize(GetHWND(), &cx, &cy, &GetFont());
 893
 894     int wText = DEFAULT_ITEM_WIDTH;
 895
 896     int hText = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy);
 897     if ( m_windowStyle & wxTE_MULTILINE )
 898     {
 899         hText *= wxMin(GetNumberOfLines(), 5);
 900     }
 901     //else: for single line control everything is ok
 902
 903     return wxSize(wText, hText);
 904 }
 905
 906 // ----------------------------------------------------------------------------
 907 // standard handlers for standard edit menu events
 908 // ----------------------------------------------------------------------------
 909
 910 void wxTextCtrl::OnCut(wxCommandEvent& event)
 911 {
 912     Cut();
 913 }
 914
 915 void wxTextCtrl::OnCopy(wxCommandEvent& event)
 916 {
 917     Copy();
 918 }
 919
 920 void wxTextCtrl::OnPaste(wxCommandEvent& event)
 921 {
 922     Paste();
 923 }
 924
 925 void wxTextCtrl::OnUndo(wxCommandEvent& event)
 926 {
 927     Undo();
 928 }
 929
 930 void wxTextCtrl::OnRedo(wxCommandEvent& event)
 931 {
 932     Redo();
 933 }
 934
 935 void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
 936 {
 937     event.Enable( CanCut() );
 938 }
 939
 940 void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
 941 {
 942     event.Enable( CanCopy() );
 943 }
 944
 945 void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
 946 {
 947     event.Enable( CanPaste() );
 948 }
 949
 950 void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
 951 {
 952     event.Enable( CanUndo() );
 953 }
 954
 955 void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
 956 {
 957     event.Enable( CanRedo() );
 958 }
 959