src/os2/textctrl.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        textctrl.cpp
   3 // Purpose:     wxTextCtrl
   4 // Author:      David Webster
   5 // Modified by:
   6 // Created:     10/17/99
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) David Webster
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ----------------------------------------------------------------------------
  13 // headers
  14 // ----------------------------------------------------------------------------
  15
  16 // For compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifndef WX_PRECOMP
  20     #include "wx/textctrl.h"
  21     #include "wx/settings.h"
  22     #include "wx/brush.h"
  23     #include "wx/utils.h"
  24     #include "wx/log.h"
  25 #endif
  26
  27 #if wxUSE_CLIPBOARD
  28     #include "wx/app.h"
  29     #include "wx/clipbrd.h"
  30 #endif
  31
  32 #include "wx/textfile.h"
  33
  34 #include "wx/os2/private.h"
  35
  36 #include <string.h>
  37 #include <stdlib.h>
  38 #include <sys/types.h>
  39
  40 #if wxUSE_IOSTREAMH
  41 #   include <fstream.h>
  42 #else
  43 #   include <fstream>
  44 #endif
  45
  46 #if defined(__EMX__) && !defined(MLE_INDEX)
  47 #define MLE_INDEX  0
  48 #define MLE_RGB    1
  49 #endif
  50
  51
  52 // ----------------------------------------------------------------------------
  53 // event tables and other macros
  54 // ----------------------------------------------------------------------------
  55
  56 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)
  57
  58 BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
  59     EVT_CHAR(wxTextCtrl::OnChar)
  60     EVT_DROP_FILES(wxTextCtrl::OnDropFiles)
  61
  62     EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
  63     EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
  64     EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
  65     EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
  66     EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
  67
  68     EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
  69     EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
  70     EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
  71     EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
  72     EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
  73 END_EVENT_TABLE()
  74
  75
  76 // ============================================================================
  77 // implementation
  78 // ============================================================================
  79
  80 // ----------------------------------------------------------------------------
  81 // creation
  82 // ----------------------------------------------------------------------------
  83
  84 wxTextCtrl::wxTextCtrl()
  85 {
  86 }
  87
  88 bool wxTextCtrl::Create(
  89   wxWindow*                         pParent
  90 , wxWindowID                        vId
  91 , const wxString&                   rsValue
  92 , const wxPoint&                    rPos
  93 , const wxSize&                     rSize
  94 , long                              lStyle
  95 #if wxUSE_VALIDATORS
  96 , const wxValidator&                rValidator
  97 #endif
  98 , const wxString&                   rsName
  99 )
 100 {
 101     //
 102     // Base initialization
 103     //
 104     if ( !CreateBase( pParent
 105                      ,vId
 106                      ,rPos
 107                      ,rSize
 108                      ,lStyle
 109 #if wxUSE_VALIDATORS
 110                      ,rValidator
 111 #endif
 112                      ,rsName
 113                     ))
 114         return FALSE;
 115
 116     wxPoint                         vPos = rPos; // The OS/2 position
 117
 118     if (pParent )
 119     {
 120         pParent->AddChild(this);
 121         //
 122         // OS2 uses normal coordinates, no bassackwards Windows ones
 123         //
 124 //        vPos.y = pParent->GetSize().y - (vPos.y + rSize.y);
 125     }
 126     else
 127     {
 128         RECTL                   vRect;
 129
 130         ::WinQueryWindowRect(HWND_DESKTOP, &vRect);
 131 //        vPos.y = vRect.yTop - (vPos.y + rSize.y);
 132     }
 133
 134     m_windowStyle = lStyle;
 135
 136     long                            lSstyle = WS_VISIBLE | WS_TABSTOP;
 137
 138     //
 139     // Single and multiline edit fields are two different controls in PM
 140     //
 141     if ( m_windowStyle & wxTE_MULTILINE )
 142     {
 143         m_bIsMLE = TRUE;
 144         m_windowStyle |= wxTE_PROCESS_ENTER;
 145
 146         if ((m_windowStyle & wxTE_NO_VSCROLL) == 0)
 147             lSstyle |= MLS_VSCROLL;
 148         if (m_windowStyle & wxHSCROLL)
 149             lSstyle |= MLS_HSCROLL;
 150         if (m_windowStyle & wxTE_READONLY)
 151             lSstyle |= MLS_READONLY;
 152     }
 153     else
 154     {
 155         lSstyle |= ES_LEFT;
 156
 157         if (m_windowStyle & wxHSCROLL)
 158             lSstyle |=  ES_AUTOSCROLL;
 159         if (m_windowStyle & wxTE_READONLY)
 160             lSstyle |= ES_READONLY;
 161         if (m_windowStyle & wxTE_PASSWORD) // hidden input
 162             lSstyle |= ES_UNREADABLE;
 163     }
 164     if (m_bIsMLE)
 165     {
 166         m_hWnd = (WXHWND)::WinCreateWindow( (HWND)GetHwndOf(pParent) // Parent window handle
 167                                            ,WC_MLE                   // Window class
 168                                            ,(PSZ)rsValue.c_str()     // Initial Text
 169                                            ,(ULONG)lSstyle           // Style flags
 170                                            ,(LONG)0                  // X pos of origin
 171                                            ,(LONG)0                  // Y pos of origin
 172                                            ,(LONG)0                  // field width
 173                                            ,(LONG)0                  // field height
 174                                            ,(HWND)GetHwndOf(pParent) // owner window handle (same as parent
 175                                            ,HWND_TOP                 // initial z position
 176                                            ,(ULONG)vId               // Window identifier
 177                                            ,NULL                     // no control data
 178                                            ,NULL                     // no Presentation parameters
 179                                           );
 180     }
 181     else
 182     {
 183         m_hWnd = (WXHWND)::WinCreateWindow( (HWND)GetHwndOf(pParent) // Parent window handle
 184                                            ,WC_ENTRYFIELD            // Window class
 185                                            ,(PSZ)rsValue.c_str()     // Initial Text
 186                                            ,(ULONG)lSstyle           // Style flags
 187                                            ,(LONG)0                  // X pos of origin
 188                                            ,(LONG)0                  // Y pos of origin
 189                                            ,(LONG)0                  // field width
 190                                            ,(LONG)0                  // field height
 191                                            ,(HWND)GetHwndOf(pParent) // owner window handle (same as parent
 192                                            ,HWND_TOP                 // initial z position
 193                                            ,(ULONG)vId               // Window identifier
 194                                            ,NULL                     // no control data
 195                                            ,NULL                     // no Presentation parameters
 196                                           );
 197     }
 198
 199     if (m_hWnd == 0)
 200     {
 201         return FALSE;
 202     }
 203
 204     SubclassWin(GetHWND());
 205
 206     //
 207     // Set font, position, size and initial value
 208     //
 209     wxFont&                         vFontParent = pParent->GetFont();
 210
 211     if (vFontParent.Ok())
 212     {
 213         SetFont(vFontParent);
 214     }
 215     else
 216     {
 217         SetFont(wxSystemSettings::GetSystemFont(wxSYS_SYSTEM_FONT));
 218     }
 219     if (!rsValue.IsEmpty())
 220     {
 221         SetValue(rsValue);
 222     }
 223     SetupColours();
 224     SetSize( rPos.x
 225             ,rPos.y
 226             ,rSize.x
 227             ,rSize.y
 228            );
 229     return TRUE;
 230 } // end of wxTextCtrl::Create
 231
 232 //
 233 // Make sure the window style (etc.) reflects the HWND style (roughly)
 234 //
 235 void wxTextCtrl::AdoptAttributesFromHWND()
 236 {
 237     HWND                            hWnd = GetHwnd();
 238     LONG                            lStyle = ::WinQueryWindowULong(hWnd, QWL_STYLE);
 239
 240     wxWindow::AdoptAttributesFromHWND();
 241
 242     if (m_bIsMLE)
 243     {
 244         m_windowStyle |= wxTE_MULTILINE;
 245         if (lStyle & MLS_READONLY)
 246             m_windowStyle |= wxTE_READONLY;
 247     }
 248     else
 249     {
 250         if (lStyle & ES_UNREADABLE)
 251             m_windowStyle |= wxTE_PASSWORD;
 252         if (lStyle & ES_READONLY)
 253             m_windowStyle |= wxTE_READONLY;
 254     }
 255 } // end of wxTextCtrl::AdoptAttributesFromHWND
 256
 257 void wxTextCtrl::SetupColours()
 258 {
 259     wxColour                        vBkgndColour;
 260
 261     vBkgndColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW);
 262     SetBackgroundColour(vBkgndColour);
 263     SetForegroundColour(GetParent()->GetForegroundColour());
 264 } // end of wxTextCtrl::SetupColours
 265
 266 // ----------------------------------------------------------------------------
 267 // set/get the controls text
 268 // ----------------------------------------------------------------------------
 269
 270 wxString wxTextCtrl::GetValue() const
 271 {
 272     wxString                        sStr = wxGetWindowText(GetHWND());
 273     char*                           zStr = (char*)sStr.c_str();
 274
 275     for ( ; *zStr; zStr++ )
 276     {
 277         //
 278         // this will replace \r\n with just \n
 279         //
 280         if (*zStr == '\n')
 281             *zStr = '\0';
 282         if (*zStr == '\r')
 283             *zStr = '\n';
 284     }
 285     sStr = zStr;
 286     return sStr;
 287 } // end of wxTextCtrl::GetValue
 288
 289 void wxTextCtrl::SetValue(
 290   const wxString&                   rsValue
 291 )
 292 {
 293     //
 294     // If the text is long enough, it's faster to just set it instead of first
 295     // comparing it with the old one (chances are that it will be different
 296     // anyhow, this comparison is there to avoid flicker for small single-line
 297     // edit controls mostly)
 298     //
 299     if ((rsValue.length() > 0x400) || (rsValue != GetValue()))
 300     {
 301         ::WinSetWindowText(GetHwnd(), rsValue.c_str());
 302         AdjustSpaceLimit();
 303     }
 304 } // end of wxTextCtrl::SetValue
 305
 306 void wxTextCtrl::WriteText(
 307   const wxString&                   rsValue
 308 )
 309 {
 310     ::WinSetWindowText(GetHwnd(), rsValue.c_str());
 311     AdjustSpaceLimit();
 312 } // end of wxTextCtrl::WriteText
 313
 314 void wxTextCtrl::AppendText(
 315   const wxString&                   rsText
 316 )
 317 {
 318     SetInsertionPointEnd();
 319     WriteText(rsText);
 320 } // end of wxTextCtrl::AppendText
 321
 322 void wxTextCtrl::Clear()
 323 {
 324     ::WinSetWindowText(GetHwnd(), "");
 325 } // end of wxTextCtrl::Clear
 326
 327 // ----------------------------------------------------------------------------
 328 // Clipboard operations
 329 // ----------------------------------------------------------------------------
 330
 331 void wxTextCtrl::Copy()
 332 {
 333     if (CanCopy())
 334     {
 335         HWND hWnd = GetHwnd();
 336         if (m_bIsMLE)
 337             ::WinSendMsg(hWnd, MLM_COPY, 0, 0);
 338         else
 339             ::WinSendMsg(hWnd, EM_COPY, 0, 0);
 340     }
 341 } // end of wxTextCtrl::Copy
 342
 343 void wxTextCtrl::Cut()
 344 {
 345     if (CanCut())
 346     {
 347         HWND hWnd = GetHwnd();
 348
 349         if (m_bIsMLE)
 350             ::WinSendMsg(hWnd, MLM_CUT, 0, 0);
 351         else
 352             ::WinSendMsg(hWnd, EM_CUT, 0, 0);
 353     }
 354 } // end of wxTextCtrl::Cut
 355
 356 void wxTextCtrl::Paste()
 357 {
 358     if (CanPaste())
 359     {
 360         HWND                        hWnd = GetHwnd();
 361
 362         ::WinSendMsg(hWnd, EM_PASTE, 0, 0);
 363     }
 364 } // end of wxTextCtrl::Paste
 365
 366 bool wxTextCtrl::CanCopy() const
 367 {
 368     //
 369     // Can copy if there's a selection
 370     //
 371     long                            lFrom = 0L;
 372     long                            lTo = 0L;
 373
 374     GetSelection(&lFrom, &lTo);
 375     return (lFrom != lTo);
 376 } // end of wxTextCtrl::CanCopy
 377
 378 bool wxTextCtrl::CanCut() const
 379 {
 380     //
 381     // Can cut if there's a selection
 382     //
 383     long                            lFrom = 0L;
 384     long                            lTo = 0L;
 385
 386     GetSelection(&lFrom, &lTo);
 387     return (lFrom != lTo);
 388 } // end of wxTextCtrl::CanCut
 389
 390 bool wxTextCtrl::CanPaste() const
 391 {
 392     bool                            bIsTextAvailable = FALSE;
 393
 394     if (!IsEditable())
 395         return FALSE;
 396
 397     //
 398     // Check for straight text on clipboard
 399     //
 400     if (::WinOpenClipbrd(vHabmain))
 401     {
 402         bIsTextAvailable = (::WinQueryClipbrdData(vHabmain, CF_TEXT) != 0);
 403         ::WinCloseClipbrd(vHabmain);
 404     }
 405     return bIsTextAvailable;
 406 } // end of wxTextCtrl::CanPaste
 407
 408 // ----------------------------------------------------------------------------
 409 // Accessors
 410 // ----------------------------------------------------------------------------
 411
 412 void wxTextCtrl::SetEditable(
 413   bool                              bEditable
 414 )
 415 {
 416     HWND                            hWnd = GetHwnd();
 417
 418     if (m_bIsMLE)
 419         ::WinSendMsg(hWnd, MLM_SETREADONLY, MPFROMLONG(!bEditable), (MPARAM)0);
 420     else
 421         ::WinSendMsg(hWnd, EM_SETREADONLY, MPFROMLONG(!bEditable), (MPARAM)0);
 422 } // end of wxTextCtrl::SetEditable
 423
 424 void wxTextCtrl::SetInsertionPoint(
 425   long                              lPos
 426 )
 427 {
 428     HWND                            hWnd = GetHwnd();
 429
 430     if (m_bIsMLE)
 431         ::WinSendMsg(hWnd, MLM_SETSEL, (MPARAM)lPos, (MPARAM)lPos);
 432     else
 433         ::WinSendMsg(hWnd, EM_SETSEL, MPFROM2SHORT((USHORT)lPos, (USHORT)lPos), (MPARAM)0);
 434 } // end of wxTextCtrl::SetInsertionPoint
 435
 436 void wxTextCtrl::SetInsertionPointEnd()
 437 {
 438     long                            lPos = GetLastPosition();
 439
 440     SetInsertionPoint(lPos);
 441 } // end of wxTextCtrl::SetInsertionPointEnd
 442
 443 long wxTextCtrl::GetInsertionPoint() const
 444 {
 445     WXDWORD                         dwPos = 0L;
 446
 447     if (m_bIsMLE)
 448         dwPos = (WXDWORD)::WinSendMsg(GetHwnd(), MLM_QUERYSEL, (MPARAM)MLFQS_MINSEL, 0);
 449     else
 450     {
 451         dwPos = (WXDWORD)::WinSendMsg(GetHwnd(), EM_QUERYSEL, 0, 0);
 452         dwPos = SHORT1FROMMP((MPARAM)dwPos);  // the first 16 bit value is the min pos
 453     }
 454     return (dwPos & 0xFFFF);
 455 } // end of wxTextCtrl::GetInsertionPoint
 456
 457 long wxTextCtrl::GetLastPosition() const
 458 {
 459     HWND                            hWnd = GetHwnd();
 460     long                            lCharIndex;
 461     long                            lLineLength;
 462
 463     if (m_bIsMLE)
 464     {
 465         lCharIndex = 0;
 466
 467         //
 468         // This just gets the total text length.  The last will be this value
 469         //
 470         lLineLength = (long)::WinSendMsg(hWnd, MLM_QUERYTEXTLENGTH, 0, 0);
 471     }
 472     else
 473     {
 474         WNDPARAMS                   vParams;
 475
 476         lCharIndex = 0;
 477         vParams.fsStatus = WPM_CCHTEXT;
 478         if (::WinSendMsg( GetHwnd()
 479                          ,WM_QUERYWINDOWPARAMS
 480                          ,&vParams
 481                          ,0
 482                         ))
 483         {
 484             lLineLength = (long)vParams.cchText;
 485         }
 486         else
 487             lLineLength = 0;
 488     }
 489     return(lCharIndex + lLineLength);
 490 } // end of wxTextCtrl::GetLastPosition
 491
 492 // If the return values from and to are the same, there is no
 493 // selection.
 494 void wxTextCtrl::GetSelection(
 495   long*                             plFrom
 496 , long*                             plTo
 497 ) const
 498 {
 499     WXDWORD                         dwPos;
 500
 501     if (m_bIsMLE)
 502         dwPos = (WXDWORD)::WinSendMsg(GetHwnd(), MLM_QUERYSEL, (MPARAM)MLFQS_MINSEL, 0);
 503     else
 504     {
 505         dwPos = (WXDWORD)::WinSendMsg(GetHwnd(), EM_QUERYSEL, 0, 0);
 506     }
 507     *plFrom = SHORT1FROMMP((MPARAM)dwPos);  // the first 16 bit value is the min pos
 508     *plTo = SHORT2FROMMP((MPARAM)dwPos);  // the first 16 bit value is the min pos
 509 } // end of wxTextCtrl::GetSelection
 510
 511 bool wxTextCtrl::IsEditable() const
 512 {
 513     if (m_bIsMLE)
 514         return((bool)LONGFROMMR(::WinSendMsg(GetHwnd(), MLM_QUERYREADONLY, 0, 0)));
 515     else
 516         return((bool)LONGFROMMR(::WinSendMsg(GetHwnd(), EM_QUERYREADONLY, 0, 0)));
 517 } // end of wxTextCtrl::IsEditable
 518
 519 // ----------------------------------------------------------------------------
 520 // Editing
 521 // ----------------------------------------------------------------------------
 522
 523 void wxTextCtrl::Replace(
 524   long                              lFrom
 525 , long                              lTo
 526 , const wxString&                   rsValue
 527 )
 528 {
 529 #if wxUSE_CLIPBOARD
 530     HWND                            hWnd      = GetHwnd();
 531     long                            lFromChar = lFrom;
 532     long                            lToChar   = lTo;
 533
 534     //
 535     // Set selection and remove it
 536     //
 537     if (m_bIsMLE)
 538     {
 539         ::WinSendMsg(hWnd, MLM_SETSEL, MPFROM2SHORT((USHORT)lFrom, (USHORT)lTo), 0);
 540         ::WinSendMsg(hWnd, MLM_CUT, 0, 0);
 541     }
 542     else
 543     {
 544         ::WinSendMsg(hWnd, EM_SETSEL, MPFROM2SHORT((USHORT)lFrom, (USHORT)lTo), 0);
 545         ::WinSendMsg(hWnd, EM_CUT, 0, 0);
 546     }
 547
 548     //
 549     // Now replace with 'value', by pasting.
 550     //
 551     wxSetClipboardData(wxDF_TEXT, (wxObject *) (const wxChar *)rsValue, 0, 0);
 552
 553     // Paste into edit control
 554     if (m_bIsMLE)
 555         ::WinSendMsg(hWnd, MLM_PASTE, (MPARAM)0, (MPARAM)0);
 556     else
 557         ::WinSendMsg(hWnd, EM_PASTE, (MPARAM)0, (MPARAM)0);
 558 #else
 559     wxFAIL_MSG("wxTextCtrl::Replace not implemented if wxUSE_CLIPBOARD is 0.");
 560 #endif
 561 }  // end of wxTextCtrl::Replace
 562
 563 void wxTextCtrl::Remove(
 564   long                              lFrom
 565 , long                              lTo
 566 )
 567 {
 568     HWND                            hWnd      = GetHwnd();
 569     long                            lFromChar = lFrom;
 570     long                            lToChar   = lTo;
 571
 572     if (m_bIsMLE)
 573     {
 574         ::WinSendMsg(hWnd, MLM_SETSEL, MPFROM2SHORT((USHORT)lFrom, (USHORT)lTo), 0);
 575         ::WinSendMsg(hWnd, MLM_CUT, 0, 0);
 576     }
 577     else
 578     {
 579         ::WinSendMsg(hWnd, EM_SETSEL, MPFROM2SHORT((USHORT)lFrom, (USHORT)lTo), 0);
 580         ::WinSendMsg(hWnd, EM_CUT, 0, 0);
 581     }
 582 } // end of wxTextCtrl::Remove
 583
 584 void wxTextCtrl::SetSelection(
 585   long                              lFrom
 586 , long                              lTo
 587 )
 588 {
 589     HWND                            hWnd = GetHwnd();
 590     long                            lFromChar = lFrom;
 591     long                            lToChar = lTo;
 592
 593     //
 594     // If from and to are both -1, it means (in wxWindows) that all text should
 595     // be selected. Translate into Windows convention
 596     //
 597     if ((lFrom == -1L) && (lTo == -1L))
 598     {
 599         lFromChar = 0L;
 600         lToChar   = -1L;
 601     }
 602     if (m_bIsMLE)
 603         ::WinSendMsg(hWnd, MLM_SETSEL, (MPARAM)lFromChar, (MPARAM)lToChar);
 604     else
 605         ::WinSendMsg(hWnd, EM_SETSEL, MPFROM2SHORT((USHORT)lFromChar, (USHORT)lToChar), (MPARAM)0);
 606 } // end of wxTextCtrl::SetSelection
 607
 608 bool wxTextCtrl::LoadFile(
 609   const wxString&                   rsFile
 610 )
 611 {
 612     if ( wxTextCtrlBase::LoadFile(rsFile) )
 613     {
 614         //
 615         // Update the size limit if needed
 616         //
 617         AdjustSpaceLimit();
 618         return TRUE;
 619     }
 620     return FALSE;
 621 } // end of wxTextCtrl::LoadFile
 622
 623 bool wxTextCtrl::IsModified() const
 624 {
 625     bool                            bRc;
 626
 627     if (m_bIsMLE)
 628         bRc = (bool)LONGFROMMR(::WinSendMsg(GetHwnd(), MLM_QUERYCHANGED, 0, 0));
 629     else
 630         bRc = (bool)LONGFROMMR(::WinSendMsg(GetHwnd(), EM_QUERYCHANGED, 0, 0));
 631     return bRc;
 632 } // end of wxTextCtrl::IsModified
 633
 634 //
 635 // Makes 'unmodified'
 636 //
 637 void wxTextCtrl::DiscardEdits()
 638 {
 639     if (m_bIsMLE)
 640         ::WinSendMsg(GetHwnd(), MLM_SETCHANGED, MPFROMLONG(FALSE), 0);
 641     else
 642         //
 643         // EM controls do not have a SETCHANGED but issuing a query should reset it
 644         //
 645         ::WinSendMsg(GetHwnd(), EM_QUERYCHANGED, 0, 0);
 646 } // end of wxTextCtrl::DiscardEdits
 647
 648 int wxTextCtrl::GetNumberOfLines() const
 649 {
 650     int                             nNumLines;
 651
 652     if (m_bIsMLE)
 653         nNumLines = (int)::WinSendMsg(GetHwnd(), MLM_QUERYLINECOUNT, 0, 0);
 654     else
 655         nNumLines = 1;
 656     return nNumLines;
 657 } // end of wxTextCtrl::GetNumberOfLines
 658
 659 long wxTextCtrl::XYToPosition(
 660   long                              lX
 661 , long                              lY
 662 ) const
 663 {
 664     HWND                            hWnd = GetHwnd();
 665     long                            lCharIndex = 0L;
 666     long                            lLen;
 667
 668     if (m_bIsMLE)
 669     {
 670         lLen = (long)::WinSendMsg(GetHwnd(), MLM_QUERYLINELENGTH, 0, 0);
 671         lCharIndex = ((lLen * lY) + lX);
 672     }
 673     else
 674         lCharIndex = lX;
 675     return lCharIndex;
 676 } // end of wxTextCtrl::XYToPosition
 677
 678 bool wxTextCtrl::PositionToXY(
 679   long                              lPos
 680 , long*                             plX
 681 , long*                             plY
 682 ) const
 683 {
 684     HWND                            hWnd = GetHwnd();
 685     long                            nLineNo = -1;
 686     long                            lCharIndex = 0;
 687
 688     if (m_bIsMLE)
 689         nLineNo = (long)::WinSendMsg(hWnd, MLM_LINEFROMCHAR, (MPARAM)lPos, 0);
 690     else
 691         nLineNo = 0;
 692
 693     if (nLineNo == -1)
 694     {
 695         // no such line
 696         return FALSE;
 697     }
 698
 699     //
 700     // This gets the char index for the _beginning_ of this line
 701     //
 702     long                            lLineWidth;
 703
 704     if (m_bIsMLE)
 705     {
 706         lLineWidth = (long)::WinSendMsg(hWnd, MLM_QUERYLINELENGTH, (MPARAM)0, (MPARAM)0);
 707         lCharIndex = (nLineNo + 1) * lLineWidth;
 708     }
 709     else
 710     {
 711         WNDPARAMS                   vParams;
 712
 713         vParams.fsStatus = WPM_CCHTEXT;
 714         if (::WinSendMsg( hWnd
 715                          ,WM_QUERYWINDOWPARAMS
 716                          ,&vParams
 717                          ,0
 718                         ))
 719         {
 720             lCharIndex = vParams.cchText;
 721         }
 722         else
 723             lCharIndex = 32;
 724     }
 725
 726     if (lCharIndex == -1)
 727     {
 728         return FALSE;
 729     }
 730
 731     //
 732     // The X position must therefore be the difference between pos and charIndex
 733     //
 734     if (plX)
 735         *plX = lPos - lCharIndex;
 736     if (plY)
 737         *plY = nLineNo;
 738
 739     return TRUE;
 740 } // end of wxTextCtrl::PositionToXY
 741
 742 void wxTextCtrl::ShowPosition(
 743   long                              lPos
 744 )
 745 {
 746     HWND                            hWnd = GetHwnd();
 747     long                            lCurrentLineLineNo = 0L;
 748
 749     // To scroll to a position, we pass the number of lines and characters
 750     // to scroll *by*. This means that we need to:
 751     // (1) Find the line position of the current line.
 752     // (2) Find the line position of pos.
 753     // (3) Scroll by (pos - current).
 754     // For now, ignore the horizontal scrolling.
 755
 756     //
 757     // Is this where scrolling is relative to - the line containing the caret?
 758     // Or is the first visible line??? Try first visible line.
 759     //
 760     if (m_bIsMLE)
 761     {
 762         //
 763         // In PM this is the actual char position
 764         //
 765         lCurrentLineLineNo = (long)::WinSendMsg(hWnd, MLM_QUERYFIRSTCHAR, (MPARAM)0, (MPARAM)0);
 766
 767         //
 768         // This will cause a scroll to the selected position
 769         //
 770         ::WinSendMsg(hWnd, MLM_SETSEL, (MPARAM)lCurrentLineLineNo, (MPARAM)lCurrentLineLineNo);
 771     }
 772 } // end of wxTextCtrl::ShowPosition
 773
 774 int wxTextCtrl::GetLineLength(
 775   long                              lLineNo
 776 ) const
 777 {
 778     long                            lLen = 0L;
 779
 780     if (m_bIsMLE)
 781         lLen = (long)::WinSendMsg(GetHwnd(), MLM_QUERYLINELENGTH, 0, 0);
 782     else
 783     {
 784         WNDPARAMS                   vParams;
 785
 786         vParams.fsStatus = WPM_CCHTEXT;
 787         if (::WinSendMsg( GetHwnd()
 788                          ,WM_QUERYWINDOWPARAMS
 789                          ,&vParams
 790                          ,0
 791                         ))
 792         {
 793             lLen = vParams.cchText;
 794         }
 795         else
 796             lLen = 32;
 797     }
 798     return lLen;
 799 } // end ofwxTextCtrl::GetLineLength
 800
 801 wxString wxTextCtrl::GetLineText(
 802   long                              lLineNo
 803 ) const
 804 {
 805     long                            lLen = (long)GetLineLength((long)lLineNo) + 1;
 806     wxString                        sStr;
 807     char*                           zBuf;
 808
 809     //
 810     // There must be at least enough place for the length WORD in the
 811     // buffer
 812     //
 813     lLen += sizeof(WORD);
 814     zBuf = new char[lLen];
 815     if (m_bIsMLE)
 816     {
 817         long                        lIndex;
 818         long                        lBuflen;
 819         long                        lCopied;
 820
 821         lLen = (long)::WinSendMsg(GetHwnd(), MLM_QUERYLINELENGTH, 0, 0);
 822         lIndex = lLen * lLineNo;
 823
 824         ::WinSendMsg(GetHwnd(), MLM_SETSEL, (MPARAM)lIndex, (MPARAM)lIndex);
 825         ::WinSendMsg(GetHwnd(), MLM_SETIMPORTEXPORT, MPFROMP(zBuf), MPFROMSHORT((USHORT)sizeof(zBuf)));
 826         lBuflen = (long)::WinSendMsg(GetHwnd(), MLM_QUERYFORMATTEXTLENGTH, MPFROMLONG(lIndex), MPFROMLONG(-1));
 827         lCopied = (long)::WinSendMsg(GetHwnd(), MLM_EXPORT, MPFROMP(&lIndex), MPFROMP(&lBuflen));
 828         zBuf[lCopied] = '\0';
 829     }
 830     else
 831     {
 832         WNDPARAMS                   vParams;
 833
 834         vParams.fsStatus = WPM_CCHTEXT;
 835         if (::WinSendMsg( GetHwnd()
 836                          ,WM_QUERYWINDOWPARAMS
 837                          ,&vParams
 838                          ,0
 839                         ))
 840          memcpy(zBuf, vParams.pszText, vParams.cchText);
 841          zBuf[vParams.cchText] = '\0';
 842      }
 843      sStr = zBuf;
 844      delete [] zBuf;
 845      return sStr;
 846 } // end of wxTextCtrl::GetLineText
 847
 848 // ----------------------------------------------------------------------------
 849 // Undo/redo
 850 // ----------------------------------------------------------------------------
 851
 852 void wxTextCtrl::Undo()
 853 {
 854     if (CanUndo())
 855     {
 856         if (m_bIsMLE)
 857             ::WinSendMsg(GetHwnd(), MLM_UNDO, 0, 0);
 858         // Simple entryfields cannot be undone
 859     }
 860 } // end of wxTextCtrl::Undo
 861
 862 void wxTextCtrl::Redo()
 863 {
 864     if (CanRedo())
 865     {
 866         if (m_bIsMLE)
 867             ::WinSendMsg(GetHwnd(), MLM_UNDO, 0, 0);
 868         // Simple entryfields cannot be undone
 869     }
 870 } // end of wxTextCtrl::Redo
 871
 872 bool wxTextCtrl::CanUndo() const
 873 {
 874     bool                            bOk;
 875
 876     if (m_bIsMLE)
 877         bOk = (::WinSendMsg(GetHwnd(), MLM_QUERYUNDO, 0, 0) != 0);
 878     else
 879         bOk = FALSE; // can't undo regular edit fields in PM
 880     return bOk;
 881 } // end of wxTextCtrl::CanUndo
 882
 883 bool wxTextCtrl::CanRedo() const
 884 {
 885     bool                            bOk;
 886
 887     if (m_bIsMLE)
 888         bOk = (::WinSendMsg(GetHwnd(), MLM_QUERYUNDO, 0, 0) != 0);
 889     else
 890         bOk = FALSE; // can't undo regular edit fields in PM
 891     return bOk;
 892 } // end of wxTextCtrl::CanRedo
 893
 894 // ----------------------------------------------------------------------------
 895 // implemenation details
 896 // ----------------------------------------------------------------------------
 897
 898 void wxTextCtrl::Command(
 899   wxCommandEvent&                   rEvent
 900 )
 901 {
 902     SetValue(rEvent.GetString());
 903     ProcessCommand (rEvent);
 904 } // end of wxTextCtrl::Command
 905
 906 void wxTextCtrl::OnDropFiles(
 907   wxDropFilesEvent&                 rEvent
 908 )
 909 {
 910     // By default, load the first file into the text window.
 911     if (rEvent.GetNumberOfFiles() > 0)
 912     {
 913         LoadFile(rEvent.GetFiles()[0]);
 914     }
 915 } // end of wxTextCtrl::OnDropFiles
 916
 917 WXHBRUSH wxTextCtrl::OnCtlColor(
 918   WXHDC                             hWxDC
 919 , WXHWND                            hWnd
 920 , WXUINT                            uCtlColor
 921 , WXUINT                            uMessage
 922 , WXWPARAM                          wParam
 923 , WXLPARAM                          lParam
 924 )
 925 {
 926     HPS                             hPS = (HPS)hWxDC;
 927     wxBrush*                        pBrush = NULL;
 928     wxColour                        vColBack = GetBackgroundColour();
 929     wxColour                        vColFore = GetForegroundColour();
 930     wxBrush*                        pBackgroundBrush = wxTheBrushList->FindOrCreateBrush( GetBackgroundColour()
 931                                                                                          ,wxSOLID
 932                                                                                         );
 933
 934     if (m_bUseCtl3D)
 935     {
 936         HBRUSH                      hBrush = NULLHANDLE;
 937
 938         return hBrush;
 939     }
 940     if (GetParent()->GetTransparentBackground())
 941         ::GpiSetBackMix(hPS, BM_LEAVEALONE);
 942     else
 943         ::GpiSetBackMix(hPS, BM_OVERPAINT);
 944     if (!IsEnabled() && (GetWindowStyle() & wxTE_MULTILINE) == 0)
 945         vColBack = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE);
 946     ::GpiSetBackColor(hPS, vColBack.GetPixel());
 947     ::GpiSetColor(hPS, vColFore.GetPixel());
 948     return (WXHBRUSH)pBackgroundBrush->GetResourceHandle();
 949 } // end of wxTextCtrl::OnCtlColor
 950
 951 void wxTextCtrl::OnChar(
 952   wxKeyEvent&                       rEvent
 953 )
 954 {
 955     switch (rEvent.KeyCode())
 956     {
 957         case WXK_RETURN:
 958             if ( !(m_windowStyle & wxTE_MULTILINE) )
 959             {
 960                 wxCommandEvent      vEvent(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
 961
 962                 vEvent.SetEventObject(this);
 963                 if ( GetEventHandler()->ProcessEvent(vEvent))
 964                     return;
 965             }
 966             //else: multiline controls need Enter for themselves
 967
 968             break;
 969
 970         case WXK_TAB:
 971             // always produce navigation event - even if we process TAB
 972             // ourselves the fact that we got here means that the user code
 973             // decided to skip processing of this TAB - probably to let it
 974             // do its default job.
 975             //
 976             // NB: Notice that Ctrl-Tab is handled elsewhere and Alt-Tab is
 977             //     handled by Windows
 978             {
 979                 wxNavigationKeyEvent    vEventNav;
 980
 981                 vEventNav.SetDirection(!rEvent.ShiftDown());
 982                 vEventNav.SetWindowChange(FALSE);
 983                 vEventNav.SetEventObject(this);
 984
 985                 if ( GetEventHandler()->ProcessEvent(vEventNav) )
 986                     return;
 987             }
 988             break;
 989     }
 990     rEvent.Skip();
 991 } // end of wxTextCtrl::OnChar
 992
 993 bool wxTextCtrl::OS2Command(
 994   WXUINT                            uParam
 995 , WXWORD                            WXUNUSED(vId)
 996 )
 997 {
 998     switch (uParam)
 999     {
1000         case EN_SETFOCUS:
1001         case EN_KILLFOCUS:
1002             {
1003                 wxFocusEvent        vEvent( uParam == EN_KILLFOCUS ? wxEVT_KILL_FOCUS
1004                                                                    : wxEVT_SET_FOCUS
1005                                            ,m_windowId
1006                                           );
1007
1008                 vEvent.SetEventObject(this);
1009                 GetEventHandler()->ProcessEvent(vEvent);
1010             }
1011             break;
1012
1013         case EN_CHANGE:
1014             {
1015                 wxCommandEvent      vEvent( wxEVT_COMMAND_TEXT_UPDATED
1016                                            ,m_windowId
1017                                           );
1018
1019                 InitCommandEvent(vEvent);
1020                 vEvent.SetString((char*)GetValue().c_str());
1021                 ProcessCommand(vEvent);
1022             }
1023             break;
1024
1025         case EN_OVERFLOW:
1026             //
1027             // The text size limit has been hit - increase it
1028             //
1029             AdjustSpaceLimit();
1030             break;
1031
1032         case EN_SCROLL:
1033         case EN_INSERTMODETOGGLE:
1034         case EN_MEMERROR:
1035             return FALSE;
1036         default:
1037             return FALSE;
1038     }
1039
1040     //
1041     // Processed
1042     //
1043     return TRUE;
1044 } // end of wxTextCtrl::OS2Command
1045
1046 void wxTextCtrl::AdjustSpaceLimit()
1047 {
1048     unsigned int                    uLen = 0;
1049     unsigned int                    uLimit = 0;
1050
1051     uLen   = ::WinQueryWindowTextLength(GetHwnd());
1052     if (m_bIsMLE)
1053     {
1054         uLimit = (unsigned int)::WinSendMsg( GetHwnd()
1055                                             ,MLM_QUERYTEXTLIMIT
1056                                             ,0
1057                                             ,0
1058                                            );
1059     }
1060     else
1061     {
1062         ENTRYFDATA*                 pEfd;
1063         WNDPARAMS                   vParams;
1064
1065         vParams.fsStatus = WPM_CBCTLDATA;
1066         vParams.cbCtlData = sizeof(ENTRYFDATA);
1067
1068         if (::WinSendMsg( GetHwnd()
1069                          ,WM_QUERYWINDOWPARAMS
1070                          ,&vParams
1071                          ,0
1072                         ))
1073         {
1074             pEfd = (ENTRYFDATA*)vParams.pCtlData;
1075             uLimit = (unsigned int)pEfd->cchEditLimit;
1076         }
1077         else
1078             uLimit = 32; //PM's default
1079     }
1080     if (uLen >= uLimit)
1081     {
1082         uLimit = uLen + 0x8000;    // 32Kb
1083         if (uLimit > 0xffff)
1084         {
1085             uLimit = 0L;
1086         }
1087         if (m_bIsMLE)
1088             ::WinSendMsg(GetHwnd(), MLM_SETTEXTLIMIT, MPFROMLONG(uLimit), 0);
1089         else
1090             ::WinSendMsg(GetHwnd(), EM_SETTEXTLIMIT, MPFROMLONG(uLimit), 0);
1091     }
1092 } // end of wxTextCtrl::AdjustSpaceLimit
1093
1094 bool wxTextCtrl::AcceptsFocus() const
1095 {
1096     //
1097     // We don't want focus if we can't be edited
1098     //
1099     return IsEditable() && wxControl::AcceptsFocus();
1100 } // end of wxTextCtrl::Command
1101
1102 wxSize wxTextCtrl::DoGetBestSize() const
1103 {
1104     int                             nCx;
1105     int                             nCy;
1106
1107     wxGetCharSize(GetHWND(), &nCx, &nCy, (wxFont*)&GetFont());
1108
1109     int                             wText = DEFAULT_ITEM_WIDTH;
1110     int                             hText = EDIT_HEIGHT_FROM_CHAR_HEIGHT(nCy);
1111
1112     if (m_windowStyle & wxTE_MULTILINE)
1113     {
1114         hText *= wxMin(GetNumberOfLines(), 5);
1115     }
1116     //else: for single line control everything is ok
1117     return wxSize(wText, hText);
1118 } // end of wxTextCtrl::DoGetBestSize
1119
1120 // ----------------------------------------------------------------------------
1121 // standard handlers for standard edit menu events
1122 // ----------------------------------------------------------------------------
1123
1124 void wxTextCtrl::OnCut(
1125   wxCommandEvent&                   rEvent
1126 )
1127 {
1128     Cut();
1129 } // end of wxTextCtrl::OnCut
1130
1131 void wxTextCtrl::OnCopy(
1132   wxCommandEvent&                   rEvent
1133 )
1134 {
1135     Copy();
1136 } // end of wxTextCtrl::OnCopy
1137
1138 void wxTextCtrl::OnPaste(
1139   wxCommandEvent&                   rEvent
1140 )
1141 {
1142     Paste();
1143 } // end of wxTextCtrl::OnPaste
1144
1145 void wxTextCtrl::OnUndo(
1146   wxCommandEvent&                   rEvent
1147 )
1148 {
1149     Undo();
1150 } // end of wxTextCtrl::OnUndo
1151
1152 void wxTextCtrl::OnRedo(
1153   wxCommandEvent&                   rEvent
1154 )
1155 {
1156     Redo();
1157 } // end of wxTextCtrl::OnRedo
1158
1159 void wxTextCtrl::OnUpdateCut(
1160   wxUpdateUIEvent&                  rEvent
1161 )
1162 {
1163     rEvent.Enable(CanCut());
1164 } // end of wxTextCtrl::OnUpdateCut
1165
1166 void wxTextCtrl::OnUpdateCopy(
1167   wxUpdateUIEvent&                  rEvent
1168 )
1169 {
1170     rEvent.Enable(CanCopy());
1171 } // end of wxTextCtrl::OnUpdateCopy
1172
1173 void wxTextCtrl::OnUpdatePaste(
1174   wxUpdateUIEvent&                  rEvent
1175 )
1176 {
1177     rEvent.Enable(CanPaste());
1178 } // end of wxTextCtrl::OnUpdatePaste
1179
1180 void wxTextCtrl::OnUpdateUndo(
1181   wxUpdateUIEvent&                  rEvent
1182 )
1183 {
1184     rEvent.Enable(CanUndo());
1185 } // end of wxTextCtrl::OnUpdateUndo
1186
1187 void wxTextCtrl::OnUpdateRedo(
1188   wxUpdateUIEvent&                  rEvent
1189 )
1190 {
1191     rEvent.Enable(CanRedo());
1192 } // end of wxTextCtrl::OnUpdateRedo
1193
1194 bool wxTextCtrl::SetBackgroundColour(
1195   const wxColour&                   rColour
1196 )
1197 {
1198     if (m_bIsMLE)
1199         ::WinSendMsg(GetHwnd(), MLM_SETBACKCOLOR, (MPARAM)rColour.GetPixel(), MLE_INDEX);
1200     return TRUE;
1201 } // end of wxTextCtrl::SetBackgroundColour
1202
1203 bool wxTextCtrl::SetForegroundColour(
1204   const wxColour&                   rColour
1205 )
1206 {
1207     if (m_bIsMLE)
1208         ::WinSendMsg(GetHwnd(), MLM_SETTEXTCOLOR, (MPARAM)rColour.GetPixel(), MLE_INDEX);
1209     return TRUE;
1210 } // end of wxTextCtrl::SetForegroundColour
1211