src/x11/textctrl.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        textctrl.cpp
   3 // Purpose:
   4 // Author:      Robert Roebling
   5 // Id:          $Id$
   6 // Copyright:   (c) 1998 Robert Roebling
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 #ifdef __GNUG__
  11 #pragma implementation "textctrl.h"
  12 #endif
  13
  14 #include "wx/textctrl.h"
  15 #include "wx/utils.h"
  16 #include "wx/intl.h"
  17 #include "wx/log.h"
  18 #include "wx/settings.h"
  19 #include "wx/panel.h"
  20 #include "wx/clipbrd.h"
  21 #include "wx/tokenzr.h"
  22
  23 #include "wx/univ/inphand.h"
  24 #include "wx/univ/renderer.h"
  25 #include "wx/univ/colschem.h"
  26 #include "wx/univ/theme.h"
  27
  28 //-----------------------------------------------------------------------------
  29 //  helpers
  30 //-----------------------------------------------------------------------------
  31
  32 wxSourceUndoStep::wxSourceUndoStep( wxSourceUndo type, int y1, int y2, wxTextCtrl *owner )
  33 {
  34     m_type = type;
  35     m_y1 = y1;
  36     m_y2 = y2;
  37     m_owner = owner;
  38
  39     m_cursorX = m_owner->GetCursorX();
  40     m_cursorY = m_owner->GetCursorY();
  41
  42     if (m_type == wxSOURCE_UNDO_LINE)
  43     {
  44         m_text = m_owner->m_lines[m_y1].m_text;
  45     } else
  46     if (m_type == wxSOURCE_UNDO_ENTER)
  47     {
  48         m_text = m_owner->m_lines[m_y1].m_text;
  49     } else
  50     if (m_type == wxSOURCE_UNDO_BACK)
  51     {
  52         for (int i = m_y1; i < m_y2+2; i++)
  53         {
  54             if (i >= (int)m_owner->m_lines.GetCount())
  55                 m_lines.Add( "" );
  56             else
  57                 m_lines.Add( m_owner->m_lines[i].m_text );
  58         }
  59     } else
  60     if (m_type == wxSOURCE_UNDO_DELETE)
  61     {
  62         for (int i = m_y1; i < m_y2+1; i++)
  63         {
  64             m_lines.Add( m_owner->m_lines[i].m_text );
  65         }
  66     } else
  67     if (m_type == wxSOURCE_UNDO_PASTE)
  68     {
  69         m_text = m_owner->m_lines[m_y1].m_text;
  70     }
  71 }
  72
  73 void wxSourceUndoStep::Undo()
  74 {
  75     if (m_type == wxSOURCE_UNDO_LINE)
  76     {
  77         m_owner->m_lines[m_y1].m_text = m_text;
  78         m_owner->MoveCursor( m_cursorX, m_cursorY );
  79         m_owner->RefreshLine( m_y1 );
  80     } else
  81     if (m_type == wxSOURCE_UNDO_ENTER)
  82     {
  83         m_owner->m_lines[m_y1].m_text = m_text;
  84         m_owner->m_lines.RemoveAt( m_y1+1 );
  85         m_owner->MoveCursor( m_cursorX, m_cursorY );
  86         m_owner->RefreshDown( m_y1 );
  87     } else
  88     if (m_type == wxSOURCE_UNDO_BACK)
  89     {
  90         m_owner->m_lines[m_y1].m_text = m_lines[0];
  91         m_owner->m_lines.Insert( new wxSourceLine( m_lines[1] ), m_y1+1 );
  92         m_owner->MyAdjustScrollbars();
  93         m_owner->MoveCursor( m_cursorX, m_cursorY );
  94         m_owner->RefreshDown( m_y1 );
  95     } else
  96     if (m_type == wxSOURCE_UNDO_DELETE)
  97     {
  98         m_owner->m_lines[m_y1].m_text = m_lines[0];
  99         for (int i = 1; i < (int)m_lines.GetCount(); i++)
 100             m_owner->m_lines.Insert( new wxSourceLine( m_lines[i] ), m_y1+i );
 101         m_owner->MyAdjustScrollbars();
 102         m_owner->MoveCursor( m_cursorX, m_cursorY );
 103         m_owner->RefreshDown( m_y1 );
 104     } else
 105     if (m_type == wxSOURCE_UNDO_PASTE)
 106     {
 107         m_owner->m_lines[m_y1].m_text = m_text;
 108         for (int i = 0; i < m_y2-m_y1; i++)
 109             m_owner->m_lines.RemoveAt( m_y1+1 );
 110         m_owner->MyAdjustScrollbars();
 111         m_owner->MoveCursor( m_cursorX, m_cursorY );
 112         m_owner->RefreshDown( m_y1 );
 113     } else
 114     if (m_type == wxSOURCE_UNDO_INSERT_LINE)
 115     {
 116         m_owner->m_lines.RemoveAt( m_y1 );
 117         m_owner->MyAdjustScrollbars();
 118         m_owner->MoveCursor( 0, m_y1 );
 119         m_owner->RefreshDown( m_y1 );
 120     }
 121 }
 122
 123 #include "wx/arrimpl.cpp"
 124 WX_DEFINE_OBJARRAY(wxSourceLineArray);
 125
 126 //-----------------------------------------------------------------------------
 127 //  wxTextCtrl
 128 //-----------------------------------------------------------------------------
 129
 130 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl,wxControl)
 131
 132 BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
 133     EVT_PAINT(wxTextCtrl::OnPaint)
 134     EVT_ERASE_BACKGROUND(wxTextCtrl::OnEraseBackground)
 135     EVT_CHAR(wxTextCtrl::OnChar)
 136     EVT_MOUSE_EVENTS(wxTextCtrl::OnMouse)
 137     EVT_IDLE(wxTextCtrl::OnIdle)
 138     EVT_KILL_FOCUS(wxTextCtrl::OnKillFocus)
 139     EVT_SET_FOCUS(wxTextCtrl::OnSetFocus)
 140
 141     EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
 142     EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
 143     EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
 144     EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
 145     EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
 146
 147     EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
 148     EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
 149     EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
 150     EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
 151     EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
 152 END_EVENT_TABLE()
 153
 154 void wxTextCtrl::Init()
 155 {
 156     m_editable = TRUE;
 157     m_modified = FALSE;
 158
 159     m_undos.DeleteContents( TRUE );
 160
 161     m_lang = wxSOURCE_LANG_NONE;
 162
 163     m_capturing = FALSE;
 164
 165     m_cursorX = 0;
 166     m_cursorY = 0;
 167
 168     m_longestLine = 0;
 169
 170     m_bracketX = -1;
 171     m_bracketY = -1;
 172
 173     m_overwrite = FALSE;
 174     m_ignoreInput = FALSE;
 175
 176     ClearSelection();
 177
 178     m_keywordColour = wxColour( 10, 140, 10 );
 179
 180     m_defineColour = *wxRED;
 181
 182     m_variableColour = wxColour( 50, 120, 150 );
 183
 184     m_commentColour = wxColour( 130, 130, 130 );
 185
 186     m_stringColour = wxColour( 10, 140, 10 );
 187 }
 188
 189 wxTextCtrl::wxTextCtrl( wxWindow *parent,
 190                         wxWindowID id,
 191                         const wxString &value,
 192                         const wxPoint &pos,
 193                         const wxSize &size,
 194                         long style,
 195                         const wxValidator& validator,
 196                         const wxString &name )
 197     : wxScrollHelper(this)
 198 {
 199     Init();
 200
 201     Create( parent, id, value, pos, size, style, validator, name );
 202 }
 203
 204 bool wxTextCtrl::Create( wxWindow *parent,
 205                          wxWindowID id,
 206                          const wxString &value,
 207                          const wxPoint &pos,
 208                          const wxSize &size,
 209                          long style,
 210                          const wxValidator& validator,
 211                          const wxString &name )
 212 {
 213     if ((style & wxBORDER_MASK) == 0)
 214         style |= wxBORDER_SUNKEN;
 215
 216     if ((style & wxTE_MULTILINE) != 0)
 217         style |= wxALWAYS_SHOW_SB;
 218
 219     wxTextCtrlBase::Create( parent, id, pos /* wxDefaultPosition */, size,
 220                               style|wxVSCROLL|wxHSCROLL|wxNO_FULL_REPAINT_ON_RESIZE );
 221
 222     SetBackgroundColour( *wxWHITE );
 223
 224     SetCursor( wxCursor( wxCURSOR_IBEAM ) );
 225
 226     m_editable = ((m_windowStyle & wxTE_READONLY) == 0);
 227
 228     if (HasFlag(wxTE_PASSWORD))
 229         m_sourceFont = wxFont( 12, wxMODERN, wxNORMAL, wxNORMAL );
 230     else
 231         m_sourceFont = GetFont();
 232
 233     wxClientDC dc(this);
 234     dc.SetFont( m_sourceFont );
 235     m_lineHeight = dc.GetCharHeight();
 236     m_charWidth = dc.GetCharWidth();
 237
 238     SetValue( value );
 239
 240     wxSize size_best( DoGetBestSize() );
 241     wxSize new_size( size );
 242     if (new_size.x == -1)
 243         new_size.x = size_best.x;
 244     if (new_size.y == -1)
 245         new_size.y = size_best.y;
 246     if ((new_size.x != size.x) || (new_size.y != size.y))
 247         SetSize( new_size.x, new_size.y );
 248
 249     // We create an input handler since it might be useful
 250     CreateInputHandler(wxINP_HANDLER_TEXTCTRL);
 251
 252     MyAdjustScrollbars();
 253
 254     return TRUE;
 255 }
 256
 257 //-----------------------------------------------------------------------------
 258 //  public methods
 259 //-----------------------------------------------------------------------------
 260
 261 wxString wxTextCtrl::GetValue() const
 262 {
 263     wxString ret;
 264     for (size_t i = 0; i < m_lines.GetCount(); i++)
 265     {
 266         ret += m_lines[i].m_text;
 267         if (i+1 < m_lines.GetCount())
 268             ret += wxT('\n');
 269     }
 270
 271     return ret;
 272 }
 273
 274 void wxTextCtrl::SetValue(const wxString& value)
 275 {
 276     m_modified = FALSE;
 277
 278     wxString oldValue = GetValue();
 279
 280     m_cursorX = 0;
 281     m_cursorY = 0;
 282     ClearSelection();
 283     m_lines.Clear();
 284     m_longestLine = 0;
 285
 286     if (value.IsEmpty())
 287     {
 288         m_lines.Add( new wxSourceLine( wxT("") ) );
 289     }
 290     else
 291     {
 292         int begin = 0;
 293         int pos = 0;
 294         for (;;)
 295         {
 296             pos = value.find( wxT('\n'), begin );
 297             if (pos < 0)
 298             {
 299                 wxSourceLine *sl = new wxSourceLine( value.Mid( begin, value.Len()-begin ) );
 300                 m_lines.Add( sl );
 301
 302                 // if (sl->m_text.Len() > m_longestLine)
 303                 //    m_longestLine = sl->m_text.Len();
 304                 int ww = 0;
 305                 GetTextExtent( sl->m_text, &ww, NULL, NULL, NULL );
 306                 ww /= m_charWidth;
 307                 if (ww > m_longestLine)
 308                     m_longestLine = ww;
 309
 310                 break;
 311             }
 312             else
 313             {
 314                 wxSourceLine *sl = new wxSourceLine( value.Mid( begin, pos-begin ) );
 315                 m_lines.Add( sl );
 316
 317                 // if (sl->m_text.Len() > m_longestLine)
 318                 //      m_longestLine = sl->m_text.Len();
 319                 int ww = 0;
 320                 GetTextExtent( sl->m_text, &ww, NULL, NULL, NULL );
 321                 ww /= m_charWidth;
 322                 if (ww > m_longestLine)
 323                     m_longestLine = ww;
 324
 325                 begin = pos+1;
 326             }
 327         }
 328     }
 329
 330     // Don't need to refresh if the value hasn't changed
 331     if ((GetWindowStyle() & wxTE_MULTILINE) == 0)
 332     {
 333         if (value == oldValue)
 334             return;
 335     }
 336
 337     MyAdjustScrollbars();
 338
 339     Refresh();
 340 }
 341
 342 int wxTextCtrl::GetLineLength(long lineNo) const
 343 {
 344     if (lineNo >= (long)m_lines.GetCount())
 345         return 0;
 346
 347     return m_lines[lineNo].m_text.Len();
 348 }
 349
 350 wxString wxTextCtrl::GetLineText(long lineNo) const
 351 {
 352     if (lineNo >= (long)m_lines.GetCount())
 353         return wxT("");
 354
 355     return m_lines[lineNo].m_text;
 356 }
 357
 358 int wxTextCtrl::GetNumberOfLines() const
 359 {
 360     return  m_lines.GetCount();
 361 }
 362
 363 bool wxTextCtrl::IsModified() const
 364 {
 365     return m_modified;
 366 }
 367
 368 bool wxTextCtrl::IsEditable() const
 369 {
 370     return m_editable;
 371 }
 372
 373 void wxTextCtrl::GetSelection(long* from, long* to) const
 374 {
 375 }
 376
 377 void wxTextCtrl::Clear()
 378 {
 379     m_modified = TRUE;
 380     m_cursorX = 0;
 381     m_cursorY = 0;
 382     ClearSelection();
 383
 384     m_lines.Clear();
 385     m_lines.Add( new wxSourceLine( wxT("") ) );
 386
 387     SetScrollbars( m_charWidth, m_lineHeight, 0, 0, 0, 0 );
 388     Refresh();
 389     m_undos.Clear();
 390 }
 391
 392 void wxTextCtrl::Replace(long from, long to, const wxString& value)
 393 {
 394 }
 395
 396 void wxTextCtrl::Remove(long from, long to)
 397 {
 398
 399 }
 400
 401 void wxTextCtrl::DiscardEdits()
 402 {
 403     ClearSelection();
 404     Refresh();
 405 }
 406
 407 void wxTextCtrl::SetMaxLength(unsigned long len)
 408 {
 409 }
 410
 411 int wxTextCtrl::PosToPixel( int line, int pos )
 412 {
 413     // TODO add support for Tabs
 414
 415     if (line >= (int)m_lines.GetCount()) return 0;
 416     if (pos < 0) return 0;
 417
 418     wxString text = m_lines[line].m_text;
 419
 420     if (text.IsEmpty()) return 0;
 421
 422     if (pos < (int)text.Len())
 423         text.Remove( pos, text.Len()-pos );
 424
 425     int w = 0;
 426
 427     GetTextExtent( text, &w, NULL, NULL, NULL );
 428
 429     return w;
 430 }
 431
 432 int wxTextCtrl::PixelToPos( int line, int pixel )
 433 {
 434     if (pixel < 2) return 0;
 435
 436     if (line >= (int)m_lines.GetCount()) return 0;
 437
 438     wxString text = m_lines[line].m_text;
 439
 440     int w = 0;
 441     int res = text.Len();
 442     while (res > 0)
 443     {
 444         GetTextExtent( text, &w, NULL, NULL, NULL );
 445
 446         if (w < pixel)
 447             return res;
 448
 449         res--;
 450         text.Remove( res,1 );
 451     }
 452
 453     return 0;
 454 }
 455
 456 void wxTextCtrl::SetLanguage( wxSourceLanguage lang )
 457 {
 458     m_lang = lang;
 459
 460     m_keywords.Clear();
 461
 462     if (m_lang == wxSOURCE_LANG_PYTHON)
 463     {
 464         m_keywords.Add( "class" );
 465         m_keywords.Add( "__init__" );
 466         m_keywords.Add( "return" );
 467         m_keywords.Add( "def" );
 468         m_keywords.Add( "try" );
 469         m_keywords.Add( "except" );
 470         m_keywords.Add( "if" );
 471         m_keywords.Add( "else" );
 472         m_keywords.Add( "finally" );
 473         m_keywords.Add( "for" );
 474         m_keywords.Add( "if" );
 475         m_keywords.Add( "elif" );
 476         m_keywords.Add( "in" );
 477         m_keywords.Add( "and" );
 478         m_keywords.Add( "del" );
 479         m_keywords.Add( "is" );
 480         m_keywords.Add( "raise" );
 481         m_keywords.Add( "assert" );
 482         m_keywords.Add( "lambda" );
 483         m_keywords.Add( "break" );
 484         m_keywords.Add( "global" );
 485         m_keywords.Add( "not" );
 486         m_keywords.Add( "or" );
 487         m_keywords.Add( "while" );
 488         m_keywords.Add( "continue" );
 489         m_keywords.Add( "exec" );
 490         m_keywords.Add( "pass" );
 491         m_keywords.Add( "print" );
 492     } else
 493     if (m_lang == wxSOURCE_LANG_PERL)
 494     {
 495         m_keywords.Add( "main" );
 496         m_keywords.Add( "sub" );
 497         m_keywords.Add( "shift" );
 498         m_keywords.Add( "push" );
 499         m_keywords.Add( "split" );
 500         m_keywords.Add( "join" );
 501         m_keywords.Add( "chop" );
 502         m_keywords.Add( "grep" );
 503         m_keywords.Add( "open" );
 504         m_keywords.Add( "print" );
 505         m_keywords.Add( "sprint" );
 506         m_keywords.Add( "printf" );
 507         m_keywords.Add( "sprintf" );
 508         m_keywords.Add( "my" );
 509         m_keywords.Add( "local" );
 510         m_keywords.Add( "exit" );
 511         m_keywords.Add( "die" );
 512         m_keywords.Add( "return" );
 513         m_keywords.Add( "for" );
 514         m_keywords.Add( "foreach" );
 515         m_keywords.Add( "while" );
 516         m_keywords.Add( "unless" );
 517         m_keywords.Add( "if" );
 518         m_keywords.Add( "next" );
 519         m_keywords.Add( "last" );
 520         m_keywords.Add( "else" );
 521         m_keywords.Add( "elsif" );
 522         m_keywords.Add( "ne" );
 523         m_keywords.Add( "qe" );
 524     }
 525     else
 526     if (m_lang == wxSOURCE_LANG_CPP)
 527     {
 528         m_keywords.Add( "class" );
 529         m_keywords.Add( "return" );
 530         m_keywords.Add( "if" );
 531         m_keywords.Add( "then" );
 532         m_keywords.Add( "else" );
 533         m_keywords.Add( "struct" );
 534         m_keywords.Add( "enum" );
 535         m_keywords.Add( "while" );
 536         m_keywords.Add( "do" );
 537         m_keywords.Add( "for" );
 538         m_keywords.Add( "continue" );
 539         m_keywords.Add( "break" );
 540         m_keywords.Add( "switch" );
 541         m_keywords.Add( "case" );
 542         m_keywords.Add( "goto" );
 543         m_keywords.Add( "label" );
 544         m_keywords.Add( "inline" );
 545         m_keywords.Add( "operator" );
 546         m_keywords.Add( "virtual" );
 547         m_keywords.Add( "private" );
 548         m_keywords.Add( "public" );
 549         m_keywords.Add( "protected" );
 550         m_keywords.Add( "friend" );
 551         m_keywords.Add( "exception" );
 552         m_keywords.Add( "throw" );
 553         m_keywords.Add( "catch" );
 554         m_keywords.Add( "delete" );
 555         m_keywords.Add( "new" );
 556         m_keywords.Add( "default" );
 557         m_keywords.Add( "overload" );
 558         m_keywords.Add( "using" );
 559         m_keywords.Add( "template" );
 560         m_keywords.Add( "try" );
 561         m_keywords.Add( "typedef" );
 562         m_keywords.Add( "union" );
 563         m_keywords.Add( "volatile" );
 564         m_keywords.Add( "asm" );
 565     }
 566
 567     m_defines.Clear();
 568
 569     if (m_lang == wxSOURCE_LANG_PYTHON)
 570     {
 571         m_defines.Add( "from" );
 572         m_defines.Add( "import" );
 573     } else
 574     if (m_lang == wxSOURCE_LANG_PERL)
 575     {
 576         m_defines.Add( "use" );
 577         m_defines.Add( "do" );
 578         m_defines.Add( "package" );
 579         m_defines.Add( "defined" );
 580     } else
 581     if (m_lang == wxSOURCE_LANG_CPP)
 582     {
 583         m_defines.Add( "#define" );
 584         m_defines.Add( "#if" );
 585         m_defines.Add( "#ifndef" );
 586         m_defines.Add( "#ifdef" );
 587         m_defines.Add( "#else" );
 588         m_defines.Add( "#elif" );
 589         m_defines.Add( "#endif" );
 590         m_defines.Add( "#pragma" );
 591         m_defines.Add( "#include" );
 592     }
 593
 594     m_variables.Clear();
 595
 596     if (m_lang == wxSOURCE_LANG_PYTHON)
 597     {
 598         m_variables.Add( "nil" );
 599         m_variables.Add( "None" );
 600         m_variables.Add( "self" );
 601         m_variables.Add( "false" );
 602         m_variables.Add( "true" );
 603     } else
 604     if (m_lang == wxSOURCE_LANG_PERL)
 605     {
 606         m_variables.Add( "undef" );
 607         m_variables.Add( "class" );
 608         m_variables.Add( "this" );
 609         m_variables.Add( "IN" );
 610         m_variables.Add( "OUT" );
 611         m_variables.Add( "STDIN" );
 612         m_variables.Add( "STDOUT" );
 613         m_variables.Add( "STDERR" );
 614     } else
 615     if (m_lang == wxSOURCE_LANG_CPP)
 616     {
 617         m_variables.Add( "int" );
 618         m_variables.Add( "bool" );
 619         m_variables.Add( "void" );
 620         m_variables.Add( "long" );
 621         m_variables.Add( "short" );
 622         m_variables.Add( "const" );
 623         m_variables.Add( "signed" );
 624         m_variables.Add( "unsigned" );
 625         m_variables.Add( "char" );
 626         m_variables.Add( "size_t" );
 627         m_variables.Add( "wchar_t" );
 628         m_variables.Add( "NULL" );
 629         m_variables.Add( "this" );
 630         m_variables.Add( "TRUE" );
 631         m_variables.Add( "FALSE" );
 632         m_variables.Add( "float" );
 633         m_variables.Add( "double" );
 634         m_variables.Add( "register" );
 635         m_variables.Add( "extern" );
 636         m_variables.Add( "static" );
 637         m_variables.Add( "sizeof" );
 638     }
 639 }
 640
 641 void wxTextCtrl::WriteText(const wxString& text2)
 642 {
 643     if (text2.IsEmpty()) return;
 644
 645     m_modified = TRUE;
 646
 647     wxString text( text2 );
 648     wxArrayString lines;
 649     int pos;
 650     while ( (pos = text.Find('\n')) != -1 )
 651     {
 652        lines.Add( text.Left( pos ) );
 653        text.Remove( 0, pos+1 );
 654     }
 655     lines.Add( text );
 656     int count = (int)lines.GetCount();
 657
 658     wxString tmp1( m_lines[m_cursorY].m_text );
 659     wxString tmp2( tmp1 );
 660     int len = (int)tmp1.Len();
 661
 662     if (len < m_cursorX)
 663     {
 664         wxString tmp;
 665         for (int i = 0; i < m_cursorX-len; i++)
 666             tmp.Append( ' ' );
 667         m_lines[m_cursorY].m_text.Append( tmp );
 668         tmp1.Append( tmp );
 669         tmp2.Append( tmp );
 670     }
 671
 672     tmp1.Remove( m_cursorX );
 673     tmp2.Remove( 0, m_cursorX );
 674     tmp1.Append( lines[0] );
 675
 676     if (count == 1)
 677     {
 678         m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_LINE, m_cursorY, m_cursorY, this ) );
 679
 680         tmp1.Append( tmp2 );
 681         m_lines[m_cursorY].m_text = tmp1;
 682         RefreshLine( m_cursorY );
 683     }
 684     else
 685     {
 686         m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_PASTE, m_cursorY, m_cursorY+count-1, this ) );
 687
 688         m_lines[m_cursorY].m_text = tmp1;
 689         int i;
 690         for (i = 1; i < count; i++)
 691             m_lines.Insert( new wxSourceLine( lines[i] ), m_cursorY+i );
 692         m_lines[m_cursorY+i-1].m_text.Append( tmp2 );
 693
 694         MyAdjustScrollbars();
 695         RefreshDown( m_cursorY );
 696     }
 697 }
 698
 699 void wxTextCtrl::AppendText(const wxString& text2)
 700 {
 701     if (text2.IsEmpty()) return;
 702
 703     m_modified = TRUE;
 704
 705     wxString text( text2 );
 706     wxArrayString lines;
 707     int pos;
 708     while ( (pos = text.Find('\n')) != -1 )
 709     {
 710        lines.Add( text.Left( pos ) );
 711        text.Remove( 0, pos+1 );
 712     }
 713     lines.Add( text );
 714     int count = (int)lines.GetCount();
 715
 716     size_t y = m_lines.GetCount()-1;
 717
 718     wxString tmp( m_lines[y].m_text );
 719     tmp.Append( lines[0] );
 720
 721     if (count == 1)
 722     {
 723         m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_LINE, y, y, this ) );
 724
 725         m_lines[y].m_text = tmp;
 726         RefreshLine( y );
 727     }
 728     else
 729     {
 730         m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_PASTE, y, y+count-1, this ) );
 731
 732         m_lines[y].m_text = tmp;
 733         int i;
 734         for (i = 1; i < count; i++)
 735             m_lines.Insert( new wxSourceLine( lines[i] ), y+i );
 736
 737         MyAdjustScrollbars();
 738         RefreshDown( y );
 739     }
 740 }
 741
 742 bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style)
 743 {
 744     return FALSE;
 745 }
 746
 747 long wxTextCtrl::XYToPosition(long x, long y) const
 748 {
 749     long ret = 0;
 750
 751     for (size_t i = 0; i < m_lines.GetCount(); i++)
 752     {
 753         if (i < (size_t)y)
 754         {
 755             ret += m_lines[i].m_text.Len();
 756             continue;
 757         }
 758
 759         if ((size_t)x < m_lines[i].m_text.Len())
 760             return (ret + x);
 761         else
 762             return (ret + m_lines[i].m_text.Len());
 763     }
 764
 765     return ret;
 766 }
 767
 768 bool wxTextCtrl::PositionToXY(long pos, long *x, long *y) const
 769 {
 770     if (m_lines.GetCount() == 0)
 771     {
 772         if (x) *x = 0;
 773         if (y) *y = 0;
 774
 775         return (pos == 0);
 776     }
 777
 778     long xx = 0;
 779     long yy = 0;
 780
 781     for (size_t i = 0; i < m_lines.GetCount(); i++)
 782     {
 783         pos -= m_lines[i].m_text.Len();
 784         if (pos <= 0)
 785         {
 786             xx = -pos;
 787             if (x) *x = xx;
 788             if (y) *y = yy;
 789             return TRUE;
 790         }
 791         yy++;
 792     }
 793
 794     // Last pos
 795     xx = m_lines[ m_lines.GetCount()-1 ].m_text.Len();
 796     if (x) *x = xx;
 797     if (y) *y = yy;
 798
 799     return FALSE;
 800 }
 801
 802 void wxTextCtrl::ShowPosition(long pos)
 803 {
 804 }
 805
 806 void wxTextCtrl::Copy()
 807 {
 808     if (!HasSelection()) return;
 809
 810     wxString sel;
 811
 812     int selStartY = m_selStartY;
 813     int selEndY = m_selEndY;
 814     int selStartX = m_selStartX;
 815     int selEndX = m_selEndX;
 816
 817     if ((selStartY > selEndY) ||
 818         ((selStartY == selEndY) && (selStartX > selEndX)))
 819     {
 820         int tmp = selStartX;
 821         selStartX = selEndX;
 822         selEndX = tmp;
 823         tmp = selStartY;
 824         selStartY = selEndY;
 825         selEndY = tmp;
 826     }
 827
 828     if (selStartY == selEndY)
 829     {
 830         sel = m_lines[selStartY].m_text;
 831
 832         if (selStartX >= (int)sel.Len()) return;
 833         if (selEndX > (int)sel.Len())
 834             selEndX = sel.Len();
 835
 836         sel.Remove( selEndX, sel.Len()-selEndX );
 837         sel.Remove( 0, selStartX );
 838     }
 839     else
 840     {
 841         wxString tmp( m_lines[selStartY].m_text );
 842
 843         if (selStartX < (int)tmp.Len())
 844         {
 845             tmp.Remove( 0, selStartX );
 846             sel = tmp;
 847             sel.Append( "\n" );
 848         }
 849         for (int i = selStartY+1; i < selEndY; i++)
 850         {
 851             sel.Append( m_lines[i].m_text );
 852             sel.Append( "\n" );
 853         }
 854         tmp = m_lines[selEndY].m_text;
 855         if (selEndX > (int)tmp.Len())
 856             selEndX = tmp.Len();
 857         if (selEndX > 0)
 858         {
 859             tmp.Remove( selEndX, tmp.Len()-selEndX );
 860             sel.Append( tmp );
 861         }
 862     }
 863
 864     if (wxTheClipboard->Open())
 865     {
 866         wxTheClipboard->SetData( new wxTextDataObject( sel ) );
 867         wxTheClipboard->Close();
 868     }
 869 }
 870
 871 void wxTextCtrl::Cut()
 872 {
 873    Copy();
 874
 875    Delete();
 876 }
 877
 878 void wxTextCtrl::Paste()
 879 {
 880     Delete();
 881
 882     if (!wxTheClipboard->Open()) return;
 883
 884     if (!wxTheClipboard->IsSupported( wxDF_TEXT ))
 885     {
 886         wxTheClipboard->Close();
 887
 888         return;
 889     }
 890
 891     wxTextDataObject data;
 892
 893     bool ret = wxTheClipboard->GetData( data );
 894
 895     wxTheClipboard->Close();
 896
 897     if (!ret) return;
 898
 899     m_modified = TRUE;
 900
 901     wxString text( data.GetText() );
 902     wxArrayString lines;
 903     int pos;
 904     while ( (pos = text.Find('\n')) != -1 )
 905     {
 906        lines.Add( text.Left( pos ) );
 907        text.Remove( 0, pos+1 );
 908     }
 909     lines.Add( text );
 910     int count = (int)lines.GetCount();
 911
 912     wxString tmp1( m_lines[m_cursorY].m_text );
 913     wxString tmp2( tmp1 );
 914     int len = (int)tmp1.Len();
 915
 916     if (len < m_cursorX)
 917     {
 918         wxString tmp;
 919         for (int i = 0; i < m_cursorX-len; i++)
 920             tmp.Append( ' ' );
 921         m_lines[m_cursorY].m_text.Append( tmp );
 922         tmp1.Append( tmp );
 923         tmp2.Append( tmp );
 924     }
 925
 926     tmp1.Remove( m_cursorX );
 927     tmp2.Remove( 0, m_cursorX );
 928     tmp1.Append( lines[0] );
 929
 930     if (count == 1)
 931     {
 932         m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_LINE, m_cursorY, m_cursorY, this ) );
 933
 934         tmp1.Append( tmp2 );
 935         m_lines[m_cursorY].m_text = tmp1;
 936         RefreshLine( m_cursorY );
 937     }
 938     else
 939     {
 940         m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_PASTE, m_cursorY, m_cursorY+count-1, this ) );
 941
 942         m_lines[m_cursorY].m_text = tmp1;
 943         int i;
 944         for (i = 1; i < count; i++)
 945             m_lines.Insert( new wxSourceLine( lines[i] ), m_cursorY+i );
 946         m_lines[m_cursorY+i-1].m_text.Append( tmp2 );
 947
 948         MyAdjustScrollbars();
 949         RefreshDown( m_cursorY );
 950     }
 951 }
 952
 953 void wxTextCtrl::Undo()
 954 {
 955     if (m_undos.GetCount() == 0) return;
 956
 957     wxNode *node = m_undos.Nth( m_undos.GetCount()-1 );
 958     wxSourceUndoStep *undo = (wxSourceUndoStep*) node->Data();
 959
 960     undo->Undo();
 961
 962     delete node;
 963
 964     m_modified = TRUE;
 965 }
 966
 967 void wxTextCtrl::SetInsertionPoint(long pos)
 968 {
 969 }
 970
 971 void wxTextCtrl::SetInsertionPointEnd()
 972 {
 973 }
 974
 975 long wxTextCtrl::GetInsertionPoint() const
 976 {
 977     return XYToPosition( m_cursorX, m_cursorY );
 978 }
 979
 980 long wxTextCtrl::GetLastPosition() const
 981 {
 982     size_t lineCount = m_lines.GetCount() - 1;
 983     return XYToPosition( m_lines[lineCount].m_text.Len()-1, lineCount );
 984 }
 985
 986 void wxTextCtrl::SetSelection(long from, long to)
 987 {
 988 }
 989
 990 void wxTextCtrl::SetEditable(bool editable)
 991 {
 992     m_editable = editable;
 993 }
 994
 995 bool wxTextCtrl::Enable( bool enable )
 996 {
 997     return FALSE;
 998 }
 999
1000 bool wxTextCtrl::SetFont(const wxFont& font)
1001 {
1002     wxTextCtrlBase::SetFont( font );
1003
1004     m_sourceFont = font;
1005
1006     wxClientDC dc(this);
1007     dc.SetFont( m_sourceFont );
1008     m_lineHeight = dc.GetCharHeight();
1009     m_charWidth = dc.GetCharWidth();
1010
1011     // TODO: recalc longest lines
1012
1013     MyAdjustScrollbars();
1014
1015     return TRUE;
1016 }
1017
1018 bool wxTextCtrl::SetForegroundColour(const wxColour& colour)
1019 {
1020     return wxWindow::SetForegroundColour( colour );
1021 }
1022
1023 bool wxTextCtrl::SetBackgroundColour(const wxColour& colour)
1024 {
1025     return wxWindow::SetBackgroundColour( colour );
1026 }
1027
1028 //-----------------------------------------------------------------------------
1029 //  private code and handlers
1030 //-----------------------------------------------------------------------------
1031
1032 void wxTextCtrl::SearchForBrackets()
1033 {
1034     int oldBracketY = m_bracketY;
1035     int oldBracketX = m_bracketX;
1036
1037     if (m_cursorY < 0 || m_cursorY >= (int)m_lines.GetCount()) return;
1038
1039     wxString current = m_lines[m_cursorY].m_text;
1040
1041     // reverse search first
1042
1043     char bracket = ' ';
1044
1045     if (m_cursorX > 0)
1046         bracket = current[m_cursorX-1];
1047
1048     if (bracket == ')' || bracket == ']' || bracket == '}')
1049     {
1050         char antibracket = '(';
1051         if (bracket == ']') antibracket = '[';
1052         if (bracket == '}') antibracket = '{';
1053
1054         int count = 1;
1055
1056         int endY = m_cursorY-60;
1057         if (endY < 0) endY = 0;
1058         for (int y = m_cursorY; y >= endY; y--)
1059         {
1060             current = m_lines[y].m_text;
1061             if (y == m_cursorY)
1062                 current.erase(m_cursorX-1,current.Len()-m_cursorX+1);
1063
1064             for (int n = current.Len()-1; n >= 0; n--)
1065             {
1066                 // ignore chars
1067                 if (current[n] == '\'')
1068                 {
1069                     for (int m = n-1; m >= 0; m--)
1070                     {
1071                         if (current[m] == '\'')
1072                         {
1073                             if (m == 0 || current[m-1] != '\\')
1074                                 break;
1075                         }
1076                         n = m-1;
1077                     }
1078                     continue;
1079                 }
1080
1081                 // ignore strings
1082                 if (current[n] == '\"')
1083                 {
1084                     for (int m = n-1; m >= 0; m--)
1085                     {
1086                         if (current[m] == '\"')
1087                         {
1088                             if (m == 0 || current[m-1] != '\\')
1089                                 break;
1090                         }
1091                         n = m-1;
1092                     }
1093                     continue;
1094                 }
1095
1096                 if (current[n] == antibracket)
1097                 {
1098                     count--;
1099                     if (count == 0)
1100                     {
1101                         m_bracketY = y;
1102                         m_bracketX = n;
1103                         if (oldBracketY != m_bracketY && oldBracketY != -1)
1104                             RefreshLine( oldBracketY );
1105                         if (m_bracketY != oldBracketY || m_bracketX != oldBracketX)
1106                             RefreshLine( m_bracketY );
1107                         return;
1108                     }
1109                 }
1110                 else if (current[n] == bracket)
1111                 {
1112                     count++;
1113                 }
1114             }
1115         }
1116     }
1117
1118     // then forward
1119
1120     bracket = ' ';
1121     if ((int)current.Len() > m_cursorX)
1122         bracket = current[m_cursorX];
1123     if (bracket == '(' || bracket == '[' || bracket == '{')
1124     {
1125         char antibracket = ')';
1126         if (bracket == '[') antibracket = ']';
1127         if (bracket == '{') antibracket = '}';
1128
1129         int count = 1;
1130
1131         int endY = m_cursorY+60;
1132         if (endY > (int)(m_lines.GetCount()-1)) endY = m_lines.GetCount()-1;
1133         for (int y = m_cursorY; y <= endY; y++)
1134         {
1135             current = m_lines[y].m_text;
1136             int start = 0;
1137             if (y == m_cursorY)
1138                 start = m_cursorX+1;
1139
1140             for (int n = start; n < (int)current.Len(); n++)
1141             {
1142                 // ignore chars
1143                 if (current[n] == '\'')
1144                 {
1145                     for (int m = n+1; m < (int)current.Len(); m++)
1146                     {
1147                         if (current[m] == '\'')
1148                         {
1149                             if (m == 0 || (current[m-1] != '\\') || (m >= 2 && current[m-2] == '\\'))
1150                                 break;
1151                         }
1152                         n = m+1;
1153                     }
1154                     continue;
1155                 }
1156
1157                 // ignore strings
1158                 if (current[n] == '\"')
1159                 {
1160                     for (int m = n+1; m < (int)current.Len(); m++)
1161                     {
1162                         if (current[m] == '\"')
1163                         {
1164                             if (m == 0 || (current[m-1] != '\\') || (m >= 2 && current[m-2] == '\\'))
1165                                 break;
1166                         }
1167                         n = m+1;
1168                     }
1169                     continue;
1170                 }
1171
1172                 if (current[n] == antibracket)
1173                 {
1174                     count--;
1175                     if (count == 0)
1176                     {
1177                         m_bracketY = y;
1178                         m_bracketX = n;
1179                         if (oldBracketY != m_bracketY && oldBracketY != -1)
1180                             RefreshLine( oldBracketY );
1181                         if (m_bracketY != oldBracketY || m_bracketX != oldBracketX)
1182                             RefreshLine( m_bracketY );
1183                         return;
1184                     }
1185                 }
1186                 else if (current[n] == bracket)
1187                 {
1188                     count++;
1189                 }
1190             }
1191         }
1192     }
1193
1194     if (oldBracketY != -1)
1195     {
1196         m_bracketY = -1;
1197         RefreshLine( oldBracketY );
1198     }
1199 }
1200
1201 void wxTextCtrl::Delete()
1202 {
1203     if (!HasSelection()) return;
1204
1205     m_modified = TRUE;
1206
1207     int selStartY = m_selStartY;
1208     int selEndY = m_selEndY;
1209     int selStartX = m_selStartX;
1210     int selEndX = m_selEndX;
1211
1212     if ((selStartY > selEndY) ||
1213         ((selStartY == selEndY) && (selStartX > selEndX)))
1214     {
1215         int tmp = selStartX;
1216         selStartX = selEndX;
1217         selEndX = tmp;
1218         tmp = selStartY;
1219         selStartY = selEndY;
1220         selEndY = tmp;
1221     }
1222
1223     int len = (int)m_lines[selStartY].m_text.Len();
1224
1225     if (selStartY == selEndY)
1226     {
1227         m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_LINE, selStartY, selStartY, this ) );
1228
1229         wxString tmp( m_lines[selStartY].m_text );
1230         if (selStartX < len)
1231         {
1232             if (selEndX > len)
1233                 selEndX = len;
1234             tmp.Remove( selStartX, selEndX-selStartX );
1235             m_lines[selStartY].m_text = tmp;
1236         }
1237         ClearSelection();
1238         m_cursorX = selStartX;
1239         RefreshLine( selStartY );
1240     }
1241     else
1242     {
1243         m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_DELETE, selStartY, selEndY, this ) );
1244
1245         if (selStartX < len)
1246             m_lines[selStartY].m_text.Remove( selStartX );
1247
1248         for (int i = 0; i < selEndY-selStartY-1; i++)
1249             m_lines.RemoveAt( selStartY+1 );
1250
1251         if (selEndX < (int)m_lines[selStartY+1].m_text.Len())
1252             m_lines[selStartY+1].m_text.Remove( 0, selEndX );
1253         else
1254             m_lines[selStartY+1].m_text.Remove( 0 );
1255
1256         m_lines[selStartY].m_text.Append( m_lines[selStartY+1].m_text );
1257         m_lines.RemoveAt( selStartY+1 );
1258
1259         ClearSelection();
1260         MoveCursor( selStartX, selStartY );
1261         MyAdjustScrollbars();
1262
1263         RefreshDown( selStartY );
1264     }
1265 }
1266
1267 void wxTextCtrl::DeleteLine()
1268 {
1269     if (HasSelection()) return;
1270
1271     if (m_cursorY < 0 || m_cursorY >= (int)m_lines.GetCount()-1) return;  // TODO
1272
1273     m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_DELETE, m_cursorY, m_cursorY+1, this ) );
1274
1275     m_lines.RemoveAt( m_cursorY );
1276     m_cursorX = 0;
1277     if (m_cursorY >= (int)m_lines.GetCount()) m_cursorY--;
1278
1279     MyAdjustScrollbars();
1280     RefreshDown( m_cursorY );
1281 }
1282
1283 void wxTextCtrl::DoChar( char c )
1284 {
1285     m_modified = TRUE;
1286
1287     m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_LINE, m_cursorY, m_cursorY, this ) );
1288
1289     wxString tmp( m_lines[m_cursorY].m_text );
1290     tmp.Trim();
1291     if (m_cursorX >= (int)tmp.Len())
1292     {
1293         int len = tmp.Len();
1294         for (int i = 0; i < m_cursorX - len; i++)
1295             tmp.Append( ' ' );
1296         tmp.Append( c );
1297     }
1298     else
1299     {
1300         if (m_overwrite)
1301             tmp.SetChar( m_cursorX, c );
1302         else
1303             tmp.insert( m_cursorX, 1, c );
1304     }
1305
1306     m_lines[m_cursorY].m_text = tmp;
1307
1308 //    if (tmp.Len() > m_longestLine)
1309 //    {
1310 //        m_longestLine = tmp.Len();
1311 //        MyAdjustScrollbars();
1312 //    }
1313
1314     int ww = 0;
1315     GetTextExtent( tmp, &ww, NULL, NULL, NULL );
1316     ww /= m_charWidth;
1317     if (ww > m_longestLine)
1318     {
1319         m_longestLine = ww;
1320         MyAdjustScrollbars();
1321     }
1322
1323     m_cursorX++;
1324
1325     int y = m_cursorY*m_lineHeight;
1326     // int x = (m_cursorX-1)*m_charWidth;
1327     int x = PosToPixel( m_cursorY, m_cursorX-1 );
1328     CalcScrolledPosition( x, y, &x, &y );
1329     wxRect rect( x+2, y+2, 10000, m_lineHeight );
1330     Refresh( TRUE, &rect );
1331     // refresh whole line for syntax colour highlighting
1332     rect.x = 0;
1333     Refresh( FALSE, &rect );
1334
1335     int size_x = 0;
1336     int size_y = 0;
1337     GetClientSize( &size_x, &size_y );
1338     size_x /= m_charWidth;
1339
1340     int view_x = 0;
1341     int view_y = 0;
1342     GetViewStart( &view_x, &view_y );
1343
1344     //int xx = m_cursorX;
1345     int xx = PosToPixel( m_cursorY, m_cursorX ) / m_charWidth;
1346
1347     if (xx < view_x)
1348         Scroll( xx, -1 );
1349     else if (xx > view_x+size_x-1)
1350         Scroll( xx-size_x+1, -1 );
1351 }
1352
1353 void wxTextCtrl::DoBack()
1354 {
1355     m_modified = TRUE;
1356
1357     if (m_cursorX == 0)
1358     {
1359         if (m_cursorY == 0) return;
1360
1361         m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_BACK, m_cursorY-1, m_cursorY, this ) );
1362
1363         wxString tmp1( m_lines[m_cursorY-1].m_text );
1364         tmp1.Trim();
1365         wxString tmp2( m_lines[m_cursorY].m_text );
1366         tmp2.Trim();
1367         m_cursorX = tmp1.Len();
1368         m_cursorY--;
1369         tmp1.Append( tmp2 );
1370         m_lines[m_cursorY].m_text = tmp1;
1371         m_lines.RemoveAt( m_cursorY+1 );
1372
1373         MyAdjustScrollbars();
1374         RefreshDown( m_cursorY-1 );
1375     }
1376     else
1377     {
1378         m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_LINE, m_cursorY, m_cursorY, this ) );
1379
1380         if (m_cursorX <= (int)m_lines[m_cursorY].m_text.Len())
1381             m_lines[m_cursorY].m_text.Remove( m_cursorX-1, 1 );
1382         m_cursorX--;
1383
1384         int y = m_cursorY*m_lineHeight;
1385         // int x = m_cursorX*m_charWidth;
1386         int x = PosToPixel( m_cursorY, m_cursorX );
1387         CalcScrolledPosition( x, y, &x, &y );
1388         wxRect rect( x+2, y+2, 10000, m_lineHeight );
1389         Refresh( TRUE, &rect );
1390         // refresh whole line for syntax colour highlighting
1391         rect.x = 0;
1392         Refresh( FALSE, &rect );
1393     }
1394 }
1395
1396 void wxTextCtrl::DoDelete()
1397 {
1398     m_modified = TRUE;
1399
1400     wxString tmp( m_lines[m_cursorY].m_text );
1401     tmp.Trim();
1402     int len = (int)tmp.Len();
1403     if (m_cursorX >= len)
1404     {
1405         if (m_cursorY == (int)m_lines.GetCount()-1) return;
1406
1407         m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_DELETE, m_cursorY, m_cursorY+1, this ) );
1408
1409         for (int i = 0; i < (m_cursorX-len); i++)
1410             tmp += ' ';
1411
1412         tmp += m_lines[m_cursorY+1].m_text;
1413
1414         m_lines[m_cursorY] = tmp;
1415         m_lines.RemoveAt( m_cursorY+1 );
1416
1417         MyAdjustScrollbars();
1418         RefreshDown( m_cursorY );
1419     }
1420     else
1421     {
1422         m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_LINE, m_cursorY, m_cursorY, this ) );
1423
1424         tmp.Remove( m_cursorX, 1 );
1425         m_lines[m_cursorY].m_text = tmp;
1426
1427         int y = m_cursorY*m_lineHeight;
1428         // int x = m_cursorX*m_charWidth;
1429         int x = PosToPixel( m_cursorY, m_cursorX );
1430         CalcScrolledPosition( x, y, &x, &y );
1431         wxRect rect( x+2, y+2, 10000, m_lineHeight );
1432         Refresh( TRUE, &rect );
1433         // refresh whole line for syntax colour highlighting
1434         rect.x = 0;
1435         Refresh( FALSE, &rect );
1436     }
1437 }
1438
1439 void wxTextCtrl::DoReturn()
1440 {
1441     m_modified = TRUE;
1442
1443     m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_ENTER, m_cursorY, m_cursorY, this ) );
1444
1445     wxString tmp( m_lines[m_cursorY].m_text );
1446     size_t indent = tmp.find_first_not_of( ' ' );
1447     if (indent == wxSTRING_MAXLEN) indent = 0;
1448     tmp.Trim();
1449     if (m_cursorX >= (int)tmp.Len())
1450     {
1451         int cursorX = indent;
1452         int cursorY = m_cursorY + 1;
1453
1454         wxString new_tmp;
1455         for (size_t i = 0; i < indent; i++) new_tmp.Append( ' ' );
1456         m_lines.Insert( new wxSourceLine( new_tmp ), cursorY );
1457
1458         MyAdjustScrollbars();
1459         MoveCursor( cursorX, cursorY );
1460         RefreshDown( m_cursorY );
1461     }
1462     else
1463     {
1464         wxString tmp1( tmp );
1465         tmp1.Remove( m_cursorX, tmp.Len()-m_cursorX );
1466         m_lines[m_cursorY].m_text = tmp1;
1467
1468         wxString tmp2( tmp );
1469         tmp2.Remove( 0, m_cursorX );
1470
1471         int cursorX = indent;
1472         int cursorY = m_cursorY + 1;
1473
1474         wxString new_tmp;
1475         for (size_t i = 0; i < indent; i++) new_tmp.Append( ' ' );
1476         new_tmp.Append( tmp2 );
1477         m_lines.Insert( new wxSourceLine( new_tmp ), cursorY );
1478
1479         MyAdjustScrollbars();
1480         MoveCursor( cursorX, cursorY );
1481         RefreshDown( m_cursorY-1 );
1482     }
1483 }
1484
1485 void wxTextCtrl::DoDClick()
1486 {
1487     wxString line( m_lines[ m_cursorY ].m_text );
1488     if (m_cursorX >= (int)line.Len()) return;
1489     int p = m_cursorX;
1490     char ch = line[p];
1491     if (((ch >= 'a') && (ch <= 'z')) ||
1492         ((ch >= 'A') && (ch <= 'Z')) ||
1493         ((ch >= '0') && (ch <= '9')) ||
1494         (ch == '_'))
1495     {
1496         m_selStartY = m_cursorY;
1497         m_selEndY = m_cursorY;
1498         if (p > 0)
1499         {
1500             ch = line[p-1];
1501             while (((ch >= 'a') && (ch <= 'z')) ||
1502                    ((ch >= 'A') && (ch <= 'Z')) ||
1503                    ((ch >= '0') && (ch <= '9')) ||
1504                    (ch == '_'))
1505             {
1506                 p--;
1507                 if (p == 0) break;
1508                 ch = line[p-1];
1509             }
1510         }
1511         m_selStartX = p;
1512
1513         p = m_cursorX;
1514         if (p < (int)line.Len())
1515         {
1516             ch = line[p];
1517             while (((ch >= 'a') && (ch <= 'z')) ||
1518                    ((ch >= 'A') && (ch <= 'Z')) ||
1519                    ((ch >= '0') && (ch <= '9')) ||
1520                    (ch == '_'))
1521             {
1522                 if (p >= (int)line.Len()) break;
1523                 p++;
1524                 ch = line[p];
1525             }
1526         }
1527         m_selEndX = p;
1528         RefreshLine( m_cursorY );
1529     }
1530 }
1531
1532 wxString wxTextCtrl::GetNextToken( wxString &line, size_t &pos )
1533 {
1534     wxString ret;
1535     size_t len = line.Len();
1536     for (size_t p = pos; p < len; p++)
1537     {
1538         if ((m_lang == wxSOURCE_LANG_PYTHON) || (m_lang == wxSOURCE_LANG_PERL))
1539         {
1540             if (line[p] == '#')
1541             {
1542                 for (size_t q = p; q < len; q++)
1543                     ret.Append( line[q] );
1544                 pos = p;
1545                 return ret;
1546             }
1547         }
1548         else
1549         {
1550             if ((line[p] == '/') && (p+1 < len) && (line[p+1] == '/'))
1551             {
1552                 for (size_t q = p; q < len; q++)
1553                     ret.Append( line[q] );
1554                 pos = p;
1555                 return ret;
1556             }
1557         }
1558
1559         if (line[p] == '"')
1560         {
1561             ret.Append( line[p] );
1562             for (size_t q = p+1; q < len; q++)
1563             {
1564                 ret.Append( line[q] );
1565                 if ((line[q] == '"') && ((line[q-1] != '\\') || (q >= 2 && line[q-2] == '\\')))
1566                    break;
1567             }
1568             pos = p;
1569             return ret;
1570         }
1571
1572         if (line[p] == '\'')
1573         {
1574             ret.Append( line[p] );
1575             for (size_t q = p+1; q < len; q++)
1576             {
1577                 ret.Append( line[q] );
1578                 if ((line[q] == '\'') && ((line[q-1] != '\\') || (q >= 2 && line[q-2] == '\\')))
1579                    break;
1580             }
1581             pos = p;
1582             return ret;
1583         }
1584
1585         if (((line[p] >= 'a') && (line[p] <= 'z')) ||
1586             ((line[p] >= 'A') && (line[p] <= 'Z')) ||
1587             (line[p] == '_') ||
1588             (line[p] == '#'))
1589         {
1590            ret.Append( line[p] );
1591            for (size_t q = p+1; q < len; q++)
1592            {
1593                 if (((line[q] >= 'a') && (line[q] <= 'z')) ||
1594                    ((line[q] >= 'A') && (line[q] <= 'Z')) ||
1595                    ((line[q] >= '0') && (line[q] <= '9')) ||
1596                    (line[q] == '_'))
1597                 {
1598                     ret.Append( line[q] );
1599                     continue;
1600                 }
1601                 else
1602                 {
1603                     pos = p;
1604                     return ret;
1605                 }
1606            }
1607            pos = p;
1608            return ret;
1609         }
1610     }
1611
1612     return ret;
1613 }
1614
1615 void wxTextCtrl::OnEraseBackground( wxEraseEvent &event )
1616 {
1617     event.Skip();
1618 }
1619
1620 void wxTextCtrl::DrawLinePart( wxDC &dc, int x, int y, const wxString &toDraw, const wxString &origin, const wxColour &colour )
1621 {
1622     size_t pos = 0;
1623     size_t len = origin.Len();
1624     dc.SetTextForeground( colour );
1625     while (pos < len)
1626     {
1627         while (toDraw[pos] == wxT(' '))
1628         {
1629             pos++;
1630             if (pos == len) return;
1631         }
1632
1633         size_t start = pos;
1634
1635         wxString current;
1636         current += toDraw[pos];
1637         pos++;
1638         while ( (toDraw[pos] == origin[pos]) && (pos < len))
1639         {
1640             current += toDraw[pos];
1641             pos++;
1642         }
1643
1644         int xx = 0;
1645         wxString tmp = origin.Left( start );
1646         GetTextExtent( tmp, &xx, NULL, NULL, NULL );
1647         xx += x;
1648         int yy = y;
1649         dc.DrawText( current, xx, yy );
1650     }
1651 }
1652
1653 void wxTextCtrl::DrawLine( wxDC &dc, int x, int y, const wxString &line2, int lineNum )
1654 {
1655     int selStartY = m_selStartY;
1656     int selEndY = m_selEndY;
1657     int selStartX = m_selStartX;
1658     int selEndX = m_selEndX;
1659
1660     if ((selStartY > selEndY) ||
1661         ((selStartY == selEndY) && (selStartX > selEndX)))
1662     {
1663         int tmp = selStartX;
1664         selStartX = selEndX;
1665         selEndX = tmp;
1666         tmp = selStartY;
1667         selStartY = selEndY;
1668         selEndY = tmp;
1669     }
1670
1671     wxString line( line2 );
1672     if (HasFlag(wxTE_PASSWORD))
1673     {
1674         size_t len = line.Len();
1675         line = wxString( wxT('*'), len );
1676     }
1677
1678     wxString keyword( ' ', line.Len() );
1679     wxString define( ' ', line.Len() );
1680     wxString variable( ' ', line.Len() );
1681     wxString comment( ' ', line.Len() );
1682     wxString my_string( ' ', line.Len() );
1683     wxString selection( ' ', line.Len() );
1684
1685     if (m_lang != wxSOURCE_LANG_NONE)
1686     {
1687         if (lineNum == m_bracketY)
1688         {
1689             wxString red( ' ', line.Len() );
1690             if (m_bracketX < (int)line.Len())
1691             {
1692                 red.SetChar( m_bracketX, line[m_bracketX] );
1693                 line.SetChar( m_bracketX, ' ' );
1694                 dc.SetTextForeground( *wxRED );
1695                 dc.DrawText( red, x, y );
1696                 dc.SetTextForeground( *wxBLACK );
1697             }
1698         }
1699
1700         size_t pos = 0;
1701         wxString token( GetNextToken( line, pos ) );
1702         while (!token.IsNull())
1703         {
1704             if (m_keywords.Index( token ) != wxNOT_FOUND)
1705             {
1706                 size_t end_pos = pos + token.Len();
1707                 for (size_t i = pos; i < end_pos; i++)
1708                 {
1709                     keyword[i] = line[i];
1710                     line[i] = ' ';
1711                 }
1712             } else
1713             if (m_defines.Index( token ) != wxNOT_FOUND)
1714             {
1715                 size_t end_pos = pos + token.Len();
1716                 for (size_t i = pos; i < end_pos; i++)
1717                 {
1718                     define[i] = line[i];
1719                     line[i] = ' ';
1720                 }
1721             } else
1722             if ((m_variables.Index( token ) != wxNOT_FOUND) ||
1723                 ((token.Len() > 2) && (token[0] == 'w') && (token[1] == 'x')))
1724             {
1725                 size_t end_pos = pos + token.Len();
1726                 for (size_t i = pos; i < end_pos; i++)
1727                 {
1728                     variable[i] = line[i];
1729                     line[i] = ' ';
1730                 }
1731             } else
1732             if ((token.Len() >= 2) && (token[0] == '/') && (token[1] == '/') && (m_lang == wxSOURCE_LANG_CPP))
1733             {
1734                 size_t end_pos = pos + token.Len();
1735                 for (size_t i = pos; i < end_pos; i++)
1736                 {
1737                     comment[i] = line[i];
1738                     line[i] = ' ';
1739                 }
1740             } else
1741             if ((token[0] == '#') &&
1742                 ((m_lang == wxSOURCE_LANG_PYTHON) || (m_lang == wxSOURCE_LANG_PERL)))
1743             {
1744                 size_t end_pos = pos + token.Len();
1745                 for (size_t i = pos; i < end_pos; i++)
1746                 {
1747                     comment[i] = line[i];
1748                     line[i] = ' ';
1749                 }
1750             } else
1751             if ((token[0] == '"') || (token[0] == '\''))
1752             {
1753                 size_t end_pos = pos + token.Len();
1754                 for (size_t i = pos; i < end_pos; i++)
1755                 {
1756                     my_string[i] = line[i];
1757                     line[i] = ' ';
1758                 }
1759             }
1760             pos += token.Len();
1761             token = GetNextToken( line, pos );
1762         }
1763     }
1764
1765     if ((lineNum < selStartY) || (lineNum > selEndY))
1766     {
1767         DrawLinePart( dc, x, y, line, line2, *wxBLACK );
1768         DrawLinePart( dc, x, y, selection, line2, *wxWHITE );
1769         DrawLinePart( dc, x, y, keyword, line2, m_keywordColour );
1770         DrawLinePart( dc, x, y, define, line2, m_defineColour );
1771         DrawLinePart( dc, x, y, variable, line2, m_variableColour );
1772         DrawLinePart( dc, x, y, comment, line2, m_commentColour );
1773         DrawLinePart( dc, x, y, my_string, line2, m_stringColour );
1774         return;
1775     }
1776
1777     if (selStartY == selEndY)
1778     {
1779         // int xx = selStartX*m_charWidth;
1780         int xx = PosToPixel( lineNum, selStartX );
1781         // int ww = (selEndX-selStartX)*m_charWidth;
1782         int ww = PosToPixel( lineNum, selEndX ) - xx;
1783         dc.DrawRectangle( xx+2, lineNum*m_lineHeight+2, ww, m_lineHeight );
1784
1785         for (size_t i = (size_t)selStartX; i < (size_t)selEndX; i++)
1786         {
1787             selection[i] = line[i];
1788             line[i] = ' ';
1789         }
1790     } else
1791     if ((lineNum > selStartY) && (lineNum < selEndY))
1792     {
1793         dc.DrawRectangle( 0+2, lineNum*m_lineHeight+2, 10000, m_lineHeight );
1794
1795         for (size_t i = 0; i < line.Len(); i++)
1796         {
1797             selection[i] = line[i];
1798             line[i] = ' ';
1799         }
1800     } else
1801     if (lineNum == selStartY)
1802     {
1803         // int xx = selStartX*m_charWidth;
1804         int xx = PosToPixel( lineNum, selStartX );
1805         dc.DrawRectangle( xx+2, lineNum*m_lineHeight+2, 10000, m_lineHeight );
1806
1807         for (size_t i = (size_t)selStartX; i < line.Len(); i++)
1808         {
1809             selection[i] = line[i];
1810             line[i] = ' ';
1811         }
1812     } else
1813     if (lineNum == selEndY)
1814     {
1815         // int ww = selEndX*m_charWidth;
1816         int ww = PosToPixel( lineNum, selEndX );
1817         dc.DrawRectangle( 0+2, lineNum*m_lineHeight+2, ww, m_lineHeight );
1818
1819         for (size_t i = 0; i < (size_t)selEndX; i++)
1820         {
1821             selection[i] = line[i];
1822             line[i] = ' ';
1823         }
1824     }
1825
1826     DrawLinePart( dc, x, y, line, line2, *wxBLACK );
1827     DrawLinePart( dc, x, y, selection, line2, *wxWHITE );
1828     DrawLinePart( dc, x, y, keyword, line2, m_keywordColour );
1829     DrawLinePart( dc, x, y, define, line2, m_defineColour );
1830     DrawLinePart( dc, x, y, variable, line2, m_variableColour );
1831     DrawLinePart( dc, x, y, comment, line2, m_commentColour );
1832     DrawLinePart( dc, x, y, my_string, line2, m_stringColour );
1833 }
1834
1835 void wxTextCtrl::OnPaint( wxPaintEvent &event )
1836 {
1837     wxPaintDC dc(this);
1838
1839     if (m_lines.GetCount() == 0) return;
1840
1841     PrepareDC( dc );
1842
1843     dc.SetFont( m_sourceFont );
1844
1845     int scroll_y = 0;
1846     GetViewStart( NULL, &scroll_y );
1847
1848     // We have a inner border of two pixels
1849     // around the text, so scroll units do
1850     // not correspond to lines.
1851     if (scroll_y > 0) scroll_y--;
1852
1853     int size_x = 0;
1854     int size_y = 0;
1855     GetClientSize( &size_x, &size_y );
1856
1857     dc.SetPen( *wxTRANSPARENT_PEN );
1858     dc.SetBrush( wxBrush( wxTHEME_COLOUR(HIGHLIGHT), wxSOLID ) );
1859     int upper = wxMin( (int)m_lines.GetCount(), scroll_y+(size_y/m_lineHeight)+2 );
1860     for (int i = scroll_y; i < upper; i++)
1861     {
1862         int x = 0+2;
1863         int y = i*m_lineHeight+2;
1864         int w = 10000;
1865         int h = m_lineHeight;
1866         CalcScrolledPosition( x,y,&x,&y );
1867         if (IsExposed(x,y,w,h))
1868             DrawLine( dc, 0+2, i*m_lineHeight+2, m_lines[i].m_text, i );
1869     }
1870
1871     if (m_editable && (FindFocus() == this))
1872     {
1873         ///dc.SetBrush( *wxRED_BRUSH );
1874         dc.SetBrush( *wxBLACK_BRUSH );
1875         // int xx = m_cursorX*m_charWidth;
1876         int xx = PosToPixel( m_cursorY, m_cursorX );
1877         dc.DrawRectangle( xx+2, m_cursorY*m_lineHeight+2, 2, m_lineHeight );
1878     }
1879 }
1880
1881 void wxTextCtrl::OnMouse( wxMouseEvent &event )
1882 {
1883     if (m_lines.GetCount() == 0) return;
1884
1885
1886 #if 0  // there is no middle button on iPAQs
1887     if (event.MiddleDown())
1888     {
1889         Paste( TRUE );
1890         return;
1891     }
1892 #endif
1893
1894     if (event.LeftDClick())
1895     {
1896         DoDClick();
1897         return;
1898     }
1899
1900     if (event.LeftDown())
1901     {
1902         m_capturing = TRUE;
1903         CaptureMouse();
1904     }
1905
1906     if (event.LeftUp())
1907     {
1908         m_capturing = FALSE;
1909         ReleaseMouse();
1910     }
1911
1912     if (event.LeftDown() ||
1913         (event.LeftIsDown() && m_capturing))
1914     {
1915         int x = event.GetX();
1916         int y = event.GetY();
1917         CalcUnscrolledPosition( x, y, &x, &y );
1918         y /= m_lineHeight;
1919         // x /= m_charWidth;
1920         x = PixelToPos( y, x );
1921         MoveCursor(
1922             wxMin( 1000, wxMax( 0, x ) ),
1923             wxMin( (int)m_lines.GetCount()-1, wxMax( 0, y ) ),
1924             event.ShiftDown() || !event.LeftDown() );
1925     }
1926 }
1927
1928 void wxTextCtrl::OnChar( wxKeyEvent &event )
1929 {
1930     if (m_lines.GetCount() == 0) return;
1931
1932     if (!m_editable) return;
1933
1934     int size_x = 0;
1935     int size_y = 0;
1936     GetClientSize( &size_x, &size_y );
1937     size_x /= m_charWidth;
1938     size_y /= m_lineHeight;
1939     size_y--;
1940
1941     if (event.ShiftDown())
1942     {
1943         switch (event.GetKeyCode())
1944         {
1945             case '4': event.m_keyCode = WXK_LEFT;   break;
1946             case '8': event.m_keyCode = WXK_UP;     break;
1947             case '6': event.m_keyCode = WXK_RIGHT;  break;
1948             case '2': event.m_keyCode = WXK_DOWN;   break;
1949             case '9': event.m_keyCode = WXK_PRIOR;  break;
1950             case '3': event.m_keyCode = WXK_NEXT;   break;
1951             case '7': event.m_keyCode = WXK_HOME;   break;
1952             case '1': event.m_keyCode = WXK_END;    break;
1953             case '0': event.m_keyCode = WXK_INSERT; break;
1954         }
1955     }
1956
1957     switch (event.GetKeyCode())
1958     {
1959         case WXK_UP:
1960         {
1961             if (m_ignoreInput) return;
1962             if (m_cursorY > 0)
1963                 MoveCursor( m_cursorX, m_cursorY-1, event.ShiftDown() );
1964             m_ignoreInput = TRUE;
1965             return;
1966         }
1967         case WXK_DOWN:
1968         {
1969             if (m_ignoreInput) return;
1970             if (m_cursorY < (int)(m_lines.GetCount()-1))
1971                 MoveCursor( m_cursorX, m_cursorY+1, event.ShiftDown() );
1972             m_ignoreInput = TRUE;
1973             return;
1974         }
1975         case WXK_LEFT:
1976         {
1977             if (m_ignoreInput) return;
1978             if (m_cursorX > 0)
1979             {
1980                 MoveCursor( m_cursorX-1, m_cursorY, event.ShiftDown() );
1981             }
1982             else
1983             {
1984                 if (m_cursorY > 0)
1985                     MoveCursor( m_lines[m_cursorY-1].m_text.Len(), m_cursorY-1, event.ShiftDown() );
1986             }
1987             m_ignoreInput = TRUE;
1988             return;
1989         }
1990         case WXK_RIGHT:
1991         {
1992             if (m_ignoreInput) return;
1993             if (m_cursorX < 1000)
1994                 MoveCursor( m_cursorX+1, m_cursorY, event.ShiftDown() );
1995             m_ignoreInput = TRUE;
1996             return;
1997         }
1998         case WXK_HOME:
1999         {
2000             if (event.ControlDown())
2001                 MoveCursor( 0, 0, event.ShiftDown() );
2002             else
2003                 MoveCursor( 0, m_cursorY, event.ShiftDown() );
2004             return;
2005         }
2006         case WXK_END:
2007         {
2008             if (event.ControlDown())
2009                 MoveCursor( 0, m_lines.GetCount()-1, event.ShiftDown() );
2010             else
2011                 MoveCursor( m_lines[m_cursorY].m_text.Len(), m_cursorY, event.ShiftDown() );
2012             return;
2013         }
2014         case WXK_NEXT:
2015         {
2016             if (m_ignoreInput) return;
2017             MoveCursor( m_cursorX, wxMin( (int)(m_lines.GetCount()-1), m_cursorY+size_y ), event.ShiftDown() );
2018             m_ignoreInput = TRUE;
2019             return;
2020         }
2021         case WXK_PRIOR:
2022         {
2023             if (m_ignoreInput) return;
2024             MoveCursor( m_cursorX, wxMax( 0, m_cursorY-size_y ), event.ShiftDown() );
2025             m_ignoreInput = TRUE;
2026             return;
2027         }
2028         case WXK_INSERT:
2029         {
2030             if (event.ShiftDown())
2031                 Paste();
2032             else if (event.ControlDown())
2033                 Copy();
2034             else
2035                 m_overwrite = !m_overwrite;
2036             return;
2037         }
2038         case WXK_RETURN:
2039         {
2040             if (m_windowStyle & wxPROCESS_ENTER)
2041             {
2042                 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
2043                 event.SetEventObject(this);
2044                 event.SetString(GetValue());
2045                 if (GetEventHandler()->ProcessEvent(event)) return;
2046             }
2047
2048             if (IsSingleLine())
2049             {
2050                 event.Skip();
2051                 return;
2052             }
2053
2054             if (HasSelection())
2055                 Delete();
2056             DoReturn();
2057             return;
2058         }
2059         case WXK_TAB:
2060         {
2061             if (HasSelection())
2062                 Delete();
2063             bool save_overwrite = m_overwrite;
2064             m_overwrite = FALSE;
2065             int i = 4-(m_cursorX % 4);
2066             if (i == 0) i = 4;
2067             for (int c = 0; c < i; c++)
2068                  DoChar( ' ' );
2069             m_overwrite = save_overwrite;
2070             return;
2071         }
2072         case WXK_BACK:
2073         {
2074             if (HasSelection())
2075                 Delete();
2076             else
2077                 DoBack();
2078             return;
2079         }
2080         case WXK_DELETE:
2081         {
2082             if (HasSelection())
2083                 Delete();
2084             else
2085                 DoDelete();
2086             return;
2087         }
2088         default:
2089         {
2090             if (  (event.KeyCode() >= 'a') &&
2091                   (event.KeyCode() <= 'z') &&
2092                   (event.AltDown()) )
2093             {
2094                 // Alt-F etc.
2095                 event.Skip();
2096                 return;
2097             }
2098
2099             if (  (event.KeyCode() >= 32) &&
2100                   (event.KeyCode() <= 255) &&
2101                  !(event.ControlDown() && !event.AltDown()) ) // filters out Ctrl-X but leaves Alt-Gr
2102             {
2103                 if (HasSelection())
2104                     Delete();
2105                 DoChar( (char) event.KeyCode() );
2106                 return;
2107             }
2108         }
2109     }
2110
2111     event.Skip();
2112 }
2113
2114 void wxTextCtrl::OnIdle( wxIdleEvent &event )
2115 {
2116     m_ignoreInput = FALSE;
2117
2118     if (m_lang != wxSOURCE_LANG_NONE)
2119         SearchForBrackets();
2120
2121     event.Skip( TRUE );
2122 }
2123
2124 void wxTextCtrl::Indent()
2125 {
2126     int startY = m_cursorY;
2127     int endY = m_cursorY;
2128     if (HasSelection())
2129     {
2130         startY = m_selStartY;
2131         endY = m_selEndY;
2132         if (endY < startY)
2133         {
2134             int tmp = startY;
2135             startY = endY;
2136             endY = tmp;
2137         }
2138     }
2139
2140     m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_LINE, startY, endY, this ) );
2141
2142     for (int i = startY; i <= endY; i++)
2143     {
2144         m_lines[i].m_text.insert( 0u, "    " );
2145         RefreshLine( i );
2146     }
2147 }
2148
2149 void wxTextCtrl::Unindent()
2150 {
2151     int startY = m_cursorY;
2152     int endY = m_cursorY;
2153     if (HasSelection())
2154     {
2155         startY = m_selStartY;
2156         endY = m_selEndY;
2157         if (endY < startY)
2158         {
2159             int tmp = startY;
2160             startY = endY;
2161             endY = tmp;
2162         }
2163     }
2164
2165     m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_LINE, startY, endY, this ) );
2166
2167     for (int i = startY; i <= endY; i++)
2168     {
2169         for (int n = 0; n < 4; n++)
2170         {
2171             if (m_lines[i].m_text[0u] == ' ')
2172                 m_lines[i].m_text.erase(0u,1u);
2173         }
2174         RefreshLine( i );
2175     }
2176 }
2177 bool wxTextCtrl::HasSelection()
2178 {
2179     return ((m_selStartY != m_selEndY) || (m_selStartX != m_selEndX));
2180 }
2181
2182 void wxTextCtrl::ClearSelection()
2183 {
2184     m_selStartX = -1;
2185     m_selStartY = -1;
2186     m_selEndX = -1;
2187     m_selEndY = -1;
2188 }
2189
2190 void wxTextCtrl::RefreshLine( int n )
2191 {
2192     int y = n*m_lineHeight;
2193     int x = 0;
2194     CalcScrolledPosition( x, y, &x, &y );
2195     wxRect rect( 0+2, y+2, 10000, m_lineHeight );
2196     Refresh( TRUE, &rect );
2197 }
2198
2199 void wxTextCtrl::RefreshDown( int n )
2200 {
2201     int size_x = 0;
2202     int size_y = 0;
2203     GetClientSize( &size_x, &size_y );
2204
2205     int view_x = 0;
2206     int view_y = 0;
2207     GetViewStart( &view_x, &view_y );
2208
2209     if (n < view_y)
2210     {
2211         Refresh();
2212     }
2213     else
2214     {
2215         int y = n*m_lineHeight;
2216         int x = 0;
2217         CalcScrolledPosition( x, y, &x, &y );
2218
2219         wxRect rect( 0+2, y+2, 10000, size_y );
2220         Refresh( TRUE, &rect );
2221     }
2222 }
2223
2224 void wxTextCtrl::MoveCursor( int new_x, int new_y, bool shift, bool centre )
2225 {
2226     if (!m_editable) return;
2227
2228     // if (IsSingleLine() || (m_lang == wxSOURCE_LANG_NONE))
2229     {
2230         if (new_x > m_lines[new_y].m_text.Len())
2231             new_x = m_lines[new_y].m_text.Len();
2232     }
2233
2234     if ((new_x == m_cursorX) && (new_y == m_cursorY)) return;
2235
2236     bool no_cursor_refresh = FALSE;
2237     bool has_selection = HasSelection();
2238
2239     if (shift)
2240     {
2241         int x,y,w,h;
2242         bool erase_background = TRUE;
2243
2244         if (!has_selection)
2245         {
2246             m_selStartX = m_cursorX;
2247             m_selStartY = m_cursorY;
2248
2249             x = 0;
2250             w = 10000;
2251             if (new_y > m_selStartY)
2252             {
2253                 y = m_selStartY*m_lineHeight;
2254                 h = (new_y-m_selStartY+1)*m_lineHeight;
2255             }
2256             else if (new_y == m_selStartY)
2257             {
2258                 x = PosToPixel( new_y, m_selStartX );
2259                 w = PosToPixel( new_y, new_x ) - x;
2260                 if (w < 0)
2261                 {
2262                     x += w;
2263                     w = -w + 2; // +2 for the cursor
2264                 }
2265                 y = m_selStartY*m_lineHeight;
2266                 h = m_lineHeight;
2267             }
2268             else
2269             {
2270                 y = new_y*m_lineHeight;
2271                 h = (-new_y+m_selStartY+1)*m_lineHeight;
2272             }
2273
2274             no_cursor_refresh = TRUE;
2275             m_cursorX = new_x;
2276             m_cursorY = new_y;
2277         }
2278         else
2279         {
2280             if (new_y == m_selEndY)
2281             {
2282                 y = new_y *m_lineHeight;
2283                 h = m_lineHeight;
2284                 if (m_selEndX > new_x)
2285                 {
2286                     // x = new_x*m_charWidth;
2287                     x = PosToPixel( new_y, new_x );
2288                     // w = (m_selEndX-new_x)*m_charWidth;
2289                     w = PosToPixel( new_y, m_selEndX ) - x;
2290                 }
2291                 else
2292                 {
2293                     // x = m_selEndX*m_charWidth;
2294                     x = PosToPixel( new_y, m_selEndX );
2295                     // w = (-m_selEndX+new_x)*m_charWidth;
2296                     w = PosToPixel( new_y, new_x ) - x;
2297                 }
2298             }
2299             else
2300             {
2301                 x = 0;
2302                 w = 10000;
2303                 if (new_y > m_selEndY)
2304                 {
2305                     y = m_selEndY*m_lineHeight;
2306                     h = (new_y-m_selEndY+1) * m_lineHeight;
2307
2308                     erase_background = ((m_selEndY < m_selStartY) ||
2309                                         ((m_selEndY == m_selStartY) && (m_selEndX < m_selStartX)));
2310                 }
2311                 else
2312                 {
2313                     y = new_y*m_lineHeight;
2314                     h = (-new_y+m_selEndY+1) * m_lineHeight;
2315
2316                     erase_background = ((m_selEndY > m_selStartY) ||
2317                                         ((m_selEndY == m_selStartY) && (m_selEndX > m_selStartX)));
2318                 }
2319                 no_cursor_refresh = TRUE;
2320                 m_cursorX = new_x;
2321                 m_cursorY = new_y;
2322             }
2323         }
2324
2325         m_selEndX = new_x;
2326         m_selEndY = new_y;
2327
2328         CalcScrolledPosition( x, y, &x, &y );
2329         wxRect rect( x+2, y+2, w, h );
2330         Refresh( erase_background, &rect );
2331     }
2332     else
2333     {
2334         if (has_selection)
2335         {
2336             int ry1 = m_selEndY;
2337             int ry2 = m_selStartY;
2338             m_selEndX = -1;
2339             m_selEndY = -1;
2340             m_selStartX = -1;
2341             m_selStartY = -1;
2342
2343             if (ry1 > ry2)
2344             {
2345                 int tmp = ry2;
2346                 ry2 = ry1;
2347                 ry1 = tmp;
2348             }
2349
2350             int x = 0;
2351             int y = ry1*m_lineHeight;
2352             CalcScrolledPosition( x, y, &x, &y );
2353             wxRect rect( 0, y+2, 10000, (ry2-ry1+1)*m_lineHeight );
2354
2355             Refresh( TRUE, &rect );
2356         }
2357     }
2358
2359 /*
2360     printf( "startx %d starty %d endx %d endy %d\n",
2361             m_selStartX, m_selStartY, m_selEndX, m_selEndY );
2362
2363     printf( "has %d\n", (int)HasSelection() );
2364 */
2365
2366     if (!no_cursor_refresh)
2367     {
2368         // int x = m_cursorX*m_charWidth;
2369         int x = PosToPixel( m_cursorY, m_cursorX );
2370         int y = m_cursorY*m_lineHeight;
2371         CalcScrolledPosition( x, y, &x, &y );
2372         wxRect rect( x+2, y+2, 4, m_lineHeight+2 );
2373
2374         m_cursorX = new_x;
2375         m_cursorY = new_y;
2376
2377         Refresh( TRUE, &rect );
2378
2379         if (FindFocus() == this)
2380         {
2381             wxClientDC dc(this);
2382             PrepareDC( dc );
2383             dc.SetPen( *wxTRANSPARENT_PEN );
2384             //dc.SetBrush( *wxRED_BRUSH );
2385             dc.SetBrush( *wxBLACK_BRUSH );
2386             // int xx = m_cursorX*m_charWidth;
2387             int xx = PosToPixel( m_cursorY, m_cursorX );
2388             dc.DrawRectangle( xx+2, m_cursorY*m_lineHeight+2, 2, m_lineHeight );
2389         }
2390     }
2391
2392     int size_x = 0;
2393     int size_y = 0;
2394     GetClientSize( &size_x, &size_y );
2395     size_x /= m_charWidth;
2396     size_y /= m_lineHeight;
2397
2398     int view_x = 0;
2399     int view_y = 0;
2400     GetViewStart( &view_x, &view_y );
2401
2402     if (centre)
2403     {
2404         int sy = m_cursorY - (size_y/2);
2405         if (sy < 0) sy = 0;
2406         Scroll( -1, sy );
2407     }
2408     else
2409     {
2410         if (m_cursorY < view_y)
2411             Scroll( -1, m_cursorY );
2412         else if (m_cursorY > view_y+size_y-1)
2413             Scroll( -1, m_cursorY-size_y+1 );
2414     }
2415
2416     //int xx = m_cursorX;
2417     int xx = PosToPixel( m_cursorY, m_cursorX ) / m_charWidth;
2418
2419     if (xx < view_x)
2420         Scroll( xx, -1 );
2421     else if (xx > view_x+size_x-1)
2422         Scroll( xx-size_x+1, -1 );
2423 }
2424
2425 void wxTextCtrl::MyAdjustScrollbars()
2426 {
2427     if (IsSingleLine())
2428         return;
2429
2430     int y_range = m_lines.GetCount();
2431
2432     int height = 0;
2433     GetClientSize( NULL, &height );
2434     height -= 4;
2435     if (height >= m_lines.GetCount() *m_lineHeight)
2436         y_range = 0;
2437
2438     int view_x = 0;
2439     int view_y = 0;
2440     GetViewStart( &view_x, &view_y );
2441
2442     SetScrollbars( m_charWidth, m_lineHeight, m_longestLine+2, y_range, view_x, view_y );
2443 }
2444
2445 //-----------------------------------------------------------------------------
2446 //  clipboard handlers
2447 //-----------------------------------------------------------------------------
2448
2449 void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
2450 {
2451     Cut();
2452 }
2453
2454 void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
2455 {
2456     Copy();
2457 }
2458
2459 void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
2460 {
2461     Paste();
2462 }
2463
2464 void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
2465 {
2466     Undo();
2467 }
2468
2469 void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
2470 {
2471     Redo();
2472 }
2473
2474 void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
2475 {
2476     event.Enable( CanCut() );
2477 }
2478
2479 void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
2480 {
2481     event.Enable( CanCopy() );
2482 }
2483
2484 void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
2485 {
2486     event.Enable( CanPaste() );
2487 }
2488
2489 void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
2490 {
2491     event.Enable( CanUndo() );
2492 }
2493
2494 void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
2495 {
2496     event.Enable( CanRedo() );
2497 }
2498
2499 wxSize wxTextCtrl::DoGetBestSize() const
2500 {
2501     if (IsSingleLine())
2502     {
2503         wxSize ret(80, m_lineHeight + 4);
2504
2505         if (HasFlag(wxBORDER_SUNKEN) || HasFlag(wxBORDER_RAISED))
2506             ret.y += 4;
2507
2508         if (HasFlag(wxBORDER_SIMPLE))
2509             ret.y += 2;
2510
2511         return ret;
2512     }
2513     else
2514     {
2515         return wxSize(80, 60);
2516     }
2517 }
2518
2519 // ----------------------------------------------------------------------------
2520 // freeze/thaw
2521 // ----------------------------------------------------------------------------
2522
2523 void wxTextCtrl::Freeze()
2524 {
2525 }
2526
2527 void wxTextCtrl::Thaw()
2528 {
2529 }
2530
2531 void wxTextCtrl::OnSetFocus( wxFocusEvent& event )
2532 {
2533     // To hide or show caret, as appropriate
2534     Refresh();
2535 }
2536
2537 void wxTextCtrl::OnKillFocus( wxFocusEvent& event )
2538 {
2539     // To hide or show caret, as appropriate
2540     Refresh();
2541 }
2542
2543 // ----------------------------------------------------------------------------
2544 // text control scrolling
2545 // ----------------------------------------------------------------------------
2546
2547 bool wxTextCtrl::ScrollLines(int lines)
2548 {
2549     wxFAIL_MSG( "wxTextCtrl::ScrollLines not implemented");
2550
2551     return FALSE;
2552 }
2553
2554 bool wxTextCtrl::ScrollPages(int pages)
2555 {
2556     wxFAIL_MSG( "wxTextCtrl::ScrollPages not implemented");
2557
2558     return FALSE;
2559 }
2560