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