Unicode compilation fixes

[wxWidgets.git] / samples / richedit / wxlwindow.cpp

diff --git a/samples/richedit/wxlwindow.cpp b/samples/richedit/wxlwindow.cpp
index 07e6e01cde7323eaf022940e3e8704a22dc6d920..4383578c2cc3d3a1df89da3b241951a881a4f34e 100644 (file)
--- a/samples/richedit/wxlwindow.cpp
+++ b/samples/richedit/wxlwindow.cpp
@@ -1,7 +1,7 @@
 /*-*- c++ -*-********************************************************
  * wxLwindow.h : a scrolled Window for displaying/entering rich text*
  *                                                                  *
 /*-*- c++ -*-********************************************************
  * wxLwindow.h : a scrolled Window for displaying/entering rich text*
  *                                                                  *

- * (C) 1998, 1999 by Karsten Ballüder (Ballueder@usa.net)           *
+ * (C) 1998-2000 by Karsten Ballüder (ballueder@gmx.net)            *

  *                                                                  *
  * $Id$
  *******************************************************************/
  *                                                                  *
  * $Id$
  *******************************************************************/


@@ -34,6 +34,9 @@
 #   endif // USE_PCH
 #   include "gui/wxlwindow.h"
 #   include "gui/wxlparser.h"
 #   endif // USE_PCH
 #   include "gui/wxlwindow.h"
 #   include "gui/wxlparser.h"

+
+#   include "MDialogs.h"
+#   include "strutil.h"

 #else
 #   ifdef   __WXMSW__
 #       include <wx/msw/private.h>
 #else
 #   ifdef   __WXMSW__
 #       include <wx/msw/private.h>


@@ -53,16 +56,24 @@
 
 #include <ctype.h>
 
 
 #include <ctype.h>
 

+

 // ----------------------------------------------------------------------------
 // macros
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // macros
 // ----------------------------------------------------------------------------
 

-#ifdef WXLAYOUT_DEBUG
+#ifdef DEBUG

 #  define   WXLO_DEBUG(x)      wxLogDebug x
 #else
 #  define WXLO_DEBUG(x)
 #endif
 
 #  define   WXLO_DEBUG(x)      wxLogDebug x
 #else
 #  define WXLO_DEBUG(x)
 #endif
 

+// for profiling in debug mode:
+WXLO_TIMER_DEFINE(UpdateTimer);
+WXLO_TIMER_DEFINE(BlitTimer);
+WXLO_TIMER_DEFINE(LayoutTimer);
+WXLO_TIMER_DEFINE(TmpTimer);
+WXLO_TIMER_DEFINE(DrawTimer);
+

 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------


@@ -75,10 +86,16 @@
 #define   WXLO_ROFFSET   20
 #define   WXLO_BOFFSET   20
 
 #define   WXLO_ROFFSET   20
 #define   WXLO_BOFFSET   20
 

+/// scroll margins when selecting with the mouse
+#define WXLO_SCROLLMARGIN_X   10
+#define WXLO_SCROLLMARGIN_Y   10
+

 /// the size of one scrollbar page in pixels
 static const int X_SCROLL_PAGE = 10;
 static const int Y_SCROLL_PAGE = 20;
 
 /// the size of one scrollbar page in pixels
 static const int X_SCROLL_PAGE = 10;
 static const int Y_SCROLL_PAGE = 20;
 

+
+

 // ----------------------------------------------------------------------------
 // event tables
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // event tables
 // ----------------------------------------------------------------------------


@@ -105,6 +122,8 @@ BEGIN_EVENT_TABLE(wxLayoutWindow,wxScrolledWindow)
 
    EVT_SET_FOCUS(wxLayoutWindow::OnSetFocus)
    EVT_KILL_FOCUS(wxLayoutWindow::OnKillFocus)
 
    EVT_SET_FOCUS(wxLayoutWindow::OnSetFocus)
    EVT_KILL_FOCUS(wxLayoutWindow::OnKillFocus)

+
+//   EVT_IDLE(wxLayoutWindow::ResizeScrollbars)

 END_EVENT_TABLE()
 
 // ----------------------------------------------------------------------------
 END_EVENT_TABLE()
 
 // ----------------------------------------------------------------------------


@@ -118,17 +137,8 @@ static bool IsDirectionKey(long keyCode);
 // implementation
 // ============================================================================
 
 // implementation
 // ============================================================================
 

-/* LEAVE IT HERE UNTIL WXGTK WORKS AGAIN!!! */
-#ifdef __WXGTK__
-/// allows me to compare to wxPoints
-static bool operator != (wxPoint const &p1, wxPoint const &p2)
-{
-   return p1.x != p2.x || p1.y != p2.y;
-}
-#endif // __WXGTK__
-

 #ifndef wxWANTS_CHARS
 #ifndef wxWANTS_CHARS

-   #define wxWANTS_CHARS 0
+#   define wxWANTS_CHARS 0

 #endif
 
 // ----------------------------------------------------------------------------
 #endif
 
 // ----------------------------------------------------------------------------


@@ -153,21 +163,14 @@ wxLayoutWindow::wxLayoutWindow(wxWindow *parent)
    m_bitmap = new wxBitmap(4,4);
    m_bitmapSize = wxPoint(4,4);
    m_llist = new wxLayoutList();
    m_bitmap = new wxBitmap(4,4);
    m_bitmapSize = wxPoint(4,4);
    m_llist = new wxLayoutList();

-

    m_BGbitmap = NULL;
    m_ScrollToCursor = false;
    m_BGbitmap = NULL;
    m_ScrollToCursor = false;

+#ifndef __WXMSW__
+   m_FocusFollowMode = false;
+#endif
+   SetWordWrap(false);

    SetWrapMargin(0);
 
    SetWrapMargin(0);
 

-   // initially the list is empty, so why would we need the scrollbars?
-#if 0
-   wxPoint max = m_llist->GetSize();
-   SetScrollbars(X_SCROLL_PAGE, Y_SCROLL_PAGE,
-                 max.x / X_SCROLL_PAGE + 1, max.y / Y_SCROLL_PAGE + 1);
-   EnableScrolling(true, true);
-   m_maxx = max.x + X_SCROLL_PAGE;
-   m_maxy = max.y + Y_SCROLL_PAGE;
-#endif // 0
-

    // no scrollbars initially
    m_hasHScrollbar =
    m_hasVScrollbar = false;
    // no scrollbars initially
    m_hasHScrollbar =
    m_hasVScrollbar = false;


@@ -179,13 +182,16 @@ wxLayoutWindow::wxLayoutWindow(wxWindow *parent)
    wxCaret *caret = new wxCaret(this, 2, 20);
    SetCaret(caret);
    m_llist->SetCaret(caret);
    wxCaret *caret = new wxCaret(this, 2, 20);
    SetCaret(caret);
    m_llist->SetCaret(caret);

-   caret->Show();

 #endif // WXLAYOUT_USE_CARET
 
 #endif // WXLAYOUT_USE_CARET
 

+   m_HaveFocus = FALSE;

    m_HandCursor = FALSE;
    m_CursorVisibility = -1;
    SetCursor(wxCURSOR_IBEAM);
    SetDirty();
    m_HandCursor = FALSE;
    m_CursorVisibility = -1;
    SetCursor(wxCURSOR_IBEAM);
    SetDirty();

+
+   // at least under Windows, this should be the default behaviour
+   m_AutoDeleteSelection = TRUE;

 }
 
 wxLayoutWindow::~wxLayoutWindow()
 }
 
 wxLayoutWindow::~wxLayoutWindow()


@@ -208,19 +214,24 @@ wxLayoutWindow::Clear(int family,
 {
    GetLayoutList()->Clear(family,size,style,weight,underline,fg,bg);
    SetBackgroundColour(GetLayoutList()->GetDefaultStyleInfo().GetBGColour());
 {
    GetLayoutList()->Clear(family,size,style,weight,underline,fg,bg);
    SetBackgroundColour(GetLayoutList()->GetDefaultStyleInfo().GetBGColour());

+   wxScrolledWindow::Clear();

    ResizeScrollbars(true);
    SetDirty();
    ResizeScrollbars(true);
    SetDirty();

-   SetModified(false);
-   wxScrolledWindow::Clear();
-   DoPaint((wxRect *)NULL);
+   SetModified(FALSE);
+   if ( m_Editable )
+      m_CursorVisibility = 1;
+
+#ifdef WXLAYOUT_USE_CARET
+   if ( m_CursorVisibility == 1 )
+      GetCaret()->Show();
+#endif // WXLAYOUT_USE_CARET
+
+   RequestUpdate((wxRect *)NULL);

 }
 
 void wxLayoutWindow::Refresh(bool eraseBackground, const wxRect *rect)
 {
    wxScrolledWindow::Refresh(eraseBackground, rect);
 }
 
 void wxLayoutWindow::Refresh(bool eraseBackground, const wxRect *rect)
 {
    wxScrolledWindow::Refresh(eraseBackground, rect);

-
-   ResizeScrollbars();
-   ScrollToCursor();

 }
 
 void
 }
 
 void


@@ -228,11 +239,13 @@ wxLayoutWindow::OnMouse(int eventId, wxMouseEvent& event)
 {
    wxClientDC dc( this );
    PrepareDC( dc );
 {
    wxClientDC dc( this );
    PrepareDC( dc );

-   if ( eventId != WXLOWIN_MENU_MOUSEMOVE )
-   {
-       // moving the mouse in a window shouldn't give it the focus!
+   if ( (eventId != WXLOWIN_MENU_MOUSEMOVE
+#ifndef __WXMSW__
+        || m_FocusFollowMode
+#endif
+        ) && (wxWindow::FindFocus() != this)
+      )

       SetFocus();
       SetFocus();

-   }

 
    wxPoint findPos;
    findPos.x = dc.DeviceToLogicalX(event.GetX());
 
    wxPoint findPos;
    findPos.x = dc.DeviceToLogicalX(event.GetX());


@@ -242,12 +255,43 @@ wxLayoutWindow::OnMouse(int eventId, wxMouseEvent& event)
    findPos.y -= WXLO_YOFFSET;
 
    if(findPos.x < 0)
    findPos.y -= WXLO_YOFFSET;
 
    if(findPos.x < 0)

-       findPos.x = 0;
+      findPos.x = 0;

    if(findPos.y < 0)
    if(findPos.y < 0)

-       findPos.y = 0;
+      findPos.y = 0;

 
    m_ClickPosition = wxPoint(event.GetX(), event.GetY());
 
 
    m_ClickPosition = wxPoint(event.GetX(), event.GetY());
 

+   // Scroll the window if the mouse is at the end of it:
+   if(m_Selecting && eventId == WXLOWIN_MENU_MOUSEMOVE)
+   {
+      //WXLO_DEBUG(("selecting at : %d/%d", (int) event.GetX(), (int)event.GetY()));
+      int left, top;
+      GetViewStart(&left, &top);
+      wxSize size = GetClientSize();
+      int xdelta, ydelta;
+      
+      if(event.GetX() < WXLO_SCROLLMARGIN_X)
+         xdelta = -(WXLO_SCROLLMARGIN_X-event.GetX());
+      else if(event.GetX() > size.x-WXLO_SCROLLMARGIN_X)
+         xdelta = event.GetX()-size.x+WXLO_SCROLLMARGIN_X;
+      else
+         xdelta = 0;
+      if(event.GetY() < WXLO_SCROLLMARGIN_Y)
+         ydelta = -(WXLO_SCROLLMARGIN_Y-event.GetY());
+      else if(event.GetY() > size.y-WXLO_SCROLLMARGIN_Y)
+         ydelta = event.GetY()-size.y+WXLO_SCROLLMARGIN_Y;
+      else
+         ydelta = 0;
+
+      //WXLO_DEBUG(("xdelta: %d", (int) xdelta));
+      if(xdelta != 0 || ydelta != 0)
+      {
+         top  += ydelta; if(top < 0) top = 0;
+         left += xdelta; if(left < 0) left = 0;
+         Scroll(left, top);
+      }
+   }
+

    wxPoint cursorPos;
    bool found;
    wxLayoutObject *obj = m_llist->FindObjectScreen(dc, findPos,
    wxPoint cursorPos;
    bool found;
    wxLayoutObject *obj = m_llist->FindObjectScreen(dc, findPos,


@@ -257,126 +301,134 @@ wxLayoutWindow::OnMouse(int eventId, wxMouseEvent& event)
    // has the mouse only been moved?
    switch ( eventId )
    {
    // has the mouse only been moved?
    switch ( eventId )
    {

-      case WXLOWIN_MENU_MOUSEMOVE:
-         // found is only true if we are really over an object, not just
-         // behind it
-         if(found && u && ! m_Selecting)
+   case WXLOWIN_MENU_MOUSEMOVE:
+   {
+      // this variables is used to only erase the message in the status
+      // bar if we had put it there previously - otherwise empting status
+      // bar might be undesirable
+      static bool s_hasPutMessageInStatusBar = false;
+
+      // found is only true if we are really over an object, not just
+      // behind it
+      if(found && u && ! m_Selecting)
+      {
+         if(!m_HandCursor)
+            SetCursor(wxCURSOR_HAND);
+         m_HandCursor = TRUE;
+         if(m_StatusBar && m_StatusFieldLabel != -1)

          {
          {

-            if(!m_HandCursor)
-               SetCursor(wxCURSOR_HAND);
-            m_HandCursor = TRUE;
-            if(m_StatusBar && m_StatusFieldLabel != -1)
+            const wxString &label = u->GetLabel();
+            if(label.Length())

             {
             {

-               const wxString &label = u->GetLabel();
-               if(label.Length())
-                  m_StatusBar->SetStatusText(label,
-                                             m_StatusFieldLabel);
+               m_StatusBar->SetStatusText(label,
+                                          m_StatusFieldLabel);
+               s_hasPutMessageInStatusBar = true;

             }
          }
             }
          }

-         else
+      }
+      else
+      {
+         if(m_HandCursor)
+            SetCursor(wxCURSOR_IBEAM);
+         m_HandCursor = FALSE;
+         if( m_StatusBar && m_StatusFieldLabel != -1 &&
+             s_hasPutMessageInStatusBar )

          {
          {

-            if(m_HandCursor)
-               SetCursor(wxCURSOR_IBEAM);
-            m_HandCursor = FALSE;
-            if(m_StatusBar && m_StatusFieldLabel != -1)
-               m_StatusBar->SetStatusText("", m_StatusFieldLabel);
+            m_StatusBar->SetStatusText("", m_StatusFieldLabel);

          }
          }

+      }
+   }

 
 

-         // selecting?
-         if ( event.LeftIsDown() )
-         {
-            wxASSERT_MSG( m_Selecting, "should be set in OnMouseLeftDown" );
+   // selecting?
+   if ( event.LeftIsDown() )
+   {
+      // m_Selecting might not be set if the button got pressed
+      // outside this window, so check for it:
+      if( m_Selecting )
+      {
+         m_llist->ContinueSelection(cursorPos, m_ClickPosition);
+         RequestUpdate();  // TODO: we don't have to redraw everything!
+      }
+   }

 
 

-            m_llist->ContinueSelection(cursorPos, m_ClickPosition);
-            DoPaint();  // TODO: we don't have to redraw everything!
-         }
+   if ( u )
+   {
+      u->DecRef();
+      u = NULL;
+   }
+   break;

 
 

-         if ( u )
-         {
-            u->DecRef();
-            u = NULL;
-         }
-         break;
+   case WXLOWIN_MENU_LDOWN:
+   {
+      // always move cursor to mouse click:
+      m_llist->MoveCursorTo(cursorPos);

 
 

-      case WXLOWIN_MENU_LDOWN:
-         {
-             // always move cursor to mouse click:
-             if ( obj )
-             {
-                // we have found the real position
-                m_llist->MoveCursorTo(cursorPos);
-             }
-             else
-             {
-                // click beyond the end of the text
-                m_llist->MoveCursorToEnd();
-             }
-
-             // clicking a mouse removes the selection
-             if ( m_llist->HasSelection() )
-             {
-                m_llist->DiscardSelection();
-                DoPaint();     // TODO: we don't have to redraw everything!
-             }
-
-             // Calculate where the top of the visible area is:
-             int x0, y0;
-             ViewStart(&x0,&y0);
-             int dx, dy;
-             GetScrollPixelsPerUnit(&dx, &dy);
-             x0 *= dx; y0 *= dy;
-
-             wxPoint offset(-x0+WXLO_XOFFSET, -y0+WXLO_YOFFSET);
-
-             if(m_CursorVisibility == -1)
-                m_CursorVisibility = 1;
-
-             if(m_CursorVisibility != 0)
-             {
-                // draw a thick cursor for    editable windows with focus
-                m_llist->DrawCursor(dc, m_HaveFocus && IsEditable(), offset);
-             }
-
-             // VZ: this should be unnecessary because mouse can only click on a
-             //     visible part of the canvas
-#if 0
-             ScrollToCursor();
-#endif // 0
+      // clicking a mouse removes the selection
+      if ( m_llist->HasSelection() )
+      {
+         m_llist->DiscardSelection();
+         m_Selecting = false;
+         RequestUpdate();     // TODO: we don't have to redraw everything!
+      }
+            
+      // Calculate where the top of the visible area is:
+      int x0, y0;
+      GetViewStart(&x0,&y0);
+      int dx, dy;
+      GetScrollPixelsPerUnit(&dx, &dy);
+      x0 *= dx; y0 *= dy;
+
+      wxPoint offset(-x0+WXLO_XOFFSET, -y0+WXLO_YOFFSET);
+
+      if(m_CursorVisibility == -1)
+         m_CursorVisibility = 1;
+#ifdef WXLAYOUT_USE_CARET
+      if ( m_CursorVisibility == 1 )
+         GetCaret()->Show();
+#endif // WXLAYOUT_USE_CARET
+
+      if(m_CursorVisibility)
+      {
+         // draw a thick cursor for editable windows with focus
+         m_llist->DrawCursor(dc, m_HaveFocus && IsEditable(), offset);
+      }

 
 #ifdef __WXGTK__
 
 #ifdef __WXGTK__

-             DoPaint(); // DoPaint suppresses flicker under GTK
+      RequestUpdate(); // RequestUpdate suppresses flicker under GTK

 #endif // wxGTK
 
 #endif // wxGTK
 

-             // start selection
-             m_llist->StartSelection(wxPoint(-1, -1), m_ClickPosition);
-             m_Selecting = true;
-         }
-         break;
-
-      case WXLOWIN_MENU_LUP:
-         if ( m_Selecting )
-         {
-            m_llist->EndSelection();
-            m_Selecting = false;
+      // start selection
+      m_llist->StartSelection(wxPoint(-1, -1), m_ClickPosition);
+      m_Selecting = true;
+   }
+   break;

 
 

-            DoPaint();     // TODO: we don't have to redraw everything!
-         }
-         break;
+   case WXLOWIN_MENU_LUP:
+      if ( m_Selecting )
+      {
+         // end selection at the cursor position corresponding to the
+         // current mouse position, but don´t move cursor there.
+         m_llist->EndSelection(cursorPos,m_ClickPosition);
+         m_Selecting = false;

 
 

-      case WXLOWIN_MENU_MDOWN:
-         Paste(TRUE);
-         break;
+         RequestUpdate();     // TODO: we don't have to redraw everything!
+      }
+      break;

 
 

-      case WXLOWIN_MENU_DBLCLICK:
-         // select a word under cursor
-         m_llist->MoveCursorTo(cursorPos);
-         m_llist->MoveCursorWord(-1);
-         m_llist->StartSelection();
-         m_llist->MoveCursorWord(1, false);
-         m_llist->EndSelection();
+   case WXLOWIN_MENU_MDOWN:
+      Paste(TRUE);
+      break;

 
 

-         DoPaint();     // TODO: we don't have to redraw everything!
-         break;
+   case WXLOWIN_MENU_DBLCLICK:
+      // select a word under cursor
+      m_llist->MoveCursorTo(cursorPos);
+      m_llist->MoveCursorWord(-1);
+      m_llist->StartSelection();
+      m_llist->MoveCursorWord(1, false);
+      m_llist->EndSelection();
+      m_Selecting = false;
+      RequestUpdate();     // TODO: we don't have to redraw everything!
+      break;

    }
 
    // notify about mouse events?
    }
 
    // notify about mouse events?


@@ -402,8 +454,7 @@ wxLayoutWindow::OnMouse(int eventId, wxMouseEvent& event)
       }
    }
 
       }
    }
 

-   if( u )
-      u->DecRef();
+   if( u ) u->DecRef();

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -414,6 +465,7 @@ void
 wxLayoutWindow::OnChar(wxKeyEvent& event)
 {
    int keyCode = event.KeyCode();
 wxLayoutWindow::OnChar(wxKeyEvent& event)
 {
    int keyCode = event.KeyCode();

+   bool ctrlDown = event.ControlDown();

 
 #ifdef WXLAYOUT_DEBUG
    if(keyCode == WXK_F1)
 
 #ifdef WXLAYOUT_DEBUG
    if(keyCode == WXK_F1)


@@ -423,34 +475,50 @@ wxLayoutWindow::OnChar(wxKeyEvent& event)
    }
 #endif
 
    }
 #endif
 

-   wxASSERT_MSG( !m_Selecting || event.ShiftDown(),
-                 "m_Selecting is normally reset in OnKeyUp() when Shift "
-                 "goes up!" );
-
-   if ( !m_Selecting && m_llist->HasSelection() )
+   // Force m_Selecting to be false if shift is no longer
+   // pressed. OnKeyUp() cannot catch all Shift-Up events.
+   if(m_Selecting && !event.ShiftDown())

    {
    {

-      // pressing any non-arrow key replaces the selection
-      if ( !IsDirectionKey(keyCode) )
-      {
-         m_llist->DeleteSelection();
-      }
-      else if ( !event.ShiftDown() )
-      {
-         m_llist->DiscardSelection();
-      }
+      m_Selecting = false;
+      m_llist->EndSelection();
+      m_llist->DiscardSelection(); //FIXME: correct?

    }
    }

-
+   
+   // If we deleted the selection here, we must not execute the
+   // deletion in Delete/Backspace handling.
+   bool deletedSelection = false;
+   // pressing any non-arrow key optionally replaces the selection:
+   if(m_AutoDeleteSelection
+      && IsEditable()
+      && !m_Selecting
+      && m_llist->HasSelection() 
+      && ! IsDirectionKey(keyCode)
+      && ! (event.AltDown() || ctrlDown)
+      )
+   {
+      m_llist->DeleteSelection();
+      deletedSelection = true;
+      SetDirty();
+   }
+   

    // <Shift>+<arrow> starts selection
    // <Shift>+<arrow> starts selection

-   if ( event.ShiftDown() && IsDirectionKey(keyCode) )
+   if ( IsDirectionKey(keyCode) )

    {
    {

-      if ( !m_Selecting )
+      // just continue the old selection
+      if ( m_Selecting && event.ShiftDown() )
+            m_llist->ContinueSelection();
+      else

       {
       {

-         m_Selecting = true;
-         m_llist->StartSelection();
+         m_llist->DiscardSelection();
+         m_Selecting = false;
+         if( event.ShiftDown() )
+         {
+            m_Selecting = true;
+            m_llist->StartSelection();
+         }

       }
       }

-      //else: just continue the old selection

    }
    }

-
+   

    // If needed, make cursor visible:
    if(m_CursorVisibility == -1)
       m_CursorVisibility = 1;
    // If needed, make cursor visible:
    if(m_CursorVisibility == -1)
       m_CursorVisibility = 1;


@@ -460,7 +528,6 @@ wxLayoutWindow::OnChar(wxKeyEvent& event)
       cursor, etc. It's default will process all keycodes causing
       modifications to the buffer, but only if editing is allowed.
    */
       cursor, etc. It's default will process all keycodes causing
       modifications to the buffer, but only if editing is allowed.
    */

-   bool ctrlDown = event.ControlDown();

    switch(keyCode)
    {
    case WXK_RIGHT:
    switch(keyCode)
    {
    case WXK_RIGHT:


@@ -499,52 +566,105 @@ wxLayoutWindow::OnChar(wxKeyEvent& event)
       else
          m_llist->MoveCursorToEndOfLine();
       break;
       else
          m_llist->MoveCursorToEndOfLine();
       break;

-

    default:
    default:

-      if(keyCode == 'c' && ctrlDown)
-      {
-         // this should work even in read-only mode
-         Copy();
-      }
+      
+      if(ctrlDown && ! IsEditable())
+         switch(keyCode)
+         {
+         case 'c':
+            // this should work even in read-only mode
+            Copy(TRUE, TRUE);
+            break;
+         case 's': // search
+            Find("");
+            break;
+         case 't': // search again
+            FindAgain();
+            break;
+         default:
+            // we don't handle it, maybe an accelerator?
+            event.Skip();
+            ;
+         }

       else if( IsEditable() )
       {
          /* First, handle control keys */
       else if( IsEditable() )
       {
          /* First, handle control keys */

-         if(event.ControlDown() && ! event.AltDown())
+         if(ctrlDown && ! event.AltDown())

          {
          {

+            if(keyCode >= 'A' && keyCode <= 'Z')
+               keyCode = tolower(keyCode);

             switch(keyCode)
             {
             case WXK_INSERT:
                Copy();
                break;
             case WXK_DELETE :
             switch(keyCode)
             {
             case WXK_INSERT:
                Copy();
                break;
             case WXK_DELETE :

+               if(! deletedSelection)
+               {
+                  m_llist->DeleteWord();
+                  SetDirty();
+               }
+               break;

             case 'd':
             case 'd':

-               m_llist->Delete(1);
+               if(! deletedSelection) // already done
+               {
+                  m_llist->Delete(1);
+                  SetDirty();
+               }

                break;
             case 'y':
                m_llist->DeleteLines(1);
                break;
             case 'y':
                m_llist->DeleteLines(1);

+               SetDirty();

                break;
             case 'h': // like backspace
                break;
             case 'h': // like backspace

-               if(m_llist->MoveCursorHorizontally(-1)) m_llist->Delete(1);
+               if(m_llist->MoveCursorHorizontally(-1))
+               {
+                  m_llist->Delete(1);
+                  SetDirty();
+               }
+               break;
+            case 's': // search
+               Find("");
+               break;
+            case 't': // search again
+               FindAgain();

                break;
             case 'u':
                m_llist->DeleteToBeginOfLine();
                break;
             case 'u':
                m_llist->DeleteToBeginOfLine();

+               SetDirty();

                break;
             case 'k':
                m_llist->DeleteToEndOfLine();
                break;
             case 'k':
                m_llist->DeleteToEndOfLine();

+               SetDirty();
+               break;
+            case 'c':
+               Copy(TRUE, TRUE);

                break;
             case 'v':
                break;
             case 'v':

-               Paste();
+               Paste( TRUE );

                break;
             case 'x':
                Cut();
                break;
                break;
             case 'x':
                Cut();
                break;

+            case 'w':
+               if(m_WrapMargin > 0)
+                  m_llist->WrapLine(m_WrapMargin);
+               break;
+            case 'q':
+               if(m_WrapMargin > 0)
+                  m_llist->WrapAll(m_WrapMargin);
+               break;

 #ifdef WXLAYOUT_DEBUG
             case WXK_F1:
                m_llist->SetFont(-1,-1,-1,-1,true);  // underlined
                break;
 #ifdef WXLAYOUT_DEBUG
             case WXK_F1:
                m_llist->SetFont(-1,-1,-1,-1,true);  // underlined
                break;

+            case 'l':
+               Refresh(TRUE);
+               break;

 #endif
             default:
 #endif
             default:

-               ;
+            // we don't handle it, maybe an accelerator?
+            event.Skip();

             }
          }
          // ALT only:
             }
          }
          // ALT only:


@@ -555,9 +675,11 @@ wxLayoutWindow::OnChar(wxKeyEvent& event)
             case WXK_DELETE:
             case 'd':
                m_llist->DeleteWord();
             case WXK_DELETE:
             case 'd':
                m_llist->DeleteWord();

+               SetDirty();

                break;
             default:
                break;
             default:

-               ;
+               // we don't handle it, maybe an accelerator?
+               event.Skip();

             }
          }
          // no control keys:
             }
          }
          // no control keys:


@@ -573,44 +695,69 @@ wxLayoutWindow::OnChar(wxKeyEvent& event)
                if(event.ShiftDown())
                   Cut();
                else
                if(event.ShiftDown())
                   Cut();
                else

-                  m_llist->Delete(1);
+                  if(! deletedSelection)
+                  {
+                     m_llist->Delete(1);
+                     SetDirty();
+                  }

                break;
             case WXK_BACK: // backspace
                break;
             case WXK_BACK: // backspace

-               if(m_llist->MoveCursorHorizontally(-1))
-                  m_llist->Delete(1);
+               if(! deletedSelection)
+                  if(m_llist->MoveCursorHorizontally(-1))
+                  {
+                     m_llist->Delete(1);
+                     SetDirty();
+                  }

                break;
             case WXK_RETURN:
                break;
             case WXK_RETURN:

-               if(m_WrapMargin > 0)
+               if(m_DoWordWrap &&
+                  m_WrapMargin > 0
+                  && m_llist->GetCursorPos().x > m_WrapMargin)

                   m_llist->WrapLine(m_WrapMargin);
                m_llist->LineBreak();
                   m_llist->WrapLine(m_WrapMargin);
                m_llist->LineBreak();

+               SetDirty();

                break;
 
             case WXK_TAB:
                break;
 
             case WXK_TAB:

+               if ( !event.ShiftDown() )

                {
                {

-                   // TODO should be configurable
-                   static const int tabSize = 8;
+                  // TODO should be configurable
+                  static const int tabSize = 8;

 
 

-                   CoordType x = m_llist->GetCursorPos().x;
-                   size_t numSpaces = tabSize - x % tabSize;
-                   m_llist->Insert(wxString(' ', numSpaces));
+                  CoordType x = m_llist->GetCursorPos().x;
+                  size_t numSpaces = tabSize - x % tabSize;
+                  m_llist->Insert(wxString(' ', numSpaces));
+                  SetDirty();

                }
                break;
                }
                break;

-
+               

             default:
             default:

-               if((!(event.ControlDown() || event.AltDown() || event.MetaDown()))
+               if((!(event.ControlDown() || event.AltDown()
+                  ))

                   && (keyCode < 256 && keyCode >= 32)
                   )
                {
                   && (keyCode < 256 && keyCode >= 32)
                   )
                {

-                  if(m_WrapMargin > 0 && isspace(keyCode))
+                  if(m_DoWordWrap
+                     && m_WrapMargin > 0
+                     && m_llist->GetCursorPos().x > m_WrapMargin
+                     && isspace(keyCode))
+                  {

                      m_llist->WrapLine(m_WrapMargin);
                      m_llist->WrapLine(m_WrapMargin);

-                  m_llist->Insert((char)keyCode);
+                  }
+                  
+                  m_llist->Insert((wxChar)keyCode);
+                  SetDirty();

                }
                }

+               else
+                  // we don't handle it, maybe an accelerator?
+                  event.Skip();

                break;
             }
          }
                break;
             }
          }

-         SetDirty();
-         SetModified();

       }// if(IsEditable())
       }// if(IsEditable())

+      else
+         // we don't handle it, maybe an accelerator?
+         event.Skip();

    }// first switch()
 
    if ( m_Selecting )
    }// first switch()
 
    if ( m_Selecting )


@@ -618,14 +765,9 @@ wxLayoutWindow::OnChar(wxKeyEvent& event)
       // continue selection to the current (new) cursor position
       m_llist->ContinueSelection();
    }
       // continue selection to the current (new) cursor position
       m_llist->ContinueSelection();
    }

-
-   // we must call ResizeScrollbars() before ScrollToCursor(), otherwise the
-   // ne cursor position might be outside the current scrolllbar range
-   ResizeScrollbars();

    ScrollToCursor();
    ScrollToCursor();

-

    // refresh the screen
    // refresh the screen

-   DoPaint(m_llist->GetUpdateRect());
+   RequestUpdate(m_llist->GetUpdateRect());

 }
 
 void
 }
 
 void


@@ -644,28 +786,29 @@ wxLayoutWindow::OnKeyUp(wxKeyEvent& event)
 void
 wxLayoutWindow::ScrollToCursor(void)
 {
 void
 wxLayoutWindow::ScrollToCursor(void)
 {

-   wxClientDC dc( this );
-   PrepareDC( dc );
+   //is always needed to make sure we know where the cursor is
+   //if(IsDirty())
+   //RequestUpdate(m_llist->GetUpdateRect());
+
+
+   ResizeScrollbars();

 
    int x0,y0,x1,y1, dx, dy;
 
    // Calculate where the top of the visible area is:
 
    int x0,y0,x1,y1, dx, dy;
 
    // Calculate where the top of the visible area is:

-   ViewStart(&x0,&y0);
+   GetViewStart(&x0,&y0);

    GetScrollPixelsPerUnit(&dx, &dy);
    x0 *= dx; y0 *= dy;
 
    GetScrollPixelsPerUnit(&dx, &dy);
    x0 *= dx; y0 *= dy;
 

-   WXLO_DEBUG(("ScrollToCursor: ViewStart is %d/%d", x0, y0));
+   WXLO_DEBUG(("ScrollToCursor: GetViewStart is %d/%d", x0, y0));

 
    // Get the size of the visible window:
    GetClientSize(&x1, &y1);
 
 
    // Get the size of the visible window:
    GetClientSize(&x1, &y1);
 

-   // update the cursor screen position
-   m_llist->Layout(dc);
-

    // Make sure that the scrollbars are at a position so that the cursor is
    // visible if we are editing
    WXLO_DEBUG(("m_ScrollToCursor = %d", (int) m_ScrollToCursor));
    // Make sure that the scrollbars are at a position so that the cursor is
    // visible if we are editing
    WXLO_DEBUG(("m_ScrollToCursor = %d", (int) m_ScrollToCursor));

-   wxPoint cc = m_llist->GetCursorScreenPos(dc);
+   wxPoint cc = m_llist->GetCursorScreenPos();

 
    // the cursor should be completely visible in both directions
    wxPoint cs(m_llist->GetCursorSize());
 
    // the cursor should be completely visible in both directions
    wxPoint cs(m_llist->GetCursorSize());


@@ -685,13 +828,13 @@ wxLayoutWindow::ScrollToCursor(void)
          ny = 0;
    }
 
          ny = 0;
    }
 

-   if ( nx != -1 || ny != -1 )
+   if( nx != -1 || ny != -1 )

    {
       // set new view start
       Scroll(nx == -1 ? -1 : (nx+dx-1)/dx, ny == -1 ? -1 : (ny+dy-1)/dy);
    {
       // set new view start
       Scroll(nx == -1 ? -1 : (nx+dx-1)/dx, ny == -1 ? -1 : (ny+dy-1)/dy);

-

       // avoid recursion
       m_ScrollToCursor = false;
       // avoid recursion
       m_ScrollToCursor = false;

+      RequestUpdate();

    }
 }
 
    }
 }
 


@@ -703,21 +846,23 @@ wxLayoutWindow::OnPaint( wxPaintEvent &WXUNUSED(event))
 }
 
 void
 }
 
 void

-wxLayoutWindow::DoPaint(const wxRect *updateRect)
+wxLayoutWindow::RequestUpdate(const wxRect *updateRect)

 {
 #ifdef __WXGTK__
 {
 #ifdef __WXGTK__

+   // Calling Refresh() causes bad flicker under wxGTK!!!

    InternalPaint(updateRect);
    InternalPaint(updateRect);

-#else // Causes bad flicker under wxGTK!!!
+#else
+   // shouldn't specify the update rectangle if it doesn't include all the
+   // changed locations - otherwise, they won't be repainted at all because
+   // the system clips the display to the update rect

    Refresh(FALSE); //, updateRect);
    Refresh(FALSE); //, updateRect);

-
-   if ( !::UpdateWindow(GetHwnd()) )
-      wxLogLastError("UpdateWindow");

 #endif
 }
 
 void
 wxLayoutWindow::InternalPaint(const wxRect *updateRect)
 {
 #endif
 }
 
 void
 wxLayoutWindow::InternalPaint(const wxRect *updateRect)
 {

+

    wxPaintDC dc( this );
    PrepareDC( dc );
 
    wxPaintDC dc( this );
    PrepareDC( dc );
 


@@ -729,7 +874,7 @@ wxLayoutWindow::InternalPaint(const wxRect *updateRect)
    int x0,y0,x1,y1, dx, dy;
 
    // Calculate where the top of the visible area is:
    int x0,y0,x1,y1, dx, dy;
 
    // Calculate where the top of the visible area is:

-   ViewStart(&x0,&y0);
+   GetViewStart(&x0,&y0);

    GetScrollPixelsPerUnit(&dx, &dy);
    x0 *= dx; y0 *= dy;
 
    GetScrollPixelsPerUnit(&dx, &dy);
    x0 *= dx; y0 *= dy;
 


@@ -745,11 +890,10 @@ wxLayoutWindow::InternalPaint(const wxRect *updateRect)
                   updateRect->x+updateRect->width,
                   updateRect->y+updateRect->height));
    }
                   updateRect->x+updateRect->width,
                   updateRect->y+updateRect->height));
    }

-   if(IsDirty())
-   {
-      m_llist->Layout(dc);
-      ResizeScrollbars();
-   }
+
+   ResizeScrollbars(true);
+
+   WXLO_TIMER_START(TmpTimer);

    /* Check whether the window has grown, if so, we need to reallocate
       the bitmap to be larger. */
    if(x1 > m_bitmapSize.x || y1 > m_bitmapSize.y)
    /* Check whether the window has grown, if so, we need to reallocate
       the bitmap to be larger. */
    if(x1 > m_bitmapSize.x || y1 > m_bitmapSize.y)


@@ -765,12 +909,13 @@ wxLayoutWindow::InternalPaint(const wxRect *updateRect)
    }
 
    m_memDC->SetDeviceOrigin(0,0);
    }
 
    m_memDC->SetDeviceOrigin(0,0);

-   m_memDC->SetBrush(wxBrush(m_llist->GetDefaultStyleInfo().GetBGColour(),wxSOLID));
+   m_memDC->SetBackground(wxBrush(m_llist->GetDefaultStyleInfo().GetBGColour(),wxSOLID));

    m_memDC->SetPen(wxPen(m_llist->GetDefaultStyleInfo().GetBGColour(),
                          0,wxTRANSPARENT));
    m_memDC->SetLogicalFunction(wxCOPY);
    m_memDC->Clear();
    m_memDC->SetPen(wxPen(m_llist->GetDefaultStyleInfo().GetBGColour(),
                          0,wxTRANSPARENT));
    m_memDC->SetLogicalFunction(wxCOPY);
    m_memDC->Clear();

-
+   WXLO_TIMER_STOP(TmpTimer);
+   

    // fill the background with the background bitmap
    if(m_BGbitmap)
    {
    // fill the background with the background bitmap
    if(m_BGbitmap)
    {


@@ -805,7 +950,7 @@ wxLayoutWindow::InternalPaint(const wxRect *updateRect)
    // update rectangle (although they are drawn on the memDC, this is
    // needed to erase it):
    m_llist->InvalidateUpdateRect();
    // update rectangle (although they are drawn on the memDC, this is
    // needed to erase it):
    m_llist->InvalidateUpdateRect();

-   if(m_CursorVisibility != 0)
+   if(m_CursorVisibility == 1)

    {
       // draw a thick cursor for editable windows with focus
       m_llist->DrawCursor(*m_memDC,
    {
       // draw a thick cursor for editable windows with focus
       m_llist->DrawCursor(*m_memDC,


@@ -813,6 +958,7 @@ wxLayoutWindow::InternalPaint(const wxRect *updateRect)
                           offset);
    }
 
                           offset);
    }
 

+   WXLO_TIMER_START(BlitTimer);

 // Now copy everything to the screen:
 #if 0
    // This somehow doesn't work, but even the following bit with the
 // Now copy everything to the screen:
 #if 0
    // This somehow doesn't work, but even the following bit with the


@@ -838,14 +984,15 @@ wxLayoutWindow::InternalPaint(const wxRect *updateRect)
 //      y1 += WXLO_YOFFSET; //FIXME might not be needed
       dc.Blit(x0,y0,x1,y1,m_memDC,0,0,wxCOPY,FALSE);
    }
 //      y1 += WXLO_YOFFSET; //FIXME might not be needed
       dc.Blit(x0,y0,x1,y1,m_memDC,0,0,wxCOPY,FALSE);
    }

+   WXLO_TIMER_STOP(BlitTimer);
+

 
 #ifdef WXLAYOUT_USE_CARET
    // show the caret back after everything is redrawn
 
 #ifdef WXLAYOUT_USE_CARET
    // show the caret back after everything is redrawn

-   m_caret->Show();
+   GetCaret()->Show();

 #endif // WXLAYOUT_USE_CARET
 
    ResetDirty();
 #endif // WXLAYOUT_USE_CARET
 
    ResetDirty();

-   m_ScrollToCursor = false;

 
    if ( m_StatusBar && m_StatusFieldCursor != -1 )
    {
 
    if ( m_StatusBar && m_StatusFieldCursor != -1 )
    {


@@ -863,23 +1010,46 @@ wxLayoutWindow::InternalPaint(const wxRect *updateRect)
          m_StatusBar->SetStatusText(label, m_StatusFieldCursor);
       }
    }
          m_StatusBar->SetStatusText(label, m_StatusFieldCursor);
       }
    }

+
+   WXLO_TIMER_PRINT(LayoutTimer);
+   WXLO_TIMER_PRINT(BlitTimer);
+   WXLO_TIMER_PRINT(TmpTimer);

 }
 
 void
 wxLayoutWindow::OnSize(wxSizeEvent &event)
 {
    if ( m_llist )
 }
 
 void
 wxLayoutWindow::OnSize(wxSizeEvent &event)
 {
    if ( m_llist )

-   {

       ResizeScrollbars();
       ResizeScrollbars();

-   }

 
    event.Skip();
 }
 
 
    event.Skip();
 }
 

-// change the range and position of scrollbars
+/*
+Change the range and position of scrollbars. Has evolved into a
+generic Update function which will at some time later cause a repaint
+as needed. 
+*/
+

 void
 wxLayoutWindow::ResizeScrollbars(bool exact)
 {
 void
 wxLayoutWindow::ResizeScrollbars(bool exact)
 {

+   wxClientDC dc( this );
+   PrepareDC( dc );
+//   m_llist->ForceTotalLayout();
+
+   if(! IsDirty())
+   {
+      // we are laying out just the minimum, but always up to the
+      // cursor line, so the cursor position is updated.
+      m_llist->Layout(dc, 0);
+      return;
+   }
+   WXLO_TIMER_START(LayoutTimer);
+   m_llist->Layout(dc, -1);
+   WXLO_TIMER_STOP(LayoutTimer);
+   ResetDirty();
+   

    wxPoint max = m_llist->GetSize();
    wxSize size = GetClientSize();
 
    wxPoint max = m_llist->GetSize();
    wxSize size = GetClientSize();
 


@@ -888,13 +1058,17 @@ wxLayoutWindow::ResizeScrollbars(bool exact)
 
    // in the absence of scrollbars we should compare with the client size
    if ( !m_hasHScrollbar )
 
    // in the absence of scrollbars we should compare with the client size
    if ( !m_hasHScrollbar )

-      m_maxx = size.x - WXLO_ROFFSET;
+      m_maxx = size.x;// - WXLO_ROFFSET;

    if ( !m_hasVScrollbar )
    if ( !m_hasVScrollbar )

-      m_maxy = size.y - WXLO_BOFFSET;
+      m_maxy = size.y;// - WXLO_BOFFSET;

 
    // check if the text hasn't become too big
    // TODO why do we set both at once? they're independent...
 
    // check if the text hasn't become too big
    // TODO why do we set both at once? they're independent...

-   if( max.x > m_maxx - WXLO_ROFFSET || max.y > m_maxy - WXLO_BOFFSET || exact )
+   if( max.x > m_maxx - WXLO_ROFFSET
+       || max.y > m_maxy - WXLO_BOFFSET
+       || (max.x < m_maxx - X_SCROLL_PAGE)
+       || (max.y < m_maxy - Y_SCROLL_PAGE)
+       || exact )

    {
       // text became too large
       if ( !exact )
    {
       // text became too large
       if ( !exact )


@@ -904,92 +1078,107 @@ wxLayoutWindow::ResizeScrollbars(bool exact)
          max.y += WXLO_BOFFSET;
       }
 
          max.y += WXLO_BOFFSET;
       }
 

-      ViewStart(&m_ViewStartX, &m_ViewStartY);
-      SetScrollbars(X_SCROLL_PAGE, Y_SCROLL_PAGE,
-                    max.x / X_SCROLL_PAGE + 1, max.y / Y_SCROLL_PAGE + 1,
-                    m_ViewStartX, m_ViewStartY,
-                    true);
-
-      m_hasHScrollbar =
-      m_hasVScrollbar = true;
-
-      m_maxx = max.x + X_SCROLL_PAGE;
-      m_maxy = max.y + Y_SCROLL_PAGE;
-   }
-#if 0
-   else
-   {
-      // check if the window hasn't become too big, thus making the scrollbars
-      // unnecessary
-      if ( m_hasHScrollbar && (max.x < size.x) )
+      bool done = FALSE;
+      if(max.x < X_SCROLL_PAGE && m_hasHScrollbar)

       {
       {

-         // remove the horizontal scrollbar
-         SetScrollbars(0, -1, 0, -1, 0, -1, true);
-         m_hasHScrollbar = false;
+         SetScrollbars(0,-1,0,-1,0,-1,true);
+         m_hasHScrollbar = FALSE;
+         done = TRUE;

       }
       }

-
-      if ( m_hasVScrollbar && (max.y < size.y) )
+      if(max.y < Y_SCROLL_PAGE && m_hasVScrollbar)

       {
       {

-         // remove the vertical scrollbar
-         SetScrollbars(-1, 0, -1, 0, -1, 0, true);
-         m_hasVScrollbar = false;
+         SetScrollbars(-1,0,-1,0,-1,0,true);
+         m_hasVScrollbar = FALSE;
+         done = TRUE;

       }
       }

+      if(! done &&
+//         (max.x > X_SCROLL_PAGE || max.y > Y_SCROLL_PAGE)
+         (max.x > size.x - X_SCROLL_PAGE|| max.y > size.y - Y_SCROLL_PAGE)
+         )
+      {
+         GetViewStart(&m_ViewStartX, &m_ViewStartY);
+         SetScrollbars(X_SCROLL_PAGE,
+                       Y_SCROLL_PAGE,
+                       max.x / X_SCROLL_PAGE + 2,
+                       max.y / Y_SCROLL_PAGE + 2,
+                       m_ViewStartX,
+                       m_ViewStartY,
+                       true);
+         m_hasHScrollbar =
+            m_hasVScrollbar = true;
+//         ScrollToCursor();
+      }
+      
+      m_maxx = max.x + X_SCROLL_PAGE;
+      m_maxy = max.y + Y_SCROLL_PAGE;

    }
    }

-#endif

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------

+//

 // clipboard operations
 //
 // ----------------------------------------------------------------------------
 
 void
 // clipboard operations
 //
 // ----------------------------------------------------------------------------
 
 void

-wxLayoutWindow::Paste(bool primary)
+wxLayoutWindow::Paste(bool usePrivate, bool primary)

 {
 {

+   // this only has an effect under X11:
+   wxTheClipboard->UsePrimarySelection(primary);

    // Read some text
    if (wxTheClipboard->Open())
    {
    // Read some text
    if (wxTheClipboard->Open())
    {

-#if __WXGTK__
-      if(primary)
-         wxTheClipboard->UsePrimarySelection();
-#endif
-#if wxUSE_PRIVATE_CLIPBOARD_FORMAT
-      wxLayoutDataObject wxldo;
-      if (wxTheClipboard->IsSupported( wxldo.GetFormat() ))
+      if(usePrivate)

       {
       {

-         wxTheClipboard->GetData(&wxldo);
+         wxLayoutDataObject wxldo;
+         if (wxTheClipboard->IsSupported( wxldo.GetFormat() ))

          {
          {

+            if(wxTheClipboard->GetData(wxldo))
+            {
+               wxTheClipboard->Close();
+               wxString str = wxldo.GetLayoutData();
+               m_llist->Read(str);
+               SetDirty();
+               RequestUpdate();
+               return;
+            }

          }
          }

-         //FIXME: missing functionality m_llist->Insert(wxldo.GetList());

       }
       }

-      else
-#endif
+      wxTextDataObject data;
+      if (wxTheClipboard->IsSupported( data.GetFormat() )
+          && wxTheClipboard->GetData(data) )
+      {
+         wxTheClipboard->Close();
+         wxString text = data.GetText();
+         wxLayoutImportText( m_llist, text);
+         SetDirty();
+         RequestUpdate();
+         return;
+      }
+   }
+   // if everything failed we can still try the primary:
+   wxTheClipboard->Close();
+   if(! primary) // not tried before
+   {
+      wxTheClipboard->UsePrimarySelection();
+      if (wxTheClipboard->Open())

       {
          wxTextDataObject data;
       {
          wxTextDataObject data;

-         if (wxTheClipboard->IsSupported( data.GetFormat() ))
+         if (wxTheClipboard->IsSupported( data.GetFormat() )
+             && wxTheClipboard->GetData(data) )

          {
          {

-            wxTheClipboard->GetData(&data);

             wxString text = data.GetText();
             wxLayoutImportText( m_llist, text);
             wxString text = data.GetText();
             wxLayoutImportText( m_llist, text);

+            SetDirty();
+            RequestUpdate();

          }
          }

+         wxTheClipboard->Close();

       }
       }

-      wxTheClipboard->Close();

    }
    }

-
-#if 0
-   /* My attempt to get the primary selection, but it does not
-      work. :-( */
-   if(text.Length() == 0)
-   {
-      wxTextCtrl tmp_tctrl(this,-1);
-      tmp_tctrl.Paste();
-      text += tmp_tctrl.GetValue();
-   }
-#endif

 }
 
 bool
 }
 
 bool

-wxLayoutWindow::Copy(bool invalidate)
+wxLayoutWindow::Copy(bool invalidate, bool privateFormat, bool primary)

 {
    // Calling GetSelection() will automatically do an EndSelection()
    // on the list, but we need to take a note of it, too:
 {
    // Calling GetSelection() will automatically do an EndSelection()
    // on the list, but we need to take a note of it, too:


@@ -999,19 +1188,19 @@ wxLayoutWindow::Copy(bool invalidate)
       m_llist->EndSelection();
    }
 
       m_llist->EndSelection();
    }
 

-   wxLayoutDataObject wldo;
-   wxLayoutList *llist = m_llist->GetSelection(&wldo, invalidate);
+   wxLayoutDataObject *wldo = new wxLayoutDataObject;
+   wxLayoutList *llist = m_llist->GetSelection(wldo, invalidate);

    if(! llist)
       return FALSE;
    // Export selection as text:
    wxString text;
    if(! llist)
       return FALSE;
    // Export selection as text:
    wxString text;

-   wxLayoutExportObject *export;
+   wxLayoutExportObject *exp;

    wxLayoutExportStatus status(llist);
    wxLayoutExportStatus status(llist);

-   while((export = wxLayoutExport( &status, WXLO_EXPORT_AS_TEXT)) != NULL)
+   while((exp = wxLayoutExport( &status, WXLO_EXPORT_AS_TEXT)) != NULL)

    {
    {

-      if(export->type == WXLO_EXPORT_TEXT)
-         text << *(export->content.text);
-      delete export;
+      if(exp->type == WXLO_EXPORT_TEXT)
+         text << *(exp->content.text);
+      delete exp;

    }
    delete llist;
 
    }
    delete llist;
 


@@ -1025,27 +1214,44 @@ wxLayoutWindow::Copy(bool invalidate)
          text = text.Mid(0,len-1);
    }
 
          text = text.Mid(0,len-1);
    }
 

+#if 0
+if(! primary) // always copy as text-only to primary selection
+   {
+      wxTheClipboard->UsePrimarySelection();
+      if (wxTheClipboard->Open())
+      {
+         wxTextDataObject *data = new wxTextDataObject( text );
+         wxTheClipboard->SetData( data );
+         wxTheClipboard->Close();
+      }
+   }
+#endif

 
 

+   wxTheClipboard->UsePrimarySelection(primary);

    if (wxTheClipboard->Open())
    {
       wxTextDataObject *data = new wxTextDataObject( text );
    if (wxTheClipboard->Open())
    {
       wxTextDataObject *data = new wxTextDataObject( text );

-      bool  rc = wxTheClipboard->SetData( data );
-#if wxUSE_PRIVATE_CLIPBOARD_FORMAT
-      rc |= wxTheClipboard->AddData( &wldo );
-#endif
+      bool rc;
+
+         rc = wxTheClipboard->SetData( data );
+      if(privateFormat)
+         rc |= wxTheClipboard->SetData( wldo );

       wxTheClipboard->Close();
       return rc;
    }
       wxTheClipboard->Close();
       return rc;
    }

-
+   else
+      delete wldo;
+   

    return FALSE;
 }
 
 bool
    return FALSE;
 }
 
 bool

-wxLayoutWindow::Cut(void)
+wxLayoutWindow::Cut(bool privateFormat, bool usePrimary)

 {
 {

-   if(Copy(false)) // do not invalidate selection after copy
+   if(Copy(false, privateFormat, usePrimary)) // do not invalidate selection after copy

    {
       m_llist->DeleteSelection();
    {
       m_llist->DeleteSelection();

+      SetDirty();

       return TRUE;
    }
    else
       return TRUE;
    }
    else


@@ -1058,14 +1264,29 @@ wxLayoutWindow::Cut(void)
 
 bool
 wxLayoutWindow::Find(const wxString &needle,
 
 bool
 wxLayoutWindow::Find(const wxString &needle,

-                     wxPoint * fromWhere)
+                     wxPoint * fromWhere,
+                     const wxString &configPath)

 {
 {

+#ifdef M_BASEDIR

    wxPoint found;
    wxPoint found;

-
+   
+   if(needle.Length() == 0)
+   {
+      if( ! MInputBox(&m_FindString,
+                      _("Find text"),
+                      _("   Find:"),
+                      this,
+                      configPath, "")
+          || strutil_isempty(m_FindString))
+         return true;
+   }
+   else
+      m_FindString = needle;
+   

    if(fromWhere == NULL)
    if(fromWhere == NULL)

-      found = m_llist->FindText(needle, m_llist->GetCursorPos());
+      found = m_llist->FindText(m_FindString, m_llist->GetCursorPos());

    else
    else

-      found = m_llist->FindText(needle, *fromWhere);
+      found = m_llist->FindText(m_FindString, *fromWhere);

    if(found.x != -1)
    {
       if(fromWhere)
    if(found.x != -1)
    {
       if(fromWhere)


@@ -1075,11 +1296,21 @@ wxLayoutWindow::Find(const wxString &needle,
       }
       m_llist->MoveCursorTo(found);
       ScrollToCursor();
       }
       m_llist->MoveCursorTo(found);
       ScrollToCursor();

+      RequestUpdate();

       return true;
    }
       return true;
    }

+#endif

    return false;
 }
 
    return false;
 }
 

+
+bool
+wxLayoutWindow::FindAgain(void)
+{
+   bool rc = Find(m_FindString);
+   return rc;
+}
+

 // ----------------------------------------------------------------------------
 // popup menu stuff
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // popup menu stuff
 // ----------------------------------------------------------------------------


@@ -1123,21 +1354,21 @@ void wxLayoutWindow::OnMenu(wxCommandEvent& event)
    switch (event.GetId())
    {
    case WXLOWIN_MENU_LARGER:
    switch (event.GetId())
    {
    case WXLOWIN_MENU_LARGER:

-      m_llist->SetFontLarger(); Refresh(FALSE); break;
+      m_llist->SetFontLarger(); RequestUpdate(); break;

    case WXLOWIN_MENU_SMALLER:
    case WXLOWIN_MENU_SMALLER:

-      m_llist->SetFontSmaller(); Refresh(FALSE); break;
+      m_llist->SetFontSmaller(); RequestUpdate(); break;

    case WXLOWIN_MENU_UNDERLINE:
    case WXLOWIN_MENU_UNDERLINE:

-      m_llist->ToggleFontUnderline(); Refresh(FALSE); break;
+      m_llist->ToggleFontUnderline(); RequestUpdate(); break;

    case WXLOWIN_MENU_BOLD:
    case WXLOWIN_MENU_BOLD:

-      m_llist->ToggleFontWeight(); Refresh(FALSE); break;
+      m_llist->ToggleFontWeight(); RequestUpdate(); break;

    case WXLOWIN_MENU_ITALICS:
    case WXLOWIN_MENU_ITALICS:

-      m_llist->ToggleFontItalics(); Refresh(FALSE); break;
+      m_llist->ToggleFontItalics(); RequestUpdate(); break;

    case WXLOWIN_MENU_ROMAN:
    case WXLOWIN_MENU_ROMAN:

-      m_llist->SetFontFamily(wxROMAN); Refresh(FALSE); break;
+      m_llist->SetFontFamily(wxROMAN); RequestUpdate(); break;

    case WXLOWIN_MENU_TYPEWRITER:
    case WXLOWIN_MENU_TYPEWRITER:

-      m_llist->SetFontFamily(wxFIXED); Refresh(FALSE); break;
+      m_llist->SetFontFamily(wxFIXED); RequestUpdate(); break;

    case WXLOWIN_MENU_SANSSERIF:
    case WXLOWIN_MENU_SANSSERIF:

-      m_llist->SetFontFamily(wxSWISS); Refresh(FALSE); break;
+      m_llist->SetFontFamily(wxSWISS); RequestUpdate(); break;

    }
 }
 
    }
 }
 


@@ -1150,6 +1381,7 @@ wxLayoutWindow::OnSetFocus(wxFocusEvent &ev)
 {
    m_HaveFocus = true;
    ev.Skip();
 {
    m_HaveFocus = true;
    ev.Skip();

+   RequestUpdate(); // cursor must change

 }
 
 void
 }
 
 void


@@ -1157,6 +1389,7 @@ wxLayoutWindow::OnKillFocus(wxFocusEvent &ev)
 {
    m_HaveFocus = false;
    ev.Skip();
 {
    m_HaveFocus = false;
    ev.Skip();

+   RequestUpdate();// cursor must change

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------