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