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_CHAR(wxTextCtrl::OnChar)
 135     EVT_MOUSE_EVENTS(wxTextCtrl::OnMouse)
 136     EVT_IDLE(wxTextCtrl::OnIdle)
 137
 138     EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
 139     EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
 140     EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
 141     EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
 142     EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
 143
 144     EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
 145     EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
 146     EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
 147     EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
 148     EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
 149 END_EVENT_TABLE()
 150
 151 void wxTextCtrl::Init()
 152 {
 153     m_editable = TRUE;
 154     m_modified = FALSE;
 155
 156     m_sourceFont = wxFont( 12, wxMODERN, wxNORMAL, wxNORMAL );
 157
 158     m_undos.DeleteContents( TRUE );
 159
 160     m_lang = wxSOURCE_LANG_NONE;
 161
 162     m_capturing = FALSE;
 163
 164     wxClientDC dc(this);
 165     dc.SetFont( m_sourceFont );
 166     m_lineHeight = dc.GetCharHeight();
 167     m_charWidth = dc.GetCharWidth();
 168
 169     m_cursorX = 0;
 170     m_cursorY = 0;
 171
 172     m_longestLine = 0;
 173
 174     m_bracketX = -1;
 175     m_bracketY = -1;
 176
 177     m_overwrite = FALSE;
 178     m_ignoreInput = FALSE;
 179
 180     ClearSelection();
 181
 182     m_keywordColour = wxColour( 10, 140, 10 );
 183
 184     m_defineColour = *wxRED;
 185
 186     m_variableColour = wxColour( 50, 120, 150 );
 187
 188     m_commentColour = wxColour( 130, 130, 130 );
 189
 190     m_stringColour = wxColour( 10, 140, 10 );
 191 }
 192
 193 wxTextCtrl::wxTextCtrl( wxWindow *parent,
 194                         wxWindowID id,
 195                         const wxString &value,
 196                         const wxPoint &pos,
 197                         const wxSize &size,
 198                         long style,
 199                         const wxValidator& validator,
 200                         const wxString &name )
 201     : wxScrollHelper(this)
 202 {
 203     Init();
 204
 205     Create( parent, id, value, pos, size, style, validator, name );
 206 }
 207
 208 bool wxTextCtrl::Create( wxWindow *parent,
 209                          wxWindowID id,
 210                          const wxString &value,
 211                          const wxPoint &pos,
 212                          const wxSize &size,
 213                          long style,
 214                          const wxValidator& validator,
 215                          const wxString &name )
 216 {
 217     if ((style & wxBORDER_MASK) == 0)
 218         style |= wxBORDER_SUNKEN;
 219
 220     if ((style & wxTE_MULTILINE) != 0)
 221         style |= wxALWAYS_SHOW_SB;
 222
 223     wxTextCtrlBase::Create( parent, id, wxDefaultPosition, size,
 224                               style|wxVSCROLL|wxHSCROLL|wxNO_FULL_REPAINT_ON_RESIZE );
 225
 226     SetBackgroundColour( *wxWHITE );
 227
 228     SetCursor( wxCursor( wxCURSOR_IBEAM ) );
 229
 230     SetValue( value );
 231
 232     wxSize size_best( DoGetBestSize() );
 233     wxSize new_size( size );
 234     if (new_size.x == -1)
 235         new_size.x = size_best.x;
 236     if (new_size.y == -1)
 237         new_size.y = size_best.y;
 238     if ((new_size.x != size.x) || (new_size.y != size.y))
 239         SetSize( new_size.x, new_size.y );
 240
 241     // We create an input handler since it might be useful
 242     CreateInputHandler(wxINP_HANDLER_TEXTCTRL);
 243
 244     return TRUE;
 245 }
 246
 247 //-----------------------------------------------------------------------------
 248 //  public methods
 249 //-----------------------------------------------------------------------------
 250
 251 wxString wxTextCtrl::GetValue() const
 252 {
 253     wxString ret;
 254     for (size_t i = 0; i < m_lines.GetCount(); i++)
 255     {
 256         ret += m_lines[i].m_text;
 257         if (i < m_lines.GetCount())
 258             ret += wxT('\n');
 259     }
 260
 261     return ret;
 262 }
 263
 264 void wxTextCtrl::SetValue(const wxString& value)
 265 {
 266     m_modified = TRUE;
 267     m_cursorX = 0;
 268     m_cursorY = 0;
 269     ClearSelection();
 270     m_lines.Clear();
 271     m_longestLine = 0;
 272
 273     int pos = 0;
 274     for (;;)
 275     {
 276         // TODO make more efficient
 277         wxString tmp = value;
 278         tmp.Remove( 0, pos );
 279         pos = tmp.Find( '\n' );
 280         if (pos == -1)
 281         {
 282             if (tmp.Len() > m_longestLine)
 283                 m_longestLine = tmp.Len();
 284
 285             m_lines.Add( new wxSourceLine( tmp ) );
 286             break;
 287
 288         }
 289         else
 290         {
 291             if (pos > m_longestLine)
 292                 m_longestLine = pos;
 293
 294             tmp.Remove( pos, tmp.Len()-pos );
 295             m_lines.Add( new wxSourceLine( tmp ) );
 296         }
 297     }
 298
 299     MyAdjustScrollbars();
 300
 301     Refresh();
 302 }
 303
 304 int wxTextCtrl::GetLineLength(long lineNo) const
 305 {
 306     if (lineNo >= (long)m_lines.GetCount())
 307         return 0;
 308
 309     return m_lines[lineNo].m_text.Len();
 310 }
 311
 312 wxString wxTextCtrl::GetLineText(long lineNo) const
 313 {
 314     if (lineNo >= (long)m_lines.GetCount())
 315         return wxT("");
 316
 317     return m_lines[lineNo].m_text;
 318 }
 319
 320 int wxTextCtrl::GetNumberOfLines() const
 321 {
 322     return  m_lines.GetCount();
 323 }
 324
 325 bool wxTextCtrl::IsModified() const
 326 {
 327     return m_modified;
 328 }
 329
 330 bool wxTextCtrl::IsEditable() const
 331 {
 332     return m_editable;
 333 }
 334
 335 void wxTextCtrl::GetSelection(long* from, long* to) const
 336 {
 337 }
 338
 339 void wxTextCtrl::Clear()
 340 {
 341     m_modified = TRUE;
 342     m_cursorX = 0;
 343     m_cursorY = 0;
 344     ClearSelection();
 345     m_lines.Clear();
 346     SetScrollbars( m_charWidth, m_lineHeight, 0, 0, 0, 0 );
 347     Refresh();
 348     m_undos.Clear();
 349 }
 350
 351 void wxTextCtrl::Replace(long from, long to, const wxString& value)
 352 {
 353 }
 354
 355 void wxTextCtrl::Remove(long from, long to)
 356 {
 357
 358 }
 359
 360 void wxTextCtrl::DiscardEdits()
 361 {
 362     ClearSelection();
 363     Refresh();
 364 }
 365
 366 void wxTextCtrl::SetMaxLength(unsigned long len)
 367 {
 368 }
 369
 370 void wxTextCtrl::WriteText(const wxString& text2)
 371 {
 372     m_modified = TRUE;
 373
 374     wxString text( text2 );
 375     wxArrayString lines;
 376     int pos;
 377     while ( (pos = text.Find('\n')) != -1 )
 378     {
 379        lines.Add( text.Left( pos ) );
 380        text.Remove( 0, pos+1 );
 381     }
 382     lines.Add( text );
 383     int count = (int)lines.GetCount();
 384
 385     wxString tmp1( m_lines[m_cursorY].m_text );
 386     wxString tmp2( tmp1 );
 387     int len = (int)tmp1.Len();
 388
 389     if (len < m_cursorX)
 390     {
 391         wxString tmp;
 392         for (int i = 0; i < m_cursorX-len; i++)
 393             tmp.Append( ' ' );
 394         m_lines[m_cursorY].m_text.Append( tmp );
 395         tmp1.Append( tmp );
 396         tmp2.Append( tmp );
 397     }
 398
 399     tmp1.Remove( m_cursorX );
 400     tmp2.Remove( 0, m_cursorX );
 401     tmp1.Append( lines[0] );
 402
 403     if (count == 1)
 404     {
 405         m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_LINE, m_cursorY, m_cursorY, this ) );
 406
 407         tmp1.Append( tmp2 );
 408         m_lines[m_cursorY].m_text = tmp1;
 409         RefreshLine( m_cursorY );
 410     }
 411     else
 412     {
 413         m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_PASTE, m_cursorY, m_cursorY+count-1, this ) );
 414
 415         m_lines[m_cursorY].m_text = tmp1;
 416         int i;
 417         for (i = 1; i < count; i++)
 418             m_lines.Insert( new wxSourceLine( lines[i] ), m_cursorY+i );
 419         m_lines[m_cursorY+i-1].m_text.Append( tmp2 );
 420
 421         MyAdjustScrollbars();
 422         RefreshDown( m_cursorY );
 423     }
 424 }
 425
 426 void wxTextCtrl::AppendText(const wxString& text)
 427 {
 428     // Leaves cursor garbage
 429
 430     m_cursorY = m_lines.GetCount()-1;
 431     m_cursorX = m_lines[m_cursorY].m_text.Len();
 432
 433     WriteText( text );
 434
 435     Refresh();
 436 }
 437
 438 bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style)
 439 {
 440     return FALSE;
 441 }
 442
 443 long wxTextCtrl::XYToPosition(long x, long y) const
 444 {
 445     long ret = 0;
 446
 447     for (size_t i = 0; i < m_lines.GetCount(); i++)
 448     {
 449         if (i < (size_t)y)
 450         {
 451             ret += m_lines[i].m_text.Len();
 452             continue;
 453         }
 454
 455         if ((size_t)x < m_lines[i].m_text.Len())
 456             return (ret + x);
 457         else
 458             return (ret + m_lines[i].m_text.Len());
 459     }
 460
 461     return ret;
 462 }
 463
 464 bool wxTextCtrl::PositionToXY(long pos, long *x, long *y) const
 465 {
 466     if (m_lines.GetCount() == 0)
 467     {
 468         if (x) *x = 0;
 469         if (y) *y = 0;
 470
 471         return (pos == 0);
 472     }
 473
 474     long xx = 0;
 475     long yy = 0;
 476
 477     for (size_t i = 0; i < m_lines.GetCount(); i++)
 478     {
 479         pos -= m_lines[i].m_text.Len();
 480         if (pos <= 0)
 481         {
 482             xx = -pos;
 483             if (x) *x = xx;
 484             if (y) *y = yy;
 485             return TRUE;
 486         }
 487         yy++;
 488     }
 489
 490     // Last pos
 491     xx = m_lines[ m_lines.GetCount()-1 ].m_text.Len();
 492     if (x) *x = xx;
 493     if (y) *y = yy;
 494
 495     return FALSE;
 496 }
 497
 498 void wxTextCtrl::ShowPosition(long pos)
 499 {
 500 }
 501
 502 void wxTextCtrl::Copy()
 503 {
 504     if (!HasSelection()) return;
 505
 506     wxString sel;
 507
 508     int selStartY = m_selStartY;
 509     int selEndY = m_selEndY;
 510     int selStartX = m_selStartX;
 511     int selEndX = m_selEndX;
 512
 513     if ((selStartY > selEndY) ||
 514         ((selStartY == selEndY) && (selStartX > selEndX)))
 515     {
 516         int tmp = selStartX;
 517         selStartX = selEndX;
 518         selEndX = tmp;
 519         tmp = selStartY;
 520         selStartY = selEndY;
 521         selEndY = tmp;
 522     }
 523
 524     if (selStartY == selEndY)
 525     {
 526         sel = m_lines[selStartY].m_text;
 527
 528         if (selStartX >= (int)sel.Len()) return;
 529         if (selEndX > (int)sel.Len())
 530             selEndX = sel.Len();
 531
 532         sel.Remove( selEndX, sel.Len()-selEndX );
 533         sel.Remove( 0, selStartX );
 534     }
 535     else
 536     {
 537         wxString tmp( m_lines[selStartY].m_text );
 538
 539         if (selStartX < (int)tmp.Len())
 540         {
 541             tmp.Remove( 0, selStartX );
 542             sel = tmp;
 543             sel.Append( "\n" );
 544         }
 545         for (int i = selStartY+1; i < selEndY; i++)
 546         {
 547             sel.Append( m_lines[i].m_text );
 548             sel.Append( "\n" );
 549         }
 550         tmp = m_lines[selEndY].m_text;
 551         if (selEndX > (int)tmp.Len())
 552             selEndX = tmp.Len();
 553         if (selEndX > 0)
 554         {
 555             tmp.Remove( selEndX, tmp.Len()-selEndX );
 556             sel.Append( tmp );
 557         }
 558     }
 559
 560     if (wxTheClipboard->Open())
 561     {
 562         wxTheClipboard->SetData( new wxTextDataObject( sel ) );
 563         wxTheClipboard->Close();
 564     }
 565 }
 566
 567 void wxTextCtrl::Cut()
 568 {
 569    Copy();
 570
 571    Delete();
 572 }
 573
 574 void wxTextCtrl::Paste()
 575 {
 576     Delete();
 577
 578     if (!wxTheClipboard->Open()) return;
 579
 580     if (!wxTheClipboard->IsSupported( wxDF_TEXT ))
 581     {
 582         wxTheClipboard->Close();
 583
 584         return;
 585     }
 586
 587     wxTextDataObject data;
 588
 589     bool ret = wxTheClipboard->GetData( data );
 590
 591     wxTheClipboard->Close();
 592
 593     if (!ret) return;
 594
 595     m_modified = TRUE;
 596
 597     wxString text( data.GetText() );
 598     wxArrayString lines;
 599     int pos;
 600     while ( (pos = text.Find('\n')) != -1 )
 601     {
 602        lines.Add( text.Left( pos ) );
 603        text.Remove( 0, pos+1 );
 604     }
 605     lines.Add( text );
 606     int count = (int)lines.GetCount();
 607
 608     wxString tmp1( m_lines[m_cursorY].m_text );
 609     wxString tmp2( tmp1 );
 610     int len = (int)tmp1.Len();
 611
 612     if (len < m_cursorX)
 613     {
 614         wxString tmp;
 615         for (int i = 0; i < m_cursorX-len; i++)
 616             tmp.Append( ' ' );
 617         m_lines[m_cursorY].m_text.Append( tmp );
 618         tmp1.Append( tmp );
 619         tmp2.Append( tmp );
 620     }
 621
 622     tmp1.Remove( m_cursorX );
 623     tmp2.Remove( 0, m_cursorX );
 624     tmp1.Append( lines[0] );
 625
 626     if (count == 1)
 627     {
 628         m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_LINE, m_cursorY, m_cursorY, this ) );
 629
 630         tmp1.Append( tmp2 );
 631         m_lines[m_cursorY].m_text = tmp1;
 632         RefreshLine( m_cursorY );
 633     }
 634     else
 635     {
 636         m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_PASTE, m_cursorY, m_cursorY+count-1, this ) );
 637
 638         m_lines[m_cursorY].m_text = tmp1;
 639         int i;
 640         for (i = 1; i < count; i++)
 641             m_lines.Insert( new wxSourceLine( lines[i] ), m_cursorY+i );
 642         m_lines[m_cursorY+i-1].m_text.Append( tmp2 );
 643
 644         MyAdjustScrollbars();
 645         RefreshDown( m_cursorY );
 646     }
 647 }
 648
 649 void wxTextCtrl::Undo()
 650 {
 651     if (m_undos.GetCount() == 0) return;
 652
 653     wxNode *node = m_undos.Nth( m_undos.GetCount()-1 );
 654     wxSourceUndoStep *undo = (wxSourceUndoStep*) node->Data();
 655
 656     undo->Undo();
 657
 658     delete node;
 659
 660     m_modified = TRUE;
 661 }
 662
 663 void wxTextCtrl::SetInsertionPoint(long pos)
 664 {
 665 }
 666
 667 void wxTextCtrl::SetInsertionPointEnd()
 668 {
 669 }
 670
 671 long wxTextCtrl::GetInsertionPoint() const
 672 {
 673     return XYToPosition( m_cursorX, m_cursorY );
 674 }
 675
 676 long wxTextCtrl::GetLastPosition() const
 677 {
 678     size_t lineCount = m_lines.GetCount() - 1;
 679     return XYToPosition( m_lines[lineCount].m_text.Len()-1, lineCount );
 680 }
 681
 682 void wxTextCtrl::SetSelection(long from, long to)
 683 {
 684 }
 685
 686 void wxTextCtrl::SetEditable(bool editable)
 687 {
 688     m_editable = editable;
 689 }
 690
 691 bool wxTextCtrl::Enable( bool enable )
 692 {
 693     return FALSE;
 694 }
 695
 696 bool wxTextCtrl::SetFont(const wxFont& font)
 697 {
 698     return FALSE;
 699 }
 700
 701 bool wxTextCtrl::SetForegroundColour(const wxColour& colour)
 702 {
 703     return wxWindow::SetForegroundColour( colour );
 704 }
 705
 706 bool wxTextCtrl::SetBackgroundColour(const wxColour& colour)
 707 {
 708     return wxWindow::SetBackgroundColour( colour );
 709 }
 710
 711 //-----------------------------------------------------------------------------
 712 //  private code and handlers
 713 //-----------------------------------------------------------------------------
 714
 715 void wxTextCtrl::SearchForBrackets()
 716 {
 717     int oldBracketY = m_bracketY;
 718     int oldBracketX = m_bracketX;
 719
 720     if (m_cursorY < 0 || m_cursorY >= (int)m_lines.GetCount()) return;
 721
 722     wxString current = m_lines[m_cursorY].m_text;
 723
 724     // reverse search first
 725
 726     char bracket = ' ';
 727
 728     if (m_cursorX > 0)
 729         bracket = current[m_cursorX-1];
 730
 731     if (bracket == ')' || bracket == ']' || bracket == '}')
 732     {
 733         char antibracket = '(';
 734         if (bracket == ']') antibracket = '[';
 735         if (bracket == '}') antibracket = '{';
 736
 737         int count = 1;
 738
 739         int endY = m_cursorY-60;
 740         if (endY < 0) endY = 0;
 741         for (int y = m_cursorY; y >= endY; y--)
 742         {
 743             current = m_lines[y].m_text;
 744             if (y == m_cursorY)
 745                 current.erase(m_cursorX-1,current.Len()-m_cursorX+1);
 746
 747             for (int n = current.Len()-1; n >= 0; n--)
 748             {
 749                 // ignore chars
 750                 if (current[n] == '\'')
 751                 {
 752                     for (int m = n-1; m >= 0; m--)
 753                     {
 754                         if (current[m] == '\'')
 755                         {
 756                             if (m == 0 || current[m-1] != '\\')
 757                                 break;
 758                         }
 759                         n = m-1;
 760                     }
 761                     continue;
 762                 }
 763
 764                 // ignore strings
 765                 if (current[n] == '\"')
 766                 {
 767                     for (int m = n-1; m >= 0; m--)
 768                     {
 769                         if (current[m] == '\"')
 770                         {
 771                             if (m == 0 || current[m-1] != '\\')
 772                                 break;
 773                         }
 774                         n = m-1;
 775                     }
 776                     continue;
 777                 }
 778
 779                 if (current[n] == antibracket)
 780                 {
 781                     count--;
 782                     if (count == 0)
 783                     {
 784                         m_bracketY = y;
 785                         m_bracketX = n;
 786                         if (oldBracketY != m_bracketY && oldBracketY != -1)
 787                             RefreshLine( oldBracketY );
 788                         if (m_bracketY != oldBracketY || m_bracketX != oldBracketX)
 789                             RefreshLine( m_bracketY );
 790                         return;
 791                     }
 792                 }
 793                 else if (current[n] == bracket)
 794                 {
 795                     count++;
 796                 }
 797             }
 798         }
 799     }
 800
 801     // then forward
 802
 803     bracket = ' ';
 804     if ((int)current.Len() > m_cursorX)
 805         bracket = current[m_cursorX];
 806     if (bracket == '(' || bracket == '[' || bracket == '{')
 807     {
 808         char antibracket = ')';
 809         if (bracket == '[') antibracket = ']';
 810         if (bracket == '{') antibracket = '}';
 811
 812         int count = 1;
 813
 814         int endY = m_cursorY+60;
 815         if (endY > (int)(m_lines.GetCount()-1)) endY = m_lines.GetCount()-1;
 816         for (int y = m_cursorY; y <= endY; y++)
 817         {
 818             current = m_lines[y].m_text;
 819             int start = 0;
 820             if (y == m_cursorY)
 821                 start = m_cursorX+1;
 822
 823             for (int n = start; n < (int)current.Len(); n++)
 824             {
 825                 // ignore chars
 826                 if (current[n] == '\'')
 827                 {
 828                     for (int m = n+1; m < (int)current.Len(); m++)
 829                     {
 830                         if (current[m] == '\'')
 831                         {
 832                             if (m == 0 || (current[m-1] != '\\') || (m >= 2 && current[m-2] == '\\'))
 833                                 break;
 834                         }
 835                         n = m+1;
 836                     }
 837                     continue;
 838                 }
 839
 840                 // ignore strings
 841                 if (current[n] == '\"')
 842                 {
 843                     for (int m = n+1; m < (int)current.Len(); m++)
 844                     {
 845                         if (current[m] == '\"')
 846                         {
 847                             if (m == 0 || (current[m-1] != '\\') || (m >= 2 && current[m-2] == '\\'))
 848                                 break;
 849                         }
 850                         n = m+1;
 851                     }
 852                     continue;
 853                 }
 854
 855                 if (current[n] == antibracket)
 856                 {
 857                     count--;
 858                     if (count == 0)
 859                     {
 860                         m_bracketY = y;
 861                         m_bracketX = n;
 862                         if (oldBracketY != m_bracketY && oldBracketY != -1)
 863                             RefreshLine( oldBracketY );
 864                         if (m_bracketY != oldBracketY || m_bracketX != oldBracketX)
 865                             RefreshLine( m_bracketY );
 866                         return;
 867                     }
 868                 }
 869                 else if (current[n] == bracket)
 870                 {
 871                     count++;
 872                 }
 873             }
 874         }
 875     }
 876
 877     if (oldBracketY != -1)
 878     {
 879         m_bracketY = -1;
 880         RefreshLine( oldBracketY );
 881     }
 882 }
 883
 884 void wxTextCtrl::Delete()
 885 {
 886     if (!HasSelection()) return;
 887
 888     m_modified = TRUE;
 889
 890     int selStartY = m_selStartY;
 891     int selEndY = m_selEndY;
 892     int selStartX = m_selStartX;
 893     int selEndX = m_selEndX;
 894
 895     if ((selStartY > selEndY) ||
 896         ((selStartY == selEndY) && (selStartX > selEndX)))
 897     {
 898         int tmp = selStartX;
 899         selStartX = selEndX;
 900         selEndX = tmp;
 901         tmp = selStartY;
 902         selStartY = selEndY;
 903         selEndY = tmp;
 904     }
 905
 906     int len = (int)m_lines[selStartY].m_text.Len();
 907
 908     if (selStartY == selEndY)
 909     {
 910         m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_LINE, selStartY, selStartY, this ) );
 911
 912         wxString tmp( m_lines[selStartY].m_text );
 913         if (selStartX < len)
 914         {
 915             if (selEndX > len)
 916                 selEndX = len;
 917             tmp.Remove( selStartX, selEndX-selStartX );
 918             m_lines[selStartY].m_text = tmp;
 919         }
 920         ClearSelection();
 921         m_cursorX = selStartX;
 922         RefreshLine( selStartY );
 923     }
 924     else
 925     {
 926         m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_DELETE, selStartY, selEndY, this ) );
 927
 928         if (selStartX < len)
 929             m_lines[selStartY].m_text.Remove( selStartX );
 930
 931         for (int i = 0; i < selEndY-selStartY-1; i++)
 932             m_lines.RemoveAt( selStartY+1 );
 933
 934         if (selEndX < (int)m_lines[selStartY+1].m_text.Len())
 935             m_lines[selStartY+1].m_text.Remove( 0, selEndX );
 936         else
 937             m_lines[selStartY+1].m_text.Remove( 0 );
 938
 939         m_lines[selStartY].m_text.Append( m_lines[selStartY+1].m_text );
 940         m_lines.RemoveAt( selStartY+1 );
 941
 942         ClearSelection();
 943         MoveCursor( selStartX, selStartY );
 944         MyAdjustScrollbars();
 945
 946         RefreshDown( selStartY );
 947     }
 948 }
 949
 950 void wxTextCtrl::DeleteLine()
 951 {
 952     if (HasSelection()) return;
 953
 954     if (m_cursorY < 0 || m_cursorY >= (int)m_lines.GetCount()-1) return;  // TODO
 955
 956     m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_DELETE, m_cursorY, m_cursorY+1, this ) );
 957
 958     m_lines.RemoveAt( m_cursorY );
 959     m_cursorX = 0;
 960     if (m_cursorY >= (int)m_lines.GetCount()) m_cursorY--;
 961
 962     MyAdjustScrollbars();
 963     RefreshDown( m_cursorY );
 964 }
 965
 966 void wxTextCtrl::DoChar( char c )
 967 {
 968     m_modified = TRUE;
 969
 970     m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_LINE, m_cursorY, m_cursorY, this ) );
 971
 972     wxString tmp( m_lines[m_cursorY].m_text );
 973     tmp.Trim();
 974     if (m_cursorX >= (int)tmp.Len())
 975     {
 976         int len = tmp.Len();
 977         for (int i = 0; i < m_cursorX - len; i++)
 978             tmp.Append( ' ' );
 979         tmp.Append( c );
 980     }
 981     else
 982     {
 983         if (m_overwrite)
 984             tmp.SetChar( m_cursorX, c );
 985         else
 986             tmp.insert( m_cursorX, 1, c );
 987     }
 988
 989     m_lines[m_cursorY].m_text = tmp;
 990
 991     if (tmp.Len() > m_longestLine)
 992     {
 993         m_longestLine = tmp.Len();
 994         MyAdjustScrollbars();
 995     }
 996
 997     m_cursorX++;
 998
 999     int y = m_cursorY*m_lineHeight;
1000     int x = (m_cursorX-1)*m_charWidth;
1001     CalcScrolledPosition( x, y, &x, &y );
1002     wxRect rect( x+2, y+2, 10000, m_lineHeight );
1003     Refresh( TRUE, &rect );
1004
1005     int size_x = 0;
1006     int size_y = 0;
1007     GetClientSize( &size_x, &size_y );
1008     size_x /= m_charWidth;
1009
1010     int view_x = 0;
1011     int view_y = 0;
1012     GetViewStart( &view_x, &view_y );
1013
1014     if (m_cursorX < view_x)
1015         Scroll( m_cursorX, -1 );
1016     else if (m_cursorX > view_x+size_x-1)
1017         Scroll( m_cursorX-size_x+1, -1 );
1018 }
1019
1020 void wxTextCtrl::DoBack()
1021 {
1022     m_modified = TRUE;
1023
1024     if (m_cursorX == 0)
1025     {
1026         if (m_cursorY == 0) return;
1027
1028         m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_BACK, m_cursorY-1, m_cursorY, this ) );
1029
1030         wxString tmp1( m_lines[m_cursorY-1].m_text );
1031         tmp1.Trim();
1032         wxString tmp2( m_lines[m_cursorY].m_text );
1033         tmp2.Trim();
1034         m_cursorX = tmp1.Len();
1035         m_cursorY--;
1036         tmp1.Append( tmp2 );
1037         m_lines[m_cursorY].m_text = tmp1;
1038         m_lines.RemoveAt( m_cursorY+1 );
1039
1040         MyAdjustScrollbars();
1041         RefreshDown( m_cursorY-1 );
1042     }
1043     else
1044     {
1045         m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_LINE, m_cursorY, m_cursorY, this ) );
1046
1047         if (m_cursorX <= (int)m_lines[m_cursorY].m_text.Len())
1048             m_lines[m_cursorY].m_text.Remove( m_cursorX-1, 1 );
1049         m_cursorX--;
1050
1051         int y = m_cursorY*m_lineHeight;
1052         int x = m_cursorX*m_charWidth;
1053         CalcScrolledPosition( x, y, &x, &y );
1054         wxRect rect( x+2, y+2, 10000, m_lineHeight );
1055         Refresh( TRUE, &rect );
1056     }
1057 }
1058
1059 void wxTextCtrl::DoDelete()
1060 {
1061     m_modified = TRUE;
1062
1063     wxString tmp( m_lines[m_cursorY].m_text );
1064     tmp.Trim();
1065     int len = (int)tmp.Len();
1066     if (m_cursorX >= len)
1067     {
1068         if (m_cursorY == (int)m_lines.GetCount()-1) return;
1069
1070         m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_DELETE, m_cursorY, m_cursorY+1, this ) );
1071
1072         for (int i = 0; i < (m_cursorX-len); i++)
1073             tmp += ' ';
1074
1075         tmp += m_lines[m_cursorY+1].m_text;
1076
1077         m_lines[m_cursorY] = tmp;
1078         m_lines.RemoveAt( m_cursorY+1 );
1079
1080         MyAdjustScrollbars();
1081         RefreshDown( m_cursorY );
1082     }
1083     else
1084     {
1085         m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_LINE, m_cursorY, m_cursorY, this ) );
1086
1087         tmp.Remove( m_cursorX, 1 );
1088         m_lines[m_cursorY].m_text = tmp;
1089
1090         int y = m_cursorY*m_lineHeight;
1091         int x = m_cursorX*m_charWidth;
1092         CalcScrolledPosition( x, y, &x, &y );
1093         wxRect rect( x+2, y+2, 10000, m_lineHeight );
1094         Refresh( TRUE, &rect );
1095     }
1096 }
1097
1098 void wxTextCtrl::DoReturn()
1099 {
1100     m_modified = TRUE;
1101
1102     m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_ENTER, m_cursorY, m_cursorY, this ) );
1103
1104     wxString tmp( m_lines[m_cursorY].m_text );
1105     size_t indent = tmp.find_first_not_of( ' ' );
1106     if (indent == wxSTRING_MAXLEN) indent = 0;
1107     tmp.Trim();
1108     if (m_cursorX >= (int)tmp.Len())
1109     {
1110         int cursorX = indent;
1111         int cursorY = m_cursorY + 1;
1112
1113         wxString new_tmp;
1114         for (size_t i = 0; i < indent; i++) new_tmp.Append( ' ' );
1115         m_lines.Insert( new wxSourceLine( new_tmp ), cursorY );
1116
1117         MyAdjustScrollbars();
1118         MoveCursor( cursorX, cursorY );
1119         RefreshDown( m_cursorY );
1120     }
1121     else
1122     {
1123         wxString tmp1( tmp );
1124         tmp1.Remove( m_cursorX, tmp.Len()-m_cursorX );
1125         m_lines[m_cursorY].m_text = tmp1;
1126
1127         wxString tmp2( tmp );
1128         tmp2.Remove( 0, m_cursorX );
1129
1130         int cursorX = indent;
1131         int cursorY = m_cursorY + 1;
1132
1133         wxString new_tmp;
1134         for (size_t i = 0; i < indent; i++) new_tmp.Append( ' ' );
1135         new_tmp.Append( tmp2 );
1136         m_lines.Insert( new wxSourceLine( new_tmp ), cursorY );
1137
1138         MyAdjustScrollbars();
1139         MoveCursor( cursorX, cursorY );
1140         RefreshDown( m_cursorY-1 );
1141     }
1142 }
1143
1144 void wxTextCtrl::DoDClick()
1145 {
1146     wxString line( m_lines[ m_cursorY ].m_text );
1147     if (m_cursorX >= (int)line.Len()) return;
1148     int p = m_cursorX;
1149     char ch = line[p];
1150     if (((ch >= 'a') && (ch <= 'z')) ||
1151         ((ch >= 'A') && (ch <= 'Z')) ||
1152         ((ch >= '0') && (ch <= '9')) ||
1153         (ch == '_'))
1154     {
1155         m_selStartY = m_cursorY;
1156         m_selEndY = m_cursorY;
1157         if (p > 0)
1158         {
1159             ch = line[p-1];
1160             while (((ch >= 'a') && (ch <= 'z')) ||
1161                    ((ch >= 'A') && (ch <= 'Z')) ||
1162                    ((ch >= '0') && (ch <= '9')) ||
1163                    (ch == '_'))
1164             {
1165                 p--;
1166                 if (p == 0) break;
1167                 ch = line[p-1];
1168             }
1169         }
1170         m_selStartX = p;
1171
1172         p = m_cursorX;
1173         if (p < (int)line.Len())
1174         {
1175             ch = line[p];
1176             while (((ch >= 'a') && (ch <= 'z')) ||
1177                    ((ch >= 'A') && (ch <= 'Z')) ||
1178                    ((ch >= '0') && (ch <= '9')) ||
1179                    (ch == '_'))
1180             {
1181                 if (p >= (int)line.Len()) break;
1182                 p++;
1183                 ch = line[p];
1184             }
1185         }
1186         m_selEndX = p;
1187         RefreshLine( m_cursorY );
1188     }
1189 }
1190
1191 wxString wxTextCtrl::GetNextToken( wxString &line, int &pos )
1192 {
1193     wxString ret;
1194     int len = (int)line.Len();
1195     for (int p = pos; p < len; p++)
1196     {
1197         if ((m_lang == wxSOURCE_LANG_PYTHON) || (m_lang == wxSOURCE_LANG_PERL))
1198         {
1199             if (line[p] == '#')
1200             {
1201                 for (int q = p; q < len; q++)
1202                     ret.Append( line[q] );
1203                 pos = p;
1204                 return ret;
1205             }
1206         }
1207         else
1208         {
1209             if ((line[p] == '/') && (p+1 < len) && (line[p+1] == '/'))
1210             {
1211                 for (int q = p; q < len; q++)
1212                     ret.Append( line[q] );
1213                 pos = p;
1214                 return ret;
1215             }
1216         }
1217
1218         if (line[p] == '"')
1219         {
1220             ret.Append( line[p] );
1221             for (int q = p+1; q < len; q++)
1222             {
1223                 ret.Append( line[q] );
1224                 if ((line[q] == '"') && ((line[q-1] != '\\') || (q >= 2 && line[q-2] == '\\')))
1225                    break;
1226             }
1227             pos = p;
1228             return ret;
1229         }
1230
1231         if (line[p] == '\'')
1232         {
1233             ret.Append( line[p] );
1234             for (int q = p+1; q < len; q++)
1235             {
1236                 ret.Append( line[q] );
1237                 if ((line[q] == '\'') && ((line[q-1] != '\\') || (q >= 2 && line[q-2] == '\\')))
1238                    break;
1239             }
1240             pos = p;
1241             return ret;
1242         }
1243
1244         if (((line[p] >= 'a') && (line[p] <= 'z')) ||
1245             ((line[p] >= 'A') && (line[p] <= 'Z')) ||
1246             (line[p] == '_') ||
1247             (line[p] == '#'))
1248         {
1249            ret.Append( line[p] );
1250            for (int q = p+1; q < len; q++)
1251            {
1252                 if (((line[q] >= 'a') && (line[q] <= 'z')) ||
1253                    ((line[q] >= 'A') && (line[q] <= 'Z')) ||
1254                    ((line[q] >= '0') && (line[q] <= '9')) ||
1255                    (line[q] == '_'))
1256                 {
1257                     ret.Append( line[q] );
1258                     continue;
1259                 }
1260                 else
1261                 {
1262                     pos = p;
1263                     return ret;
1264                 }
1265            }
1266            pos = p;
1267            return ret;
1268         }
1269     }
1270
1271     return ret;
1272 }
1273
1274 void wxTextCtrl::DrawLine( wxDC &dc, int x, int y, const wxString &line2, int lineNum )
1275 {
1276     int selStartY = m_selStartY;
1277     int selEndY = m_selEndY;
1278     int selStartX = m_selStartX;
1279     int selEndX = m_selEndX;
1280
1281     if ((selStartY > selEndY) ||
1282         ((selStartY == selEndY) && (selStartX > selEndX)))
1283     {
1284         int tmp = selStartX;
1285         selStartX = selEndX;
1286         selEndX = tmp;
1287         tmp = selStartY;
1288         selStartY = selEndY;
1289         selEndY = tmp;
1290     }
1291
1292     wxString line( line2 );
1293     if (HasFlag(wxTE_PASSWORD))
1294     {
1295         size_t len = line.Len();
1296         line = wxString( wxT('*'), len );
1297     }
1298
1299     wxString keyword( ' ', line.Len() );
1300     wxString define( ' ', line.Len() );
1301     wxString variable( ' ', line.Len() );
1302     wxString comment( ' ', line.Len() );
1303     wxString my_string( ' ', line.Len() );
1304
1305     if (lineNum == m_bracketY)
1306     {
1307         wxString red( ' ', line.Len() );
1308         if (m_bracketX < (int)line.Len())
1309         {
1310             red.SetChar( m_bracketX, line[m_bracketX] );
1311             line.SetChar( m_bracketX, ' ' );
1312             dc.SetTextForeground( *wxRED );
1313             dc.DrawText( red, x, y );
1314             dc.SetTextForeground( *wxBLACK );
1315         }
1316     }
1317
1318     int pos = 0;
1319     wxString token( GetNextToken( line, pos) );
1320     while (!token.IsNull())
1321     {
1322         if (m_keywords.Index( token ) != wxNOT_FOUND)
1323         {
1324             int end_pos = pos + (int)token.Len();
1325             for (int i = pos; i < end_pos; i++)
1326             {
1327                 keyword.SetChar( i, line[i] );
1328                 line.SetChar( i, ' ' );
1329             }
1330         } else
1331         if (m_defines.Index( token ) != wxNOT_FOUND)
1332         {
1333             int end_pos = pos + (int)token.Len();
1334             for (int i = pos; i < end_pos; i++)
1335             {
1336                 define.SetChar( i, line[i] );
1337                 line.SetChar( i, ' ' );
1338             }
1339         } else
1340         if ((m_variables.Index( token ) != wxNOT_FOUND) ||
1341             ((token.Len() > 2) && (token[0] == 'w') && (token[1] == 'x')))
1342         {
1343             int end_pos = pos + (int)token.Len();
1344             for (int i = pos; i < end_pos; i++)
1345             {
1346                 variable.SetChar( i, line[i] );
1347                 line.SetChar( i, ' ' );
1348             }
1349         } else
1350         if ((token.Len() >= 2) && (token[0] == '/') && (token[1] == '/') && (m_lang == wxSOURCE_LANG_CPP))
1351         {
1352             int end_pos = pos + (int)token.Len();
1353             for (int i = pos; i < end_pos; i++)
1354             {
1355                 comment.SetChar( i, line[i] );
1356                 line.SetChar( i, ' ' );
1357             }
1358         } else
1359         if ((token[0] == '#') &&
1360             ((m_lang == wxSOURCE_LANG_PYTHON) || (m_lang == wxSOURCE_LANG_PERL)))
1361         {
1362             int end_pos = pos + (int)token.Len();
1363             for (int i = pos; i < end_pos; i++)
1364             {
1365                 comment.SetChar( i, line[i] );
1366                 line.SetChar( i, ' ' );
1367             }
1368
1369         } else
1370         if ((token[0] == '"') || (token[0] == '\''))
1371         {
1372             int end_pos = pos + (int)token.Len();
1373             for (int i = pos; i < end_pos; i++)
1374             {
1375                 my_string.SetChar( i, line[i] );
1376                 line.SetChar( i, ' ' );
1377             }
1378         }
1379         pos += token.Len();
1380         token = GetNextToken( line, pos);
1381     }
1382
1383     if ((lineNum < selStartY) || (lineNum > selEndY))
1384     {
1385         dc.DrawText( line, x, y );
1386         dc.SetTextForeground( m_keywordColour );
1387         dc.DrawText( keyword, x, y );
1388         dc.SetTextForeground( m_defineColour );
1389         dc.DrawText( define, x, y );
1390         dc.SetTextForeground( m_variableColour );
1391         dc.DrawText( variable, x, y );
1392         dc.SetTextForeground( m_commentColour );
1393         dc.DrawText( comment, x, y );
1394         dc.SetTextForeground( m_stringColour );
1395         dc.DrawText( my_string, x, y );
1396         dc.SetTextForeground( *wxBLACK );
1397         return;
1398     }
1399
1400     if (selStartY == selEndY)
1401     {
1402         int i;
1403         wxString tmp1( line );
1404         wxString tmp2( line );
1405         dc.DrawRectangle( selStartX*m_charWidth+2, lineNum*m_lineHeight+2,
1406                           (selEndX-selStartX)*m_charWidth, m_lineHeight );
1407         for (i = selStartX; i < selEndX; i++)
1408             if ((int)tmp1.Len() > i)
1409                 tmp1.SetChar( i, ' ' );
1410         dc.DrawText( tmp1, x, y );
1411         for (i = 0; i < selStartX; i++)
1412             if ((int)tmp2.Len() > i)
1413                 tmp2.SetChar( i, ' ' );
1414         for (i = selEndX; i < (int)tmp2.Len(); i++)
1415             if ((int)tmp2.Len() > i)
1416                 tmp2.SetChar( i, ' ' );
1417         dc.SetTextForeground( *wxWHITE );
1418         dc.DrawText( tmp2, x, y );
1419         dc.SetTextForeground( *wxBLACK );
1420     } else
1421     if ((lineNum > selStartY) && (lineNum < selEndY))
1422     {
1423         dc.DrawRectangle( 0+2, lineNum*m_lineHeight+2, 10000, m_lineHeight );
1424         dc.SetTextForeground( *wxWHITE );
1425         dc.DrawText( line, x, y );
1426         dc.SetTextForeground( *wxBLACK );
1427     } else
1428     if (lineNum == selStartY)
1429     {
1430         int i;
1431         wxString tmp1( line );
1432         wxString tmp2( line );
1433         dc.DrawRectangle( selStartX*m_charWidth+2, lineNum*m_lineHeight+2,
1434                           10000, m_lineHeight );
1435         for (i = selStartX; i < (int)tmp1.Len(); i++)
1436             tmp1.SetChar( i, ' ' );
1437         dc.DrawText( tmp1, x, y );
1438         for (i = 0; i < selStartX; i++)
1439             if ((int)tmp2.Len() > i)
1440                 tmp2.SetChar( i, ' ' );
1441         dc.SetTextForeground( *wxWHITE );
1442         dc.DrawText( tmp2, x, y );
1443         dc.SetTextForeground( *wxBLACK );
1444     } else
1445     if (lineNum == selEndY)
1446     {
1447         int i;
1448         wxString tmp1( line );
1449         wxString tmp2( line );
1450         dc.DrawRectangle( 0+2, lineNum*m_lineHeight+2,
1451                           selEndX*m_charWidth, m_lineHeight );
1452         for (i = 0; i < selEndX; i++)
1453             if ((int)tmp1.Len() > i)
1454                tmp1.SetChar( i, ' ' );
1455         dc.DrawText( tmp1, x, y );
1456         for (i = selEndX; i < (int)tmp2.Len(); i++)
1457             tmp2.SetChar( i, ' ' );
1458         dc.SetTextForeground( *wxWHITE );
1459         dc.DrawText( tmp2, x, y );
1460         dc.SetTextForeground( *wxBLACK );
1461     }
1462
1463     dc.SetTextForeground( m_keywordColour );
1464     dc.DrawText( keyword, x, y );
1465     dc.SetTextForeground( m_defineColour );
1466     dc.DrawText( define, x, y );
1467     dc.SetTextForeground( m_variableColour );
1468     dc.DrawText( variable, x, y );
1469     dc.SetTextForeground( m_commentColour );
1470     dc.DrawText( comment, x, y );
1471     dc.SetTextForeground( m_stringColour );
1472     dc.DrawText( my_string, x, y );
1473     dc.SetTextForeground( *wxBLACK );
1474 }
1475
1476 void wxTextCtrl::OnPaint( wxPaintEvent &event )
1477 {
1478     wxPaintDC dc(this);
1479
1480     if (m_lines.GetCount() == 0) return;
1481
1482     PrepareDC( dc );
1483
1484     dc.SetFont( m_sourceFont );
1485
1486     int scroll_y = 0;
1487     GetViewStart( NULL, &scroll_y );
1488
1489     int size_x = 0;
1490     int size_y = 0;
1491     GetClientSize( &size_x, &size_y );
1492
1493     dc.SetPen( *wxTRANSPARENT_PEN );
1494     dc.SetBrush( wxBrush( wxTHEME_COLOUR(HIGHLIGHT), wxSOLID ) );
1495     int upper = wxMin( (int)m_lines.GetCount(), scroll_y+(size_y/m_lineHeight)+1 );
1496     for (int i = scroll_y; i < upper; i++)
1497     {
1498         int x = 0+2;
1499         int y = i*m_lineHeight+2;
1500         int w = 10000;
1501         int h = m_lineHeight;
1502         CalcScrolledPosition( x,y,&x,&y );
1503         if (IsExposed(x,y,w,h))
1504             DrawLine( dc, 0+2, i*m_lineHeight+2, m_lines[i].m_text, i );
1505     }
1506
1507     dc.SetBrush( *wxRED_BRUSH );
1508     dc.DrawRectangle( m_cursorX*m_charWidth+2, m_cursorY*m_lineHeight+2, 2, m_lineHeight );
1509 }
1510
1511 void wxTextCtrl::OnMouse( wxMouseEvent &event )
1512 {
1513     if (m_lines.GetCount() == 0) return;
1514
1515
1516 #if 0  // there is no middle button on iPAQs
1517     if (event.MiddleDown())
1518     {
1519         Paste( TRUE );
1520         return;
1521     }
1522 #endif
1523
1524     if (event.LeftDClick())
1525     {
1526         DoDClick();
1527         return;
1528     }
1529
1530     if (event.LeftDown())
1531     {
1532         m_capturing = TRUE;
1533         CaptureMouse();
1534     }
1535
1536     if (event.LeftUp())
1537     {
1538         m_capturing = FALSE;
1539         ReleaseMouse();
1540     }
1541
1542     if (event.LeftDown() ||
1543         (event.LeftIsDown() && m_capturing))
1544     {
1545         int x = event.GetX();
1546         int y = event.GetY();
1547         CalcUnscrolledPosition( x, y, &x, &y );
1548         x /= m_charWidth;
1549         y /= m_lineHeight;
1550         MoveCursor(
1551             wxMin( 1000, wxMax( 0, x ) ),
1552             wxMin( (int)m_lines.GetCount()-1, wxMax( 0, y ) ),
1553             event.ShiftDown() || !event.LeftDown() );
1554     }
1555 }
1556
1557 void wxTextCtrl::OnChar( wxKeyEvent &event )
1558 {
1559     if (m_lines.GetCount() == 0) return;
1560
1561     int size_x = 0;
1562     int size_y = 0;
1563     GetClientSize( &size_x, &size_y );
1564     size_x /= m_charWidth;
1565     size_y /= m_lineHeight;
1566     size_y--;
1567
1568     if (event.ShiftDown())
1569     {
1570         switch (event.GetKeyCode())
1571         {
1572             case '4': event.m_keyCode = WXK_LEFT;   break;
1573             case '8': event.m_keyCode = WXK_UP;     break;
1574             case '6': event.m_keyCode = WXK_RIGHT;  break;
1575             case '2': event.m_keyCode = WXK_DOWN;   break;
1576             case '9': event.m_keyCode = WXK_PRIOR;  break;
1577             case '3': event.m_keyCode = WXK_NEXT;   break;
1578             case '7': event.m_keyCode = WXK_HOME;   break;
1579             case '1': event.m_keyCode = WXK_END;    break;
1580             case '0': event.m_keyCode = WXK_INSERT; break;
1581         }
1582     }
1583
1584     switch (event.GetKeyCode())
1585     {
1586         case WXK_UP:
1587         {
1588             if (m_ignoreInput) return;
1589             if (m_cursorY > 0)
1590                 MoveCursor( m_cursorX, m_cursorY-1, event.ShiftDown() );
1591             m_ignoreInput = TRUE;
1592             return;
1593         }
1594         case WXK_DOWN:
1595         {
1596             if (m_ignoreInput) return;
1597             if (m_cursorY < (int)(m_lines.GetCount()-1))
1598                 MoveCursor( m_cursorX, m_cursorY+1, event.ShiftDown() );
1599             m_ignoreInput = TRUE;
1600             return;
1601         }
1602         case WXK_LEFT:
1603         {
1604             if (m_ignoreInput) return;
1605             if (m_cursorX > 0)
1606             {
1607                 MoveCursor( m_cursorX-1, m_cursorY, event.ShiftDown() );
1608             }
1609             else
1610             {
1611                 if (m_cursorY > 0)
1612                     MoveCursor( m_lines[m_cursorY-1].m_text.Len(), m_cursorY-1, event.ShiftDown() );
1613             }
1614             m_ignoreInput = TRUE;
1615             return;
1616         }
1617         case WXK_RIGHT:
1618         {
1619             if (m_ignoreInput) return;
1620             if (m_cursorX < 1000)
1621                 MoveCursor( m_cursorX+1, m_cursorY, event.ShiftDown() );
1622             m_ignoreInput = TRUE;
1623             return;
1624         }
1625         case WXK_HOME:
1626         {
1627             if (event.ControlDown())
1628                 MoveCursor( 0, 0, event.ShiftDown() );
1629             else
1630                 MoveCursor( 0, m_cursorY, event.ShiftDown() );
1631             return;
1632         }
1633         case WXK_END:
1634         {
1635             if (event.ControlDown())
1636                 MoveCursor( 0, m_lines.GetCount()-1, event.ShiftDown() );
1637             else
1638                 MoveCursor( m_lines[m_cursorY].m_text.Len(), m_cursorY, event.ShiftDown() );
1639             return;
1640         }
1641         case WXK_NEXT:
1642         {
1643             if (m_ignoreInput) return;
1644             MoveCursor( m_cursorX, wxMin( (int)(m_lines.GetCount()-1), m_cursorY+size_y ), event.ShiftDown() );
1645             m_ignoreInput = TRUE;
1646             return;
1647         }
1648         case WXK_PRIOR:
1649         {
1650             if (m_ignoreInput) return;
1651             MoveCursor( m_cursorX, wxMax( 0, m_cursorY-size_y ), event.ShiftDown() );
1652             m_ignoreInput = TRUE;
1653             return;
1654         }
1655         case WXK_INSERT:
1656         {
1657             if (event.ShiftDown())
1658                 Paste();
1659             else if (event.ControlDown())
1660                 Copy();
1661             else
1662                 m_overwrite = !m_overwrite;
1663             return;
1664         }
1665         case WXK_RETURN:
1666         {
1667             if (IsSingleLine())
1668             {
1669                 event.Skip();
1670                 return;
1671             }
1672
1673             if (HasSelection())
1674                 Delete();
1675             DoReturn();
1676             return;
1677         }
1678         case WXK_TAB:
1679         {
1680             if (HasSelection())
1681                 Delete();
1682             bool save_overwrite = m_overwrite;
1683             m_overwrite = FALSE;
1684             int i = 4-(m_cursorX % 4);
1685             if (i == 0) i = 4;
1686             for (int c = 0; c < i; c++)
1687                  DoChar( ' ' );
1688             m_overwrite = save_overwrite;
1689             return;
1690         }
1691         case WXK_BACK:
1692         {
1693             if (HasSelection())
1694                 Delete();
1695             else
1696                 DoBack();
1697             return;
1698         }
1699         case WXK_DELETE:
1700         {
1701             if (HasSelection())
1702                 Delete();
1703             else
1704                 DoDelete();
1705             return;
1706         }
1707         default:
1708         {
1709             if (  (event.KeyCode() >= 'a') &&
1710                   (event.KeyCode() <= 'z') &&
1711                   (event.AltDown()) )
1712             {
1713                 // Alt-F etc.
1714                 event.Skip();
1715                 return;
1716             }
1717
1718             if (  (event.KeyCode() >= 32) &&
1719                   (event.KeyCode() <= 255) &&
1720                  !(event.ControlDown() && !event.AltDown()) ) // filters out Ctrl-X but leaves Alt-Gr
1721             {
1722                 if (HasSelection())
1723                     Delete();
1724                 DoChar( (char) event.KeyCode() );
1725                 return;
1726             }
1727         }
1728     }
1729
1730     event.Skip();
1731 }
1732
1733 void wxTextCtrl::OnIdle( wxIdleEvent &event )
1734 {
1735     m_ignoreInput = FALSE;
1736
1737     SearchForBrackets();
1738
1739     event.Skip( TRUE );
1740 }
1741
1742 void wxTextCtrl::Indent()
1743 {
1744     int startY = m_cursorY;
1745     int endY = m_cursorY;
1746     if (HasSelection())
1747     {
1748         startY = m_selStartY;
1749         endY = m_selEndY;
1750         if (endY < startY)
1751         {
1752             int tmp = startY;
1753             startY = endY;
1754             endY = tmp;
1755         }
1756     }
1757
1758     m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_LINE, startY, endY, this ) );
1759
1760     for (int i = startY; i <= endY; i++)
1761     {
1762         m_lines[i].m_text.insert( 0u, "    " );
1763         RefreshLine( i );
1764     }
1765 }
1766
1767 void wxTextCtrl::Unindent()
1768 {
1769     int startY = m_cursorY;
1770     int endY = m_cursorY;
1771     if (HasSelection())
1772     {
1773         startY = m_selStartY;
1774         endY = m_selEndY;
1775         if (endY < startY)
1776         {
1777             int tmp = startY;
1778             startY = endY;
1779             endY = tmp;
1780         }
1781     }
1782
1783     m_undos.Append( new wxSourceUndoStep( wxSOURCE_UNDO_LINE, startY, endY, this ) );
1784
1785     for (int i = startY; i <= endY; i++)
1786     {
1787         for (int n = 0; n < 4; n++)
1788         {
1789             if (m_lines[i].m_text[0u] == ' ')
1790                 m_lines[i].m_text.erase(0u,1u);
1791         }
1792         RefreshLine( i );
1793     }
1794 }
1795 bool wxTextCtrl::HasSelection()
1796 {
1797     return ((m_selStartY != m_selEndY) || (m_selStartX != m_selEndX));
1798 }
1799
1800 void wxTextCtrl::ClearSelection()
1801 {
1802     m_selStartX = -1;
1803     m_selStartY = -1;
1804     m_selEndX = -1;
1805     m_selEndY = -1;
1806 }
1807
1808 void wxTextCtrl::RefreshLine( int n )
1809 {
1810     int y = n*m_lineHeight;
1811     int x = 0;
1812     CalcScrolledPosition( x, y, &x, &y );
1813     wxRect rect( 0+2, y+2, 10000, m_lineHeight );
1814     Refresh( TRUE, &rect );
1815 }
1816
1817 void wxTextCtrl::RefreshDown( int n )
1818 {
1819     int size_x = 0;
1820     int size_y = 0;
1821     GetClientSize( &size_x, &size_y );
1822
1823     int view_x = 0;
1824     int view_y = 0;
1825     GetViewStart( &view_x, &view_y );
1826
1827     if (n < view_y)
1828     {
1829         Refresh();
1830     }
1831     else
1832     {
1833         int y = n*m_lineHeight;
1834         int x = 0;
1835         CalcScrolledPosition( x, y, &x, &y );
1836
1837         wxRect rect( 0+2, y+2, 10000, size_y );
1838         Refresh( TRUE, &rect );
1839     }
1840 }
1841
1842 void wxTextCtrl::MoveCursor( int new_x, int new_y, bool shift, bool centre )
1843 {
1844     // if (IsSingleLine())
1845     {
1846         if (new_x > m_lines[new_y].m_text.Len())
1847             new_x = m_lines[new_y].m_text.Len();
1848     }
1849
1850     if ((new_x == m_cursorX) && (new_y == m_cursorY)) return;
1851
1852     bool no_cursor_refresh = FALSE;
1853
1854     if (shift)
1855     {
1856         int x,y,w,h;
1857
1858         if (!HasSelection())
1859         {
1860             m_selStartX = m_cursorX;
1861             m_selStartY = m_cursorY;
1862
1863             x = 0;
1864             w = 10000;
1865             if (new_y > m_selStartY)
1866             {
1867                 y = m_selStartY*m_lineHeight;
1868                 h = (new_y-m_selStartY+1)*m_lineHeight;
1869             }
1870             else if (new_y == m_selStartY)
1871             {
1872                 y = m_selStartY*m_lineHeight;
1873                 h = m_lineHeight;
1874             }
1875             else
1876             {
1877                 y = new_y*m_lineHeight;
1878                 h = (-new_y+m_selStartY+1)*m_lineHeight;
1879             }
1880
1881             no_cursor_refresh = TRUE;
1882             m_cursorX = new_x;
1883             m_cursorY = new_y;
1884         }
1885         else
1886         {
1887             if (new_y == m_selEndY)
1888             {
1889                 y = new_y *m_lineHeight;
1890                 h = m_lineHeight;
1891                 if (m_selEndX > new_x)
1892                 {
1893                     x = new_x*m_charWidth;
1894                     w = (m_selEndX-new_x)*m_charWidth;
1895                 }
1896                 else
1897                 {
1898                     x = m_selEndX*m_charWidth;
1899                     w = (-m_selEndX+new_x)*m_charWidth;
1900                 }
1901             }
1902             else
1903             {
1904                 x = 0;
1905                 w = 10000;
1906                 if (new_y > m_selEndY)
1907                 {
1908                     y = m_selEndY*m_lineHeight;
1909                     h = (new_y-m_selEndY+1) * m_lineHeight;
1910                 }
1911                 else
1912                 {
1913                     y = new_y*m_lineHeight;
1914                     h = (-new_y+m_selEndY+1) * m_lineHeight;
1915                 }
1916                 no_cursor_refresh = TRUE;
1917                 m_cursorX = new_x;
1918                 m_cursorY = new_y;
1919             }
1920         }
1921
1922         m_selEndX = new_x;
1923         m_selEndY = new_y;
1924
1925         CalcScrolledPosition( x, y, &x, &y );
1926         wxRect rect( x+2, y+2, w, h );
1927         Refresh( TRUE, &rect );
1928     }
1929     else
1930     {
1931         if (HasSelection())
1932         {
1933             int ry1 = m_selEndY;
1934             int ry2 = m_selStartY;
1935             m_selEndX = -1;
1936             m_selEndY = -1;
1937             m_selStartX = -1;
1938             m_selStartY = -1;
1939
1940             if (ry1 > ry2)
1941             {
1942                 int tmp = ry2;
1943                 ry2 = ry1;
1944                 ry1 = tmp;
1945             }
1946
1947             int x = 0;
1948             int y = ry1*m_lineHeight;
1949             CalcScrolledPosition( x, y, &x, &y );
1950             wxRect rect( 0+2, y+2, 10000, (ry2-ry1+1)*m_lineHeight );
1951
1952             Refresh( TRUE, &rect );
1953         }
1954     }
1955
1956 /*
1957     printf( "startx %d starty %d endx %d endy %d\n",
1958             m_selStartX, m_selStartY, m_selEndX, m_selEndY );
1959
1960     printf( "has %d\n", (int)HasSelection() );
1961 */
1962
1963     if (!no_cursor_refresh)
1964     {
1965         int x = m_cursorX*m_charWidth;
1966         int y = m_cursorY*m_lineHeight;
1967         CalcScrolledPosition( x, y, &x, &y );
1968         wxRect rect( x+2, y+2, 4, m_lineHeight+2 );
1969
1970         m_cursorX = new_x;
1971         m_cursorY = new_y;
1972
1973         Refresh( TRUE, &rect );
1974
1975         wxClientDC dc(this);
1976         PrepareDC( dc );
1977         dc.SetPen( *wxTRANSPARENT_PEN );
1978         dc.SetBrush( *wxRED_BRUSH );
1979         dc.DrawRectangle( m_cursorX*m_charWidth+2, m_cursorY*m_lineHeight+2, 2, m_lineHeight );
1980     }
1981
1982     int size_x = 0;
1983     int size_y = 0;
1984     GetClientSize( &size_x, &size_y );
1985     size_x /= m_charWidth;
1986     size_y /= m_lineHeight;
1987
1988     int view_x = 0;
1989     int view_y = 0;
1990     GetViewStart( &view_x, &view_y );
1991
1992     if (centre)
1993     {
1994         int sy = m_cursorY - (size_y/2);
1995         if (sy < 0) sy = 0;
1996         Scroll( -1, sy );
1997     }
1998     else
1999     {
2000         if (m_cursorY < view_y)
2001             Scroll( -1, m_cursorY );
2002         else if (m_cursorY > view_y+size_y-1)
2003             Scroll( -1, m_cursorY-size_y+1 );
2004     }
2005
2006     if (m_cursorX < view_x)
2007         Scroll( m_cursorX, -1 );
2008     else if (m_cursorX > view_x+size_x-1)
2009         Scroll( m_cursorX-size_x+1, -1 );
2010 }
2011
2012 void wxTextCtrl::MyAdjustScrollbars()
2013 {
2014     if (IsSingleLine())
2015         return;
2016
2017     int y_range = m_lines.GetCount();
2018
2019     int height = 0;
2020     GetClientSize( NULL, &height );
2021     height -= 4;
2022     if (height >= m_lines.GetCount() *m_lineHeight)
2023         y_range = 0;
2024
2025     int view_x = 0;
2026     int view_y = 0;
2027     GetViewStart( &view_x, &view_y );
2028
2029     SetScrollbars( m_charWidth, m_lineHeight, m_longestLine+2, y_range, view_x, view_y );
2030 }
2031
2032 //-----------------------------------------------------------------------------
2033 //  clipboard handlers
2034 //-----------------------------------------------------------------------------
2035
2036 void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
2037 {
2038     Cut();
2039 }
2040
2041 void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
2042 {
2043     Copy();
2044 }
2045
2046 void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
2047 {
2048     Paste();
2049 }
2050
2051 void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
2052 {
2053     Undo();
2054 }
2055
2056 void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
2057 {
2058     Redo();
2059 }
2060
2061 void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
2062 {
2063     event.Enable( CanCut() );
2064 }
2065
2066 void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
2067 {
2068     event.Enable( CanCopy() );
2069 }
2070
2071 void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
2072 {
2073     event.Enable( CanPaste() );
2074 }
2075
2076 void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
2077 {
2078     event.Enable( CanUndo() );
2079 }
2080
2081 void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
2082 {
2083     event.Enable( CanRedo() );
2084 }
2085
2086 wxSize wxTextCtrl::DoGetBestSize() const
2087 {
2088     if (IsSingleLine())
2089     {
2090         wxSize ret(80, m_lineHeight + 4);
2091
2092         if (HasFlag(wxBORDER_SUNKEN) || HasFlag(wxBORDER_RAISED))
2093             ret.y += 4;
2094
2095         if (HasFlag(wxBORDER_SIMPLE))
2096             ret.y += 2;
2097
2098         return ret;
2099     }
2100     else
2101     {
2102         return wxSize(80, 60);
2103     }
2104 }
2105
2106 // ----------------------------------------------------------------------------
2107 // freeze/thaw
2108 // ----------------------------------------------------------------------------
2109
2110 void wxTextCtrl::Freeze()
2111 {
2112 }
2113
2114 void wxTextCtrl::Thaw()
2115 {
2116 }
2117
2118 // ----------------------------------------------------------------------------
2119 // text control scrolling
2120 // ----------------------------------------------------------------------------
2121
2122 bool wxTextCtrl::ScrollLines(int lines)
2123 {
2124     wxFAIL_MSG( "wxTextCtrl::ScrollLines not implemented");
2125
2126     return FALSE;
2127 }
2128
2129 bool wxTextCtrl::ScrollPages(int pages)
2130 {
2131     wxFAIL_MSG( "wxTextCtrl::ScrollPages not implemented");
2132
2133     return FALSE;
2134 }
2135