samples/richedit/wxlwindow.cpp

   1 /*-*- c++ -*-********************************************************
   2  * wxLwindow.h : a scrolled Window for displaying/entering rich text*
   3  *                                                                  *
   4  * (C) 1998, 1999 by Karsten Ballüder (karsten@phy.hw.ac.uk)        *
   5  *                                                                  *
   6  * $Id$
   7  *******************************************************************/
   8
   9 // ============================================================================
  10 // declarations
  11 // ============================================================================
  12
  13 // ----------------------------------------------------------------------------
  14 // headers
  15 // ----------------------------------------------------------------------------
  16
  17 #ifdef __GNUG__
  18 #   pragma implementation "wxlwindow.h"
  19 #endif
  20
  21 #include <wx/wxprec.h>
  22
  23 #ifdef __BORLANDC__
  24 #  pragma hdrstop
  25 #endif
  26
  27 #include "Mpch.h"
  28
  29 #ifdef M_BASEDIR
  30 #   ifndef USE_PCH
  31 #     include "Mcommon.h"
  32 #     include "gui/wxMenuDefs.h"
  33 #     include "gui/wxMApp.h"
  34 #   endif // USE_PCH
  35 #   include "gui/wxlwindow.h"
  36 #   include "gui/wxlparser.h"
  37
  38 #   include "MDialogs.h"
  39 #   include "strutil.h"
  40 #else
  41 #   ifdef   __WXMSW__
  42 #       include <wx/msw/private.h>
  43 #   endif
  44
  45 #   include "wxlwindow.h"
  46 #   include "wxlparser.h"
  47 #endif
  48
  49 #include <wx/clipbrd.h>
  50 #include <wx/textctrl.h>
  51 #include <wx/dataobj.h>
  52
  53 #ifdef WXLAYOUT_USE_CARET
  54 #   include <wx/caret.h>
  55 #endif // WXLAYOUT_USE_CARET
  56
  57 #include <ctype.h>
  58
  59 // ----------------------------------------------------------------------------
  60 // macros
  61 // ----------------------------------------------------------------------------
  62
  63 #ifdef DEBUG
  64 #  define   WXLO_DEBUG(x)      wxLogDebug x
  65 #else
  66 #  define WXLO_DEBUG(x)
  67 #endif
  68
  69 // ----------------------------------------------------------------------------
  70 // constants
  71 // ----------------------------------------------------------------------------
  72
  73 /// offsets to put a nice frame around text
  74 #define WXLO_XOFFSET   4
  75 #define WXLO_YOFFSET   4
  76
  77 /// offset to the right and bottom for when to redraw scrollbars
  78 #define   WXLO_ROFFSET   20
  79 #define   WXLO_BOFFSET   20
  80
  81 /// scroll margins when selecting with the mouse
  82 #define WXLO_SCROLLMARGIN_X   10
  83 #define WXLO_SCROLLMARGIN_Y   10
  84
  85 /// the size of one scrollbar page in pixels
  86 static const int X_SCROLL_PAGE = 10;
  87 static const int Y_SCROLL_PAGE = 20;
  88
  89
  90
  91 #define wxUSE_PRIVATE_CLIPBOARD_FORMAT 0
  92
  93 // ----------------------------------------------------------------------------
  94 // event tables
  95 // ----------------------------------------------------------------------------
  96
  97 BEGIN_EVENT_TABLE(wxLayoutWindow,wxScrolledWindow)
  98    EVT_SIZE    (wxLayoutWindow::OnSize)
  99
 100    EVT_PAINT    (wxLayoutWindow::OnPaint)
 101
 102    EVT_CHAR     (wxLayoutWindow::OnChar)
 103    EVT_KEY_UP   (wxLayoutWindow::OnKeyUp)
 104
 105    EVT_LEFT_DOWN(wxLayoutWindow::OnLeftMouseDown)
 106    EVT_LEFT_UP(wxLayoutWindow::OnLeftMouseUp)
 107    EVT_RIGHT_DOWN(wxLayoutWindow::OnRightMouseClick)
 108    EVT_LEFT_DCLICK(wxLayoutWindow::OnMouseDblClick)
 109    EVT_MIDDLE_DOWN(wxLayoutWindow::OnMiddleMouseDown)
 110    EVT_MOTION    (wxLayoutWindow::OnMouseMove)
 111
 112    EVT_UPDATE_UI(WXLOWIN_MENU_UNDERLINE, wxLayoutWindow::OnUpdateMenuUnderline)
 113    EVT_UPDATE_UI(WXLOWIN_MENU_BOLD, wxLayoutWindow::OnUpdateMenuBold)
 114    EVT_UPDATE_UI(WXLOWIN_MENU_ITALICS, wxLayoutWindow::OnUpdateMenuItalic)
 115    EVT_MENU_RANGE(WXLOWIN_MENU_FIRST, WXLOWIN_MENU_LAST, wxLayoutWindow::OnMenu)
 116
 117    EVT_SET_FOCUS(wxLayoutWindow::OnSetFocus)
 118    EVT_KILL_FOCUS(wxLayoutWindow::OnKillFocus)
 119
 120 //   EVT_IDLE(wxLayoutWindow::ResizeScrollbars)
 121 END_EVENT_TABLE()
 122
 123 // ----------------------------------------------------------------------------
 124 // function prototypes
 125 // ----------------------------------------------------------------------------
 126
 127 /// returns TRUE if keyCode is one of arrows/home/end/page{up|down} keys
 128 static bool IsDirectionKey(long keyCode);
 129
 130 // ============================================================================
 131 // implementation
 132 // ============================================================================
 133
 134 #ifndef wxWANTS_CHARS
 135 #   define wxWANTS_CHARS 0
 136 #endif
 137
 138 // ----------------------------------------------------------------------------
 139 // wxLayoutWindow
 140 // ----------------------------------------------------------------------------
 141
 142 wxLayoutWindow::wxLayoutWindow(wxWindow *parent)
 143               : wxScrolledWindow(parent, -1,
 144                                  wxDefaultPosition, wxDefaultSize,
 145                                  wxHSCROLL | wxVSCROLL |
 146                                  wxBORDER |
 147                                  wxWANTS_CHARS),
 148                 m_llist(NULL)
 149 {
 150    SetStatusBar(NULL); // don't use statusbar
 151    m_Editable = false;
 152    m_doSendEvents = false;
 153    m_ViewStartX = 0; m_ViewStartY = 0;
 154    m_DoPopupMenu = true;
 155    m_PopupMenu = MakeFormatMenu();
 156    m_memDC = new wxMemoryDC;
 157    m_bitmap = new wxBitmap(4,4);
 158    m_bitmapSize = wxPoint(4,4);
 159    m_llist = new wxLayoutList();
 160    m_BGbitmap = NULL;
 161    m_ScrollToCursor = false;
 162 #ifndef __WXMSW__
 163    m_FocusFollowMode = false;
 164 #endif
 165    SetWrapMargin(0);
 166
 167    // no scrollbars initially
 168    m_hasHScrollbar =
 169    m_hasVScrollbar = false;
 170
 171    m_Selecting = false;
 172
 173 #ifdef WXLAYOUT_USE_CARET
 174    // FIXME cursor size shouldn't be hardcoded
 175    wxCaret *caret = new wxCaret(this, 2, 20);
 176    SetCaret(caret);
 177    m_llist->SetCaret(caret);
 178 #endif // WXLAYOUT_USE_CARET
 179
 180    m_HaveFocus = FALSE;
 181    m_HandCursor = FALSE;
 182    m_CursorVisibility = -1;
 183    SetCursor(wxCURSOR_IBEAM);
 184    SetDirty();
 185
 186    // at least under Windows, this should be the default behaviour
 187    m_AutoDeleteSelection = TRUE;
 188 }
 189
 190 wxLayoutWindow::~wxLayoutWindow()
 191 {
 192    delete m_memDC; // deletes bitmap automatically (?)
 193    delete m_bitmap;
 194    delete m_llist;
 195    delete m_PopupMenu;
 196    SetBackgroundBitmap(NULL);
 197 }
 198
 199 void
 200 wxLayoutWindow::Clear(int family,
 201                       int size,
 202                       int style,
 203                       int weight,
 204                       int underline,
 205                       wxColour *fg,
 206                       wxColour *bg)
 207 {
 208    GetLayoutList()->Clear(family,size,style,weight,underline,fg,bg);
 209    SetBackgroundColour(GetLayoutList()->GetDefaultStyleInfo().GetBGColour());
 210    wxScrolledWindow::Clear();
 211    ResizeScrollbars(true);
 212    SetDirty();
 213    SetModified(FALSE);
 214    if ( m_Editable )
 215       m_CursorVisibility = 1;
 216
 217 #ifdef WXLAYOUT_USE_CARET
 218    if ( m_CursorVisibility == 1 )
 219       GetCaret()->Show();
 220 #endif // WXLAYOUT_USE_CARET
 221
 222    RequestUpdate((wxRect *)NULL);
 223 }
 224
 225 void wxLayoutWindow::Refresh(bool eraseBackground, const wxRect *rect)
 226 {
 227    wxScrolledWindow::Refresh(eraseBackground, rect);
 228 }
 229
 230 void
 231 wxLayoutWindow::OnMouse(int eventId, wxMouseEvent& event)
 232 {
 233    wxClientDC dc( this );
 234    PrepareDC( dc );
 235    if ( eventId != WXLOWIN_MENU_MOUSEMOVE
 236 #ifndef __WXMSW__
 237         || m_FocusFollowMode
 238 #endif
 239       )
 240       SetFocus();
 241
 242    wxPoint findPos;
 243    findPos.x = dc.DeviceToLogicalX(event.GetX());
 244    findPos.y = dc.DeviceToLogicalY(event.GetY());
 245
 246    findPos.x -= WXLO_XOFFSET;
 247    findPos.y -= WXLO_YOFFSET;
 248
 249    if(findPos.x < 0)
 250       findPos.x = 0;
 251    if(findPos.y < 0)
 252       findPos.y = 0;
 253
 254    m_ClickPosition = wxPoint(event.GetX(), event.GetY());
 255
 256    // Scroll the window if the mouse is at the end of it:
 257    if(m_Selecting && eventId == WXLOWIN_MENU_MOUSEMOVE)
 258    {
 259       //WXLO_DEBUG(("selecting at : %d/%d", (int) event.GetX(), (int)event.GetY()));
 260       int left, top;
 261       ViewStart(&left, &top);
 262       wxSize size = GetClientSize();
 263       int xdelta, ydelta;
 264
 265       if(event.GetX() < WXLO_SCROLLMARGIN_X)
 266          xdelta = -(WXLO_SCROLLMARGIN_X-event.GetX());
 267       else if(event.GetX() > size.x-WXLO_SCROLLMARGIN_X)
 268          xdelta = event.GetX()-size.x+WXLO_SCROLLMARGIN_X;
 269       else
 270          xdelta = 0;
 271       if(event.GetY() < WXLO_SCROLLMARGIN_Y)
 272          ydelta = -(WXLO_SCROLLMARGIN_Y-event.GetY());
 273       else if(event.GetY() > size.y-WXLO_SCROLLMARGIN_Y)
 274          ydelta = event.GetY()-size.y+WXLO_SCROLLMARGIN_Y;
 275       else
 276          ydelta = 0;
 277
 278       //WXLO_DEBUG(("xdelta: %d", (int) xdelta));
 279       if(xdelta != 0 || ydelta != 0)
 280       {
 281          top  += ydelta; if(top < 0) top = 0;
 282          left += xdelta; if(left < 0) left = 0;
 283          Scroll(left, top);
 284       }
 285    }
 286
 287    wxPoint cursorPos;
 288    bool found;
 289    wxLayoutObject *obj = m_llist->FindObjectScreen(dc, findPos,
 290                                                    &cursorPos, &found);
 291    wxLayoutObject::UserData *u = obj ? obj->GetUserData() : NULL;
 292
 293    // has the mouse only been moved?
 294    switch ( eventId )
 295    {
 296    case WXLOWIN_MENU_MOUSEMOVE:
 297    {
 298       // this variables is used to only erase the message in the status
 299       // bar if we had put it there previously - otherwise empting status
 300       // bar might be undesirable
 301       static bool s_hasPutMessageInStatusBar = false;
 302
 303       // found is only true if we are really over an object, not just
 304       // behind it
 305       if(found && u && ! m_Selecting)
 306       {
 307          if(!m_HandCursor)
 308             SetCursor(wxCURSOR_HAND);
 309          m_HandCursor = TRUE;
 310          if(m_StatusBar && m_StatusFieldLabel != -1)
 311          {
 312             const wxString &label = u->GetLabel();
 313             if(label.Length())
 314             {
 315                m_StatusBar->SetStatusText(label,
 316                                           m_StatusFieldLabel);
 317                s_hasPutMessageInStatusBar = true;
 318             }
 319          }
 320       }
 321       else
 322       {
 323          if(m_HandCursor)
 324             SetCursor(wxCURSOR_IBEAM);
 325          m_HandCursor = FALSE;
 326          if( m_StatusBar && m_StatusFieldLabel != -1 &&
 327              s_hasPutMessageInStatusBar )
 328          {
 329             m_StatusBar->SetStatusText("", m_StatusFieldLabel);
 330          }
 331       }
 332    }
 333
 334    // selecting?
 335    if ( event.LeftIsDown() )
 336    {
 337       // m_Selecting might not be set if the button got pressed
 338       // outside this window, so check for it:
 339       if( m_Selecting )
 340       {
 341          m_llist->ContinueSelection(cursorPos, m_ClickPosition);
 342          RequestUpdate();  // TODO: we don't have to redraw everything!
 343       }
 344    }
 345
 346    if ( u )
 347    {
 348       u->DecRef();
 349       u = NULL;
 350    }
 351    break;
 352
 353    case WXLOWIN_MENU_LDOWN:
 354    {
 355       // always move cursor to mouse click:
 356       m_llist->MoveCursorTo(cursorPos);
 357
 358       // clicking a mouse removes the selection
 359       if ( m_llist->HasSelection() )
 360       {
 361          m_llist->DiscardSelection();
 362          m_Selecting = false;
 363          RequestUpdate();     // TODO: we don't have to redraw everything!
 364       }
 365
 366       // Calculate where the top of the visible area is:
 367       int x0, y0;
 368       ViewStart(&x0,&y0);
 369       int dx, dy;
 370       GetScrollPixelsPerUnit(&dx, &dy);
 371       x0 *= dx; y0 *= dy;
 372
 373       wxPoint offset(-x0+WXLO_XOFFSET, -y0+WXLO_YOFFSET);
 374
 375       if(m_CursorVisibility == -1)
 376          m_CursorVisibility = 1;
 377 #ifdef WXLAYOUT_USE_CARET
 378       if ( m_CursorVisibility == 1 )
 379          GetCaret()->Show();
 380 #endif // WXLAYOUT_USE_CARET
 381
 382       if(m_CursorVisibility)
 383       {
 384          // draw a thick cursor for editable windows with focus
 385          m_llist->DrawCursor(dc, m_HaveFocus && IsEditable(), offset);
 386       }
 387
 388 #ifdef __WXGTK__
 389       RequestUpdate(); // RequestUpdate suppresses flicker under GTK
 390 #endif // wxGTK
 391
 392       // start selection
 393       m_llist->StartSelection(wxPoint(-1, -1), m_ClickPosition);
 394       m_Selecting = true;
 395    }
 396    break;
 397
 398    case WXLOWIN_MENU_LUP:
 399       if ( m_Selecting )
 400       {
 401          // end selection at the cursor position corresponding to the
 402          // current mouse position, but don´t move cursor there.
 403          m_llist->EndSelection(cursorPos,m_ClickPosition);
 404          m_Selecting = false;
 405
 406          RequestUpdate();     // TODO: we don't have to redraw everything!
 407       }
 408       break;
 409
 410    case WXLOWIN_MENU_MDOWN:
 411       Paste(TRUE);
 412       break;
 413
 414    case WXLOWIN_MENU_DBLCLICK:
 415       // select a word under cursor
 416       m_llist->MoveCursorTo(cursorPos);
 417       m_llist->MoveCursorWord(-1);
 418       m_llist->StartSelection();
 419       m_llist->MoveCursorWord(1, false);
 420       m_llist->EndSelection();
 421       m_Selecting = false;
 422       RequestUpdate();     // TODO: we don't have to redraw everything!
 423       break;
 424    }
 425
 426    // notify about mouse events?
 427    if( m_doSendEvents )
 428    {
 429       // only do the menu if activated, editable and not on a clickable object
 430       if(eventId == WXLOWIN_MENU_RCLICK
 431          && IsEditable()
 432          && (! obj || u == NULL))
 433       {
 434          PopupMenu(m_PopupMenu, m_ClickPosition.x, m_ClickPosition.y);
 435          if(u) u->DecRef();
 436          return;
 437       }
 438
 439       // find the object at this position
 440       if(obj)
 441       {
 442          wxCommandEvent commandEvent(wxEVT_COMMAND_MENU_SELECTED, eventId);
 443          commandEvent.SetEventObject( this );
 444          commandEvent.SetClientData((char *)obj);
 445          GetEventHandler()->ProcessEvent(commandEvent);
 446       }
 447    }
 448
 449    if( u ) u->DecRef();
 450 }
 451
 452 // ----------------------------------------------------------------------------
 453 // keyboard handling.
 454 // ----------------------------------------------------------------------------
 455
 456 void
 457 wxLayoutWindow::OnChar(wxKeyEvent& event)
 458 {
 459    int keyCode = event.KeyCode();
 460    bool ctrlDown = event.ControlDown();
 461
 462 #ifdef WXLAYOUT_DEBUG
 463    if(keyCode == WXK_F1)
 464    {
 465       m_llist->Debug();
 466       return;
 467    }
 468 #endif
 469
 470    // Force m_Selecting to be false if shift is no longer
 471    // pressed. OnKeyUp() cannot catch all Shift-Up events.
 472    if(m_Selecting && !event.ShiftDown())
 473    {
 474       m_Selecting = false;
 475       m_llist->EndSelection();
 476       m_llist->DiscardSelection(); //FIXME: correct?
 477    }
 478
 479    // If we deleted the selection here, we must not execute the
 480    // deletion in Delete/Backspace handling.
 481    bool deletedSelection = false;
 482    // pressing any non-arrow key optionally replaces the selection:
 483    if(m_AutoDeleteSelection
 484       && !m_Selecting
 485       && m_llist->HasSelection()
 486       && ! IsDirectionKey(keyCode)
 487       && ! (event.AltDown() || ctrlDown)
 488       )
 489    {
 490       m_llist->DeleteSelection();
 491       deletedSelection = true;
 492       SetDirty();
 493    }
 494
 495    // <Shift>+<arrow> starts selection
 496    if ( IsDirectionKey(keyCode) )
 497    {
 498       // just continue the old selection
 499       if ( m_Selecting && event.ShiftDown() )
 500             m_llist->ContinueSelection();
 501       else
 502       {
 503          m_llist->DiscardSelection();
 504          m_Selecting = false;
 505          if( event.ShiftDown() )
 506          {
 507             m_Selecting = true;
 508             m_llist->StartSelection();
 509          }
 510       }
 511    }
 512
 513    // If needed, make cursor visible:
 514    if(m_CursorVisibility == -1)
 515       m_CursorVisibility = 1;
 516
 517    /* These two nested switches work like this:
 518       The first one processes all non-editing keycodes, to move the
 519       cursor, etc. It's default will process all keycodes causing
 520       modifications to the buffer, but only if editing is allowed.
 521    */
 522    switch(keyCode)
 523    {
 524    case WXK_RIGHT:
 525       if ( ctrlDown )
 526          m_llist->MoveCursorWord(1);
 527       else
 528          m_llist->MoveCursorHorizontally(1);
 529       break;
 530    case WXK_LEFT:
 531       if ( ctrlDown )
 532          m_llist->MoveCursorWord(-1);
 533       else
 534          m_llist->MoveCursorHorizontally(-1);
 535       break;
 536    case WXK_UP:
 537       m_llist->MoveCursorVertically(-1);
 538       break;
 539    case WXK_DOWN:
 540       m_llist->MoveCursorVertically(1);
 541       break;
 542    case WXK_PRIOR:
 543       m_llist->MoveCursorVertically(-Y_SCROLL_PAGE);
 544       break;
 545    case WXK_NEXT:
 546       m_llist->MoveCursorVertically(Y_SCROLL_PAGE);
 547       break;
 548    case WXK_HOME:
 549       if ( ctrlDown )
 550          m_llist->MoveCursorTo(wxPoint(0, 0));
 551       else
 552          m_llist->MoveCursorToBeginOfLine();
 553       break;
 554    case WXK_END:
 555       if ( ctrlDown )
 556          m_llist->MoveCursorToEnd();
 557       else
 558          m_llist->MoveCursorToEndOfLine();
 559       break;
 560    default:
 561
 562       if(ctrlDown && ! IsEditable())
 563          switch(keyCode)
 564          {
 565          case 'c':
 566             // this should work even in read-only mode
 567             Copy();
 568             break;
 569          case 's': // search
 570             Find("");
 571             break;
 572          case 't': // search again
 573             FindAgain();
 574             break;
 575          default:
 576             // we don't handle it, maybe an accelerator?
 577             event.Skip();
 578             ;
 579          }
 580       else if( IsEditable() )
 581       {
 582          /* First, handle control keys */
 583          if(ctrlDown && ! event.AltDown())
 584          {
 585             if(keyCode >= 'A' && keyCode <= 'Z')
 586                keyCode = tolower(keyCode);
 587             switch(keyCode)
 588             {
 589             case WXK_INSERT:
 590                Copy();
 591                break;
 592             case WXK_DELETE :
 593                if(! deletedSelection)
 594                {
 595                   m_llist->DeleteWord();
 596                   SetDirty();
 597                }
 598                break;
 599             case 'd':
 600                if(! deletedSelection) // already done
 601                {
 602                   m_llist->Delete(1);
 603                   SetDirty();
 604                }
 605                break;
 606             case 'y':
 607                m_llist->DeleteLines(1);
 608                SetDirty();
 609                break;
 610             case 'h': // like backspace
 611                if(m_llist->MoveCursorHorizontally(-1))
 612                {
 613                   m_llist->Delete(1);
 614                   SetDirty();
 615                }
 616                break;
 617             case 's': // search
 618                Find("");
 619                break;
 620             case 't': // search again
 621                FindAgain();
 622                break;
 623             case 'u':
 624                m_llist->DeleteToBeginOfLine();
 625                SetDirty();
 626                break;
 627             case 'k':
 628                m_llist->DeleteToEndOfLine();
 629                SetDirty();
 630                break;
 631             case 'c':
 632                Copy();
 633                break;
 634             case 'v':
 635                // if SHIFT is down, use primary selection
 636                Paste( event.ShiftDown() );
 637                break;
 638             case 'x':
 639                Cut();
 640                break;
 641 #ifdef WXLAYOUT_DEBUG
 642             case WXK_F1:
 643                m_llist->SetFont(-1,-1,-1,-1,true);  // underlined
 644                break;
 645 #endif
 646             default:
 647             // we don't handle it, maybe an accelerator?
 648             event.Skip();
 649             }
 650          }
 651          // ALT only:
 652          else if( event.AltDown() && ! event.ControlDown() )
 653          {
 654             switch(keyCode)
 655             {
 656             case WXK_DELETE:
 657             case 'd':
 658                m_llist->DeleteWord();
 659                SetDirty();
 660                break;
 661             default:
 662                // we don't handle it, maybe an accelerator?
 663                event.Skip();
 664             }
 665          }
 666          // no control keys:
 667          else if ( ! event.AltDown() && ! event.ControlDown())
 668          {
 669             switch(keyCode)
 670             {
 671             case WXK_INSERT:
 672                if(event.ShiftDown())
 673                   Paste();
 674                break;
 675             case WXK_DELETE :
 676                if(event.ShiftDown())
 677                   Cut();
 678                else
 679                   if(! deletedSelection)
 680                   {
 681                      m_llist->Delete(1);
 682                      SetDirty();
 683                   }
 684                break;
 685             case WXK_BACK: // backspace
 686                if(! deletedSelection)
 687                   if(m_llist->MoveCursorHorizontally(-1))
 688                   {
 689                      m_llist->Delete(1);
 690                      SetDirty();
 691                   }
 692                break;
 693             case WXK_RETURN:
 694                if(m_WrapMargin > 0)
 695                   m_llist->WrapLine(m_WrapMargin);
 696                m_llist->LineBreak();
 697                SetDirty();
 698                break;
 699
 700             case WXK_TAB:
 701                if ( !event.ShiftDown() )
 702                {
 703                   // TODO should be configurable
 704                   static const int tabSize = 8;
 705
 706                   CoordType x = m_llist->GetCursorPos().x;
 707                   size_t numSpaces = tabSize - x % tabSize;
 708                   m_llist->Insert(wxString(' ', numSpaces));
 709                   SetDirty();
 710                }
 711                break;
 712
 713             default:
 714                if((!(event.ControlDown() || event.AltDown()
 715                   ))
 716                   && (keyCode < 256 && keyCode >= 32)
 717                   )
 718                {
 719                   if(m_WrapMargin > 0 && isspace(keyCode))
 720                      m_llist->WrapLine(m_WrapMargin);
 721                   m_llist->Insert((char)keyCode);
 722                   SetDirty();
 723                }
 724                else
 725                   // we don't handle it, maybe an accelerator?
 726                   event.Skip();
 727                break;
 728             }
 729          }
 730       }// if(IsEditable())
 731       else
 732          // we don't handle it, maybe an accelerator?
 733          event.Skip();
 734    }// first switch()
 735
 736    if ( m_Selecting )
 737    {
 738       // continue selection to the current (new) cursor position
 739       m_llist->ContinueSelection();
 740    }
 741    ScrollToCursor();
 742    // refresh the screen
 743    RequestUpdate(m_llist->GetUpdateRect());
 744 }
 745
 746 void
 747 wxLayoutWindow::OnKeyUp(wxKeyEvent& event)
 748 {
 749    if ( event.KeyCode() == WXK_SHIFT && m_Selecting )
 750    {
 751       m_llist->EndSelection();
 752       m_Selecting = false;
 753    }
 754
 755    event.Skip();
 756 }
 757
 758
 759 void
 760 wxLayoutWindow::ScrollToCursor(void)
 761 {
 762    //is always needed to make sure we know where the cursor is
 763    //if(IsDirty())
 764    RequestUpdate(m_llist->GetUpdateRect());
 765
 766    int x0,y0,x1,y1, dx, dy;
 767
 768    // Calculate where the top of the visible area is:
 769    ViewStart(&x0,&y0);
 770    GetScrollPixelsPerUnit(&dx, &dy);
 771    x0 *= dx; y0 *= dy;
 772
 773    WXLO_DEBUG(("ScrollToCursor: ViewStart is %d/%d", x0, y0));
 774
 775    // Get the size of the visible window:
 776    GetClientSize(&x1, &y1);
 777
 778    // Make sure that the scrollbars are at a position so that the cursor is
 779    // visible if we are editing
 780    WXLO_DEBUG(("m_ScrollToCursor = %d", (int) m_ScrollToCursor));
 781    wxPoint cc = m_llist->GetCursorScreenPos();
 782
 783    // the cursor should be completely visible in both directions
 784    wxPoint cs(m_llist->GetCursorSize());
 785    int nx = -1,
 786        ny = -1;
 787    if ( cc.x < x0 || cc.x >= x0 + x1 - cs.x )
 788    {
 789       nx = cc.x - x1/2;
 790       if ( nx < 0 )
 791          nx = 0;
 792    }
 793
 794    if ( cc.y < y0 || cc.y >= y0 + y1 - cs.y )
 795    {
 796       ny = cc.y - y1/2;
 797       if ( ny < 0)
 798          ny = 0;
 799    }
 800
 801    if ( nx != -1 || ny != -1 )
 802    {
 803       // set new view start
 804       Scroll(nx == -1 ? -1 : (nx+dx-1)/dx, ny == -1 ? -1 : (ny+dy-1)/dy);
 805       // avoid recursion
 806       m_ScrollToCursor = false;
 807       RequestUpdate();
 808    }
 809 }
 810
 811 void
 812 wxLayoutWindow::OnPaint( wxPaintEvent &WXUNUSED(event))
 813 {
 814    wxRect region = GetUpdateRegion().GetBox();
 815    InternalPaint(&region);
 816 }
 817
 818 void
 819 wxLayoutWindow::RequestUpdate(const wxRect *updateRect)
 820 {
 821 #ifdef __WXGTK__
 822    // Calling Refresh() causes bad flicker under wxGTK!!!
 823    InternalPaint(updateRect);
 824 #else
 825    // shouldn't specify the update rectangle if it doesn't include all the
 826    // changed locations - otherwise, they won't be repainted at all because
 827    // the system clips the display to the update rect
 828    Refresh(FALSE); //, updateRect);
 829 #endif
 830 }
 831
 832 void
 833 wxLayoutWindow::InternalPaint(const wxRect *updateRect)
 834 {
 835    wxPaintDC dc( this );
 836    PrepareDC( dc );
 837
 838 #ifdef WXLAYOUT_USE_CARET
 839    // hide the caret before drawing anything
 840    GetCaret()->Hide();
 841 #endif // WXLAYOUT_USE_CARET
 842
 843    int x0,y0,x1,y1, dx, dy;
 844
 845    // Calculate where the top of the visible area is:
 846    ViewStart(&x0,&y0);
 847    GetScrollPixelsPerUnit(&dx, &dy);
 848    x0 *= dx; y0 *= dy;
 849
 850    // Get the size of the visible window:
 851    GetClientSize(&x1,&y1);
 852    wxASSERT(x1 >= 0);
 853    wxASSERT(y1 >= 0);
 854
 855    if(updateRect)
 856    {
 857       WXLO_DEBUG(("Update rect: %ld,%ld / %ld,%ld",
 858                   updateRect->x, updateRect->y,
 859                   updateRect->x+updateRect->width,
 860                   updateRect->y+updateRect->height));
 861    }
 862
 863    ResizeScrollbars();
 864
 865
 866    /* Check whether the window has grown, if so, we need to reallocate
 867       the bitmap to be larger. */
 868    if(x1 > m_bitmapSize.x || y1 > m_bitmapSize.y)
 869    {
 870       wxASSERT(m_bitmapSize.x > 0);
 871       wxASSERT(m_bitmapSize.y > 0);
 872
 873       m_memDC->SelectObject(wxNullBitmap);
 874       delete m_bitmap;
 875       m_bitmapSize = wxPoint(x1,y1);
 876       m_bitmap = new wxBitmap(x1,y1);
 877       m_memDC->SelectObject(*m_bitmap);
 878    }
 879
 880    m_memDC->SetDeviceOrigin(0,0);
 881    m_memDC->SetBackground(wxBrush(m_llist->GetDefaultStyleInfo().GetBGColour(),wxSOLID));
 882    m_memDC->SetPen(wxPen(m_llist->GetDefaultStyleInfo().GetBGColour(),
 883                          0,wxTRANSPARENT));
 884    m_memDC->SetLogicalFunction(wxCOPY);
 885    m_memDC->Clear();
 886
 887    // fill the background with the background bitmap
 888    if(m_BGbitmap)
 889    {
 890       CoordType
 891          y, x,
 892          w = m_BGbitmap->GetWidth(),
 893          h = m_BGbitmap->GetHeight();
 894       for(y = 0; y < y1; y+=h)
 895          for(x = 0; x < x1; x+=w)
 896             m_memDC->DrawBitmap(*m_BGbitmap, x, y);
 897       m_memDC->SetBackgroundMode(wxTRANSPARENT);
 898    }
 899
 900    // This is the important bit: we tell the list to draw itself
 901 #if WXLO_DEBUG_URECT
 902    if(updateRect)
 903    {
 904       WXLO_DEBUG(("Update rect: %ld,%ld / %ld,%ld",
 905                   updateRect->x, updateRect->y,
 906                   updateRect->x+updateRect->width,
 907                   updateRect->y+updateRect->height));
 908    }
 909 #endif
 910
 911    // Device origins on the memDC are suspect, we translate manually
 912    // with the translate parameter of Draw().
 913    wxPoint offset(-x0+WXLO_XOFFSET,-y0+WXLO_YOFFSET);
 914    m_llist->Draw(*m_memDC,offset, y0, y0+y1);
 915
 916    // We start calculating a new update rect before drawing the
 917    // cursor, so that the cursor coordinates get included in the next
 918    // update rectangle (although they are drawn on the memDC, this is
 919    // needed to erase it):
 920    m_llist->InvalidateUpdateRect();
 921    if(m_CursorVisibility != 0)
 922    {
 923       // draw a thick cursor for editable windows with focus
 924       m_llist->DrawCursor(*m_memDC,
 925                           m_HaveFocus && IsEditable(),
 926                           offset);
 927    }
 928
 929 // Now copy everything to the screen:
 930 #if 0
 931    // This somehow doesn't work, but even the following bit with the
 932    // whole rect at once is still a bit broken I think.
 933    wxRegionIterator ri ( GetUpdateRegion() );
 934    if(ri)
 935       while(ri)
 936       {
 937          WXLO_DEBUG(("UpdateRegion: %ld,%ld, %ld,%ld",
 938                      ri.GetX(),ri.GetY(),ri.GetW(),ri.GetH()));
 939          dc.Blit(x0+ri.GetX(),y0+ri.GetY(),ri.GetW(),ri.GetH(),
 940                  m_memDC,ri.GetX(),ri.GetY(),wxCOPY,FALSE);
 941          ri++;
 942       }
 943    else
 944 #endif
 945    {
 946       // FIXME: Trying to copy only the changed parts, but it does not seem
 947       // to work:
 948 //      x0 = updateRect->x; y0 = updateRect->y;
 949 //      if(updateRect->height < y1)
 950 //         y1 = updateRect->height;
 951 //      y1 += WXLO_YOFFSET; //FIXME might not be needed
 952       dc.Blit(x0,y0,x1,y1,m_memDC,0,0,wxCOPY,FALSE);
 953    }
 954
 955 #ifdef WXLAYOUT_USE_CARET
 956    // show the caret back after everything is redrawn
 957    GetCaret()->Show();
 958 #endif // WXLAYOUT_USE_CARET
 959
 960    ResetDirty();
 961
 962    if ( m_StatusBar && m_StatusFieldCursor != -1 )
 963    {
 964       static wxPoint s_oldCursorPos(-1, -1);
 965
 966       wxPoint pos(m_llist->GetCursorPos());
 967
 968       // avoid unnecessary status bar refreshes
 969       if ( pos != s_oldCursorPos )
 970       {
 971          s_oldCursorPos = pos;
 972
 973          wxString label;
 974          label.Printf(_("Ln:%d Col:%d"), pos.y + 1, pos.x + 1);
 975          m_StatusBar->SetStatusText(label, m_StatusFieldCursor);
 976       }
 977    }
 978 }
 979
 980 void
 981 wxLayoutWindow::OnSize(wxSizeEvent &event)
 982 {
 983    if ( m_llist )
 984       ResizeScrollbars();
 985
 986    event.Skip();
 987 }
 988
 989 /*
 990 Change the range and position of scrollbars. Has evolved into a
 991 generic Update function which will at some time later cause a repaint
 992 as needed.
 993 */
 994
 995 void
 996 wxLayoutWindow::ResizeScrollbars(bool exact)
 997 {
 998
 999    if(! IsDirty())
1000       return;
1001
1002    wxClientDC dc( this );
1003    PrepareDC( dc );
1004 //      m_llist->ForceTotalLayout();
1005    m_llist->Layout(dc);
1006    ResetDirty();
1007
1008    wxPoint max = m_llist->GetSize();
1009    wxSize size = GetClientSize();
1010
1011    WXLO_DEBUG(("ResizeScrollbars: max size = (%ld, %ld)",
1012                (long int)max.x, (long int) max.y));
1013
1014    // in the absence of scrollbars we should compare with the client size
1015    if ( !m_hasHScrollbar )
1016       m_maxx = size.x;// - WXLO_ROFFSET;
1017    if ( !m_hasVScrollbar )
1018       m_maxy = size.y;// - WXLO_BOFFSET;
1019
1020    // check if the text hasn't become too big
1021    // TODO why do we set both at once? they're independent...
1022    if( max.x > m_maxx - WXLO_ROFFSET
1023        || max.y > m_maxy - WXLO_BOFFSET
1024        || max.x < m_maxx - X_SCROLL_PAGE
1025        || max.y < m_maxy - Y_SCROLL_PAGE
1026        || exact )
1027    {
1028       // text became too large
1029       if ( !exact )
1030       {
1031          // add an extra bit to the sizes to avoid future updates
1032          max.x += WXLO_ROFFSET;
1033          max.y += WXLO_BOFFSET;
1034       }
1035
1036       bool done = FALSE;
1037       if(max.x < X_SCROLL_PAGE)
1038       {
1039          SetScrollbars(0,-1,0,-1,0,-1,true);
1040          m_hasHScrollbar = FALSE;
1041          done = TRUE;
1042       }
1043       if(max.y < Y_SCROLL_PAGE)
1044       {
1045          SetScrollbars(-1,0,-1,0,-1,0,true);
1046          m_hasVScrollbar = FALSE;
1047          done = TRUE;
1048       }
1049       if(! done)
1050       {
1051          ViewStart(&m_ViewStartX, &m_ViewStartY);
1052          SetScrollbars(X_SCROLL_PAGE,
1053                        Y_SCROLL_PAGE,
1054                        max.x / X_SCROLL_PAGE + 1,
1055                        max.y / Y_SCROLL_PAGE + 1,
1056                        m_ViewStartX, m_ViewStartY,
1057                        true);
1058          m_hasHScrollbar =
1059             m_hasVScrollbar = true;
1060       }
1061
1062       m_maxx = max.x + X_SCROLL_PAGE;
1063       m_maxy = max.y + Y_SCROLL_PAGE;
1064    }
1065 }
1066
1067 // ----------------------------------------------------------------------------
1068 //
1069 // clipboard operations
1070 //
1071 // ----------------------------------------------------------------------------
1072
1073 void
1074 wxLayoutWindow::Paste(bool primary)
1075 {
1076    // this only has an effect under X11:
1077    if(primary) wxTheClipboard->UsePrimarySelection();
1078    // Read some text
1079    if (wxTheClipboard->Open())
1080    {
1081 #if wxUSE_PRIVATE_CLIPBOARD_FORMAT
1082       wxLayoutDataObject wxldo;
1083       if (wxTheClipboard->IsSupported( wxldo.GetFormat() ))
1084       {
1085          if(wxTheClipboard->GetData(wxldo))
1086          {
1087             wxString str = wxldo.GetLayoutData();
1088             m_llist->Read(str);
1089             RequestUpdate();
1090          }
1091       }
1092       else
1093 #endif
1094       {
1095          wxTextDataObject data;
1096          if (wxTheClipboard->IsSupported( data.GetFormat() )
1097              && wxTheClipboard->GetData(data) )
1098          {
1099             wxString text = data.GetText();
1100             wxLayoutImportText( m_llist, text);
1101             SetDirty();
1102          }
1103       }
1104       wxTheClipboard->Close();
1105    }
1106 }
1107
1108 bool
1109 wxLayoutWindow::Copy(bool invalidate)
1110 {
1111    // Calling GetSelection() will automatically do an EndSelection()
1112    // on the list, but we need to take a note of it, too:
1113    if(m_Selecting)
1114    {
1115       m_Selecting = false;
1116       m_llist->EndSelection();
1117    }
1118
1119    wxLayoutDataObject *wldo = new wxLayoutDataObject;
1120    wxLayoutList *llist = m_llist->GetSelection(wldo, invalidate);
1121    if(! llist)
1122       return FALSE;
1123    // Export selection as text:
1124    wxString text;
1125    wxLayoutExportObject *exp;
1126    wxLayoutExportStatus status(llist);
1127    while((exp = wxLayoutExport( &status, WXLO_EXPORT_AS_TEXT)) != NULL)
1128    {
1129       if(exp->type == WXLO_EXPORT_TEXT)
1130          text << *(exp->content.text);
1131       delete exp;
1132    }
1133    delete llist;
1134
1135    // The exporter always appends a newline, so we chop it off if it
1136    // is there:
1137    {
1138       size_t len = text.Length();
1139       if(len > 2 && text[len-2] ==  '\r') // Windows
1140          text = text.Mid(0,len-2);
1141       else if(len > 1 && text[len-1] == '\n')
1142          text = text.Mid(0,len-1);
1143    }
1144
1145    if (wxTheClipboard->Open())
1146    {
1147       wxTextDataObject *data = new wxTextDataObject( text );
1148       bool rc;
1149
1150       rc = wxTheClipboard->SetData( data );
1151 #if wxUSE_PRIVATE_CLIPBOARD_FORMAT
1152       rc |= wxTheClipboard->SetData( wldo );
1153 #endif
1154       wxTheClipboard->Close();
1155       return rc;
1156    }
1157    else
1158       delete wldo;
1159
1160    return FALSE;
1161 }
1162
1163 bool
1164 wxLayoutWindow::Cut(void)
1165 {
1166    if(Copy(false)) // do not invalidate selection after copy
1167    {
1168       m_llist->DeleteSelection();
1169       SetDirty();
1170       return TRUE;
1171    }
1172    else
1173       return FALSE;
1174 }
1175
1176 // ----------------------------------------------------------------------------
1177 // searching
1178 // ----------------------------------------------------------------------------
1179
1180 bool
1181 wxLayoutWindow::Find(const wxString &needle,
1182                      wxPoint * fromWhere,
1183                      const wxString &configPath)
1184 {
1185 #ifdef M_BASEDIR
1186    wxPoint found;
1187
1188    if(needle.Length() == 0)
1189    {
1190       if( ! MInputBox(&m_FindString,
1191                       _("Find text"),
1192                       _("   Find:"),
1193                       this,
1194                       configPath, "")
1195           || strutil_isempty(m_FindString))
1196          return true;
1197    }
1198    else
1199       m_FindString = needle;
1200
1201    if(fromWhere == NULL)
1202       found = m_llist->FindText(m_FindString, m_llist->GetCursorPos());
1203    else
1204       found = m_llist->FindText(m_FindString, *fromWhere);
1205    if(found.x != -1)
1206    {
1207       if(fromWhere)
1208       {
1209          *fromWhere = found;
1210          fromWhere->x ++;
1211       }
1212       m_llist->MoveCursorTo(found);
1213       ScrollToCursor();
1214       RequestUpdate();
1215       return true;
1216    }
1217 #endif
1218    return false;
1219 }
1220
1221
1222 bool
1223 wxLayoutWindow::FindAgain(void)
1224 {
1225    bool rc = Find(m_FindString);
1226    return rc;
1227 }
1228
1229 // ----------------------------------------------------------------------------
1230 // popup menu stuff
1231 // ----------------------------------------------------------------------------
1232
1233 wxMenu *
1234 wxLayoutWindow::MakeFormatMenu()
1235 {
1236    wxMenu *m = new wxMenu(_("Layout Menu"));
1237
1238    m->Append(WXLOWIN_MENU_LARGER   ,_("&Larger"),_("Switch to larger font."), false);
1239    m->Append(WXLOWIN_MENU_SMALLER  ,_("&Smaller"),_("Switch to smaller font."), false);
1240    m->AppendSeparator();
1241    m->Append(WXLOWIN_MENU_UNDERLINE, _("&Underline"),_("Underline mode."), true);
1242    m->Append(WXLOWIN_MENU_BOLD, _("&Bold"),_("Bold mode."), true);
1243    m->Append(WXLOWIN_MENU_ITALICS, _("&Italics"),_("Italics mode."), true);
1244    m->AppendSeparator();
1245    m->Append(WXLOWIN_MENU_ROMAN     ,_("&Roman"),_("Switch to roman font."), false);
1246    m->Append(WXLOWIN_MENU_TYPEWRITER,_("&Typewriter"),_("Switch to typewriter font."), false);
1247    m->Append(WXLOWIN_MENU_SANSSERIF ,_("&Sans Serif"),_("Switch to sans serif font."), false);
1248
1249    return m;
1250 }
1251
1252 void wxLayoutWindow::OnUpdateMenuUnderline(wxUpdateUIEvent& event)
1253 {
1254    event.Check(m_llist->IsFontUnderlined());
1255 }
1256
1257 void wxLayoutWindow::OnUpdateMenuBold(wxUpdateUIEvent& event)
1258 {
1259    event.Check(m_llist->IsFontBold());
1260 }
1261
1262 void wxLayoutWindow::OnUpdateMenuItalic(wxUpdateUIEvent& event)
1263 {
1264    event.Check(m_llist->IsFontItalic());
1265 }
1266
1267 void wxLayoutWindow::OnMenu(wxCommandEvent& event)
1268 {
1269    switch (event.GetId())
1270    {
1271    case WXLOWIN_MENU_LARGER:
1272       m_llist->SetFontLarger(); RequestUpdate(); break;
1273    case WXLOWIN_MENU_SMALLER:
1274       m_llist->SetFontSmaller(); RequestUpdate(); break;
1275    case WXLOWIN_MENU_UNDERLINE:
1276       m_llist->ToggleFontUnderline(); RequestUpdate(); break;
1277    case WXLOWIN_MENU_BOLD:
1278       m_llist->ToggleFontWeight(); RequestUpdate(); break;
1279    case WXLOWIN_MENU_ITALICS:
1280       m_llist->ToggleFontItalics(); RequestUpdate(); break;
1281    case WXLOWIN_MENU_ROMAN:
1282       m_llist->SetFontFamily(wxROMAN); RequestUpdate(); break;
1283    case WXLOWIN_MENU_TYPEWRITER:
1284       m_llist->SetFontFamily(wxFIXED); RequestUpdate(); break;
1285    case WXLOWIN_MENU_SANSSERIF:
1286       m_llist->SetFontFamily(wxSWISS); RequestUpdate(); break;
1287    }
1288 }
1289
1290 // ----------------------------------------------------------------------------
1291 // focus
1292 // ----------------------------------------------------------------------------
1293
1294 void
1295 wxLayoutWindow::OnSetFocus(wxFocusEvent &ev)
1296 {
1297    m_HaveFocus = true;
1298    ev.Skip();
1299    RequestUpdate(); // cursor must change
1300 }
1301
1302 void
1303 wxLayoutWindow::OnKillFocus(wxFocusEvent &ev)
1304 {
1305    m_HaveFocus = false;
1306    ev.Skip();
1307    RequestUpdate();// cursor must change
1308 }
1309
1310 // ----------------------------------------------------------------------------
1311 // private functions
1312 // ----------------------------------------------------------------------------
1313
1314 static bool IsDirectionKey(long keyCode)
1315 {
1316    switch(keyCode)
1317    {
1318       case WXK_UP:
1319       case WXK_DOWN:
1320       case WXK_RIGHT:
1321       case WXK_LEFT:
1322       case WXK_PRIOR:
1323       case WXK_NEXT:
1324       case WXK_HOME:
1325       case WXK_END:
1326          return true;
1327
1328       default:
1329          return false;
1330    }
1331 }