]> git.saurik.com Git - wxWidgets.git/blob - samples/richedit/wxlwindow.cpp
projects / wxWidgets.git / blob
? search:


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