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


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