]> git.saurik.com Git - wxWidgets.git/blob - samples/richedit/wxllist.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
NO C++ COMMENTS IN THIS FILE PLEASE
[wxWidgets.git] / samples / richedit / wxllist.cpp
1 /*-*- c++ -*-********************************************************
2 * wxllist: wxLayoutList, a layout engine for text and graphics *
3 * *
4 * (C) 1998-1999 by Karsten Ballüder (Ballueder@usa.net) *
5 * *
6 * $Id$
7 *******************************************************************/
8
9 /*
10
11 Some docs:
12
13 Layout() recalculates the objects, sizes, etc.
14 Draw() just draws them with the current settings, without
15 re-layout()ing them again
16
17 Each line has its own wxLayoutStyleInfo structure which gets updated
18 from within Layout(). Thanks to this, we don't need to re-layout all
19 lines if we want to draw one, but can just use its styleinfo to set
20 the right font.
21
22 */
23
24 #ifdef __GNUG__
25 # pragma implementation "wxllist.h"
26 #endif
27
28 #include <wx/wxprec.h>
29
30 #ifdef __BORLANDC__
31 # pragma hdrstop
32 #endif
33
34 #include "Mpch.h"
35
36 #ifdef M_BASEDIR
37 # include "Mcommon.h"
38 # include "gui/wxllist.h"
39 # include "gui/wxlparser.h"
40 # define SHOW_SELECTIONS 1
41 #else
42 # include "wxllist.h"
43 # include "wxlparser.h"
44 # define SHOW_SELECTIONS 1
45 #endif
46
47 #ifndef USE_PCH
48 # include <iostream.h>
49
50 # include <wx/dc.h>
51 # include <wx/dcps.h>
52 # include <wx/print.h>
53 # include <wx/log.h>
54 # include <wx/filefn.h>
55 #endif
56
57 #ifdef WXLAYOUT_USE_CARET
58 # include <wx/caret.h>
59 #endif // WXLAYOUT_USE_CARET
60
61 #include <ctype.h>
62
63 /// This should never really get created
64 #define WXLLIST_TEMPFILE "__wxllist.tmp"
65
66 #ifdef WXLAYOUT_DEBUG
67
68 # define TypeString(t) g_aTypeStrings[t]
69 # define WXLO_DEBUG(x) wxLogDebug x
70
71 static const char *g_aTypeStrings[] =
72 {
73 "invalid", "text", "cmd", "icon"
74 };
75 void
76 wxLayoutObject::Debug(void)
77 {
78 WXLO_DEBUG(("%s",g_aTypeStrings[GetType()]));
79 }
80 #else
81 # define TypeString(t) ""
82 # define WXLO_DEBUG(x)
83 #endif
84
85 // FIXME under MSW, this constant is needed to make the thing properly redraw
86 // itself - I don't know where the size calculation error is and I can't
87 // waste time looking for it right now. Search for occurences of
88 // MSW_CORRECTION to find all the places where I did it.
89 #ifdef __WXMSW__
90 static const int MSW_CORRECTION = 10;
91 #else
92 static const int MSW_CORRECTION = 0;
93 #endif
94
95 /// Cursors smaller than this disappear in XOR drawing mode
96 #define WXLO_MINIMUM_CURSOR_WIDTH 4
97
98 /// Use this character to estimate a cursor size when none is available.
99 #define WXLO_CURSORCHAR "E"
100 /** @name Helper functions */
101 //@{
102 /// allows me to compare to wxPoints
103 bool operator <=(wxPoint const &p1, wxPoint const &p2)
104 {
105 return p1.y < p2.y || (p1.y == p2.y && p1.x <= p2.x);
106 }
107
108 /*
109 The following STAY HERE until we have a working wxGTK again!!!
110 */
111 #ifndef wxWANTS_CHARS
112 /// allows me to compare to wxPoints
113 bool operator ==(wxPoint const &p1, wxPoint const &p2)
114 {
115 return p1.x == p2.x && p1.y == p2.y;
116 }
117
118 /// allows me to compare to wxPoints
119 bool operator !=(wxPoint const &p1, wxPoint const &p2)
120 {
121 return p1.x != p2.x || p1.y != p2.y;
122 }
123
124 wxPoint & operator += (wxPoint &p1, wxPoint const &p2)
125 {
126 p1.x += p2.x;
127 p1.y += p2.y;
128 return p1;
129 }
130 #endif // old wxGTK
131
132 /// allows me to compare to wxPoints
133 bool operator>(wxPoint const &p1, wxPoint const &p2)
134 {
135 return !(p1 <= p2);
136 }
137
138 /// grows a wxRect so that it includes the given point
139
140 static
141 void GrowRect(wxRect &r, CoordType x, CoordType y)
142 {
143 if(r.x > x)
144 r.x = x;
145 else if(r.x + r.width < x)
146 r.width = x - r.x;
147
148 if(r.y > y)
149 r.y = y;
150 else if(r.y + r.height < y)
151 r.height = y - r.y;
152 }
153
154 #if 0
155 // unused
156 /// returns true if the point is in the rectangle
157 static
158 bool Contains(const wxRect &r, const wxPoint &p)
159 {
160 return r.x <= p.x && r.y <= p.y && (r.x+r.width) >= p.x && (r.y + r.height) >= p.y;
161 }
162 #endif
163
164
165 //@}
166
167
168 void ReadString(wxString &to, wxString &from)
169 {
170 to = "";
171 const char *cptr = from.c_str();
172 while(*cptr && *cptr != '\n')
173 to += *cptr++;
174 if(*cptr) cptr++;
175 from = cptr;
176 }
177
178 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
179
180 wxLayoutObject
181
182 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
183
184 /* static */
185 wxLayoutObject *
186 wxLayoutObject::Read(wxString &istr)
187 {
188 wxString tmp;
189 ReadString(tmp, istr);
190 int type = -1;
191 sscanf(tmp.c_str(),"%d", &type);
192
193 switch(type)
194 {
195 case WXLO_TYPE_TEXT:
196 return wxLayoutObjectText::Read(istr);
197 case WXLO_TYPE_CMD:
198 return wxLayoutObjectCmd::Read(istr);
199 case WXLO_TYPE_ICON:
200 return wxLayoutObjectIcon::Read(istr);
201 default:
202 return NULL;
203 }
204 }
205
206 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
207
208 wxLayoutObjectText
209
210 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
211
212 wxLayoutObjectText::wxLayoutObjectText(const wxString &txt)
213 {
214 m_Text = txt;
215 m_Width = 0;
216 m_Height = 0;
217 m_Top = 0;
218 m_Bottom = 0;
219 }
220
221 wxLayoutObject *
222 wxLayoutObjectText::Copy(void)
223 {
224 wxLayoutObjectText *obj = new wxLayoutObjectText(m_Text);
225 obj->m_Width = m_Width;
226 obj->m_Height = m_Height;
227 obj->m_Top = m_Top;
228 obj->m_Bottom = m_Bottom;
229 obj->SetUserData(m_UserData);
230 return obj;
231 }
232
233
234 void
235 wxLayoutObjectText::Write(wxString &ostr)
236 {
237 ostr << (int) WXLO_TYPE_TEXT << '\n'
238 << m_Text << '\n';
239 }
240 /* static */
241 wxLayoutObjectText *
242 wxLayoutObjectText::Read(wxString &istr)
243 {
244 wxString text;
245 ReadString(text, istr);
246
247 return new wxLayoutObjectText(text);
248 }
249
250 wxPoint
251 wxLayoutObjectText::GetSize(CoordType *top, CoordType *bottom) const
252 {
253
254 *top = m_Top; *bottom = m_Bottom;
255 return wxPoint(m_Width, m_Height);
256 }
257
258 void
259 wxLayoutObjectText::Draw(wxDC &dc, wxPoint const &coords,
260 wxLayoutList *wxllist,
261 CoordType begin, CoordType end)
262 {
263 if( end <= 0 )
264 {
265 // draw the whole object normally
266 dc.DrawText(m_Text, coords.x, coords.y-m_Top);
267 }
268 else
269 {
270 // highlight the bit between begin and len
271 CoordType
272 xpos = coords.x,
273 ypos = coords.y-m_Top;
274 long width, height, descent;
275
276 if(begin < 0) begin = 0;
277 if( end > (signed)m_Text.Length() )
278 end = m_Text.Length();
279
280 wxString str = m_Text.Mid(0, begin);
281 dc.DrawText(str, xpos, ypos);
282 dc.GetTextExtent(str, &width, &height, &descent);
283 xpos += width;
284 wxllist->StartHighlighting(dc);
285 str = m_Text.Mid(begin, end-begin);
286 dc.DrawText(str, xpos, ypos);
287 dc.GetTextExtent(str, &width, &height, &descent);
288 xpos += width;
289 wxllist->EndHighlighting(dc);
290 str = m_Text.Mid(end, m_Text.Length()-end);
291 dc.DrawText(str, xpos, ypos);
292 }
293 }
294
295 CoordType
296 wxLayoutObjectText::GetOffsetScreen(wxDC &dc, CoordType xpos) const
297 {
298 CoordType
299 offs = 1,
300 maxlen = m_Text.Length();
301 long
302 width = 0,
303 height, descent = 0l;
304
305 if(xpos == 0) return 0; // easy
306
307 while(width < xpos && offs < maxlen)
308 {
309 dc.GetTextExtent(m_Text.substr(0,offs),
310 &width, &height, &descent);
311 offs++;
312 }
313 /* We have to substract 1 to compensate for the offs++, and another
314 one because we don't want to position the cursor behind the
315 object what we clicked on, but before - otherwise it looks
316 funny. */
317 return (xpos > 2) ? offs-2 : 0;
318 }
319
320 void
321 wxLayoutObjectText::Layout(wxDC &dc, class wxLayoutList *llist)
322 {
323 long descent = 0l;
324
325 // now this is done in wxLayoutLine::Layout(), but this code might be
326 // reenabled later - in principle, it's more efficient
327 #if 0
328 CoordType widthOld = m_Width,
329 heightOld = m_Height;
330 #endif // 0
331
332 #ifdef __WXDEBUG__
333 CoordType a,b,c,d,e,f;
334 dc.GetTextExtent("test ", &a, &b, &c);
335 dc.GetTextExtent("test", &d, &e, &f);
336 wxASSERT(a != d);
337 wxASSERT(b == e);
338 wxASSERT(c == f);
339 dc.GetTextExtent(" ", &d, &e, &f);
340 wxASSERT(a > 0);
341 #endif
342 dc.GetTextExtent(m_Text, &m_Width, &m_Height, &descent);
343
344 #if 0
345 if ( widthOld != m_Width || heightOld != m_Height )
346 {
347 // as the text length changed, it must be refreshed
348 wxLayoutLine *line = GetLine();
349
350 wxCHECK_RET( line, "wxLayoutObjectText can't refresh itself" );
351
352 // as our size changed, we need to repaint the part which was appended
353 wxPoint position(line->GetPosition());
354
355 // this is not the most efficient way (we repaint the whole line), but
356 // it's not too slow and is *simple*
357 if ( widthOld < m_Width )
358 widthOld = m_Width;
359 if ( heightOld < m_Height )
360 heightOld = m_Height;
361
362 llist->SetUpdateRect(position.x + widthOld + MSW_CORRECTION,
363 position.y + heightOld + MSW_CORRECTION);
364 }
365 #endif // 0
366
367 m_Bottom = descent;
368 m_Top = m_Height - m_Bottom;
369 }
370
371
372 #ifdef WXLAYOUT_DEBUG
373 void
374 wxLayoutObjectText::Debug(void)
375 {
376 wxLayoutObject::Debug();
377 WXLO_DEBUG((" `%s`", m_Text.c_str()));
378 }
379 #endif
380
381 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
382
383 wxLayoutObjectIcon
384
385 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
386
387 wxLayoutObjectIcon::wxLayoutObjectIcon(wxBitmap const &icon)
388 {
389 if ( !icon.Ok() )
390 {
391 wxFAIL_MSG("invalid icon");
392
393 m_Icon = NULL;
394
395 return;
396 }
397
398 #ifdef __WXMSW__
399 // FIXME ugly, ugly, ugly - but the only way to avoid slicing
400 m_Icon = icon.GetHBITMAP() ? new wxBitmap(icon)
401 : new wxBitmap(wxBitmap((const wxBitmap &)icon));
402 #else // !MSW
403 m_Icon = new wxBitmap(icon);
404 #endif // MSW/!MSW
405 }
406
407
408 void
409 wxLayoutObjectIcon::Write(wxString &ostr)
410 {
411 /* Exports icon through a temporary file. */
412
413 wxString file = wxGetTempFileName("wxloexport");
414
415 ostr << WXLO_TYPE_ICON << '\n'
416 << file << '\n';
417 m_Icon->SaveFile(file, WXLO_BITMAP_FORMAT);
418 }
419 /* static */
420 wxLayoutObjectIcon *
421 wxLayoutObjectIcon::Read(wxString &istr)
422 {
423 wxString file;
424 ReadString(file, istr);
425
426 if(! wxFileExists(file))
427 return NULL;
428 wxLayoutObjectIcon *obj = new wxLayoutObjectIcon;
429
430 if(!obj->m_Icon->LoadFile(file, WXLO_BITMAP_FORMAT))
431 {
432 delete obj;
433 return NULL;
434 }
435 else
436 return obj;
437 }
438
439 wxLayoutObject *
440 wxLayoutObjectIcon::Copy(void)
441 {
442 wxLayoutObjectIcon *obj = new wxLayoutObjectIcon(new
443 wxBitmap(*m_Icon));
444 obj->SetUserData(m_UserData);
445 return obj;
446 }
447
448 wxLayoutObjectIcon::wxLayoutObjectIcon(wxBitmap *icon)
449 {
450 m_Icon = icon;
451 }
452
453 void
454 wxLayoutObjectIcon::Draw(wxDC &dc, wxPoint const &coords,
455 wxLayoutList *wxllist,
456 CoordType begin, CoordType /* len */)
457 {
458 dc.DrawBitmap(*m_Icon, coords.x, coords.y-m_Icon->GetHeight(),
459 (m_Icon->GetMask() == NULL) ? FALSE : TRUE);
460 }
461
462 void
463 wxLayoutObjectIcon::Layout(wxDC & /* dc */, class wxLayoutList * )
464 {
465 }
466
467 wxPoint
468 wxLayoutObjectIcon::GetSize(CoordType *top, CoordType *bottom) const
469 {
470 *top = m_Icon->GetHeight();
471 *bottom = 0;
472 return wxPoint(m_Icon->GetWidth(), m_Icon->GetHeight());
473 }
474
475
476
477 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
478
479 wxLayoutObjectCmd
480
481 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
482
483
484 wxLayoutStyleInfo::wxLayoutStyleInfo(int ifamily,
485 int isize,
486 int istyle,
487 int iweight,
488 int iul,
489 wxColour *fg,
490 wxColour *bg)
491 {
492 family = ifamily;
493 size = isize;
494 style = istyle;
495 weight = iweight;
496 underline = iul != 0;
497
498 m_fg_valid = fg != 0;
499 m_bg_valid = bg != 0;
500 m_fg = m_fg_valid ? *fg : *wxBLACK;
501 m_bg = m_bg_valid ? *bg : *wxWHITE;
502 }
503
504 #define COPY_SI_(what) if(right.what != -1) what = right.what;
505
506 wxLayoutStyleInfo &
507 wxLayoutStyleInfo::operator=(const wxLayoutStyleInfo &right)
508 {
509 COPY_SI_(family);
510 COPY_SI_(style);
511 COPY_SI_(size);
512 COPY_SI_(weight);
513 COPY_SI_(underline);
514 if(right.m_fg_valid) m_fg = right.m_fg;
515 if(right.m_bg_valid) m_bg = right.m_bg;
516 return *this;
517 }
518
519 wxLayoutObjectCmd::wxLayoutObjectCmd(int family, int size, int style, int
520 weight, int underline,
521 wxColour *fg, wxColour *bg)
522
523 {
524 m_StyleInfo = new wxLayoutStyleInfo(family, size,style,weight,underline,fg,bg);
525 }
526
527 wxLayoutObject *
528 wxLayoutObjectCmd::Copy(void)
529 {
530 wxLayoutObjectCmd *obj = new wxLayoutObjectCmd(
531 m_StyleInfo->size,
532 m_StyleInfo->family,
533 m_StyleInfo->style,
534 m_StyleInfo->weight,
535 m_StyleInfo->underline,
536 m_StyleInfo->m_fg_valid ?
537 &m_StyleInfo->m_fg : NULL,
538 m_StyleInfo->m_bg_valid ?
539 &m_StyleInfo->m_bg : NULL);
540 obj->SetUserData(m_UserData);
541 return obj;
542 }
543
544 void
545 wxLayoutObjectCmd::Write(wxString &ostr)
546 {
547 ostr << WXLO_TYPE_CMD << '\n'
548 << m_StyleInfo->size << '\n'
549 << m_StyleInfo->family << '\n'
550 << m_StyleInfo->style << '\n'
551 << m_StyleInfo->weight << '\n'
552 << m_StyleInfo->underline << '\n'
553 << m_StyleInfo->m_fg_valid << '\n'
554 << m_StyleInfo->m_bg_valid << '\n';
555 if(m_StyleInfo->m_fg_valid)
556 {
557 ostr << m_StyleInfo->m_fg.Red() << '\n'
558 << m_StyleInfo->m_fg.Green() << '\n'
559 << m_StyleInfo->m_fg.Blue() << '\n';
560 }
561 if(m_StyleInfo->m_bg_valid)
562 {
563 ostr << m_StyleInfo->m_bg.Red() << '\n'
564 << m_StyleInfo->m_bg.Green() << '\n'
565 << m_StyleInfo->m_bg.Blue() << '\n';
566 }
567 }
568 /* static */
569 wxLayoutObjectCmd *
570 wxLayoutObjectCmd::Read(wxString &istr)
571 {
572 wxLayoutObjectCmd *obj = new wxLayoutObjectCmd;
573
574 wxString tmp;
575 ReadString(tmp, istr);
576 sscanf(tmp.c_str(),"%d", &obj->m_StyleInfo->size);
577 ReadString(tmp, istr);
578 sscanf(tmp.c_str(),"%d", &obj->m_StyleInfo->family);
579 ReadString(tmp, istr);
580 sscanf(tmp.c_str(),"%d", &obj->m_StyleInfo->style);
581 ReadString(tmp, istr);
582 sscanf(tmp.c_str(),"%d", &obj->m_StyleInfo->weight);
583 ReadString(tmp, istr);
584 sscanf(tmp.c_str(),"%d", &obj->m_StyleInfo->underline);
585 ReadString(tmp, istr);
586 sscanf(tmp.c_str(),"%d", &obj->m_StyleInfo->m_fg_valid);
587 ReadString(tmp, istr);
588 sscanf(tmp.c_str(),"%d", &obj->m_StyleInfo->m_bg_valid);
589 if(obj->m_StyleInfo->m_fg_valid)
590 {
591 int red, green, blue;
592 ReadString(tmp, istr);
593 sscanf(tmp.c_str(),"%d", &red);
594 ReadString(tmp, istr);
595 sscanf(tmp.c_str(),"%d", &green);
596 ReadString(tmp, istr);
597 sscanf(tmp.c_str(),"%d", &blue);
598 obj->m_StyleInfo->m_fg = wxColour(red, green, blue);
599 }
600 if(obj->m_StyleInfo->m_bg_valid)
601 {
602 int red, green, blue;
603 ReadString(tmp, istr);
604 sscanf(tmp.c_str(),"%d", &red);
605 ReadString(tmp, istr);
606 sscanf(tmp.c_str(),"%d", &green);
607 ReadString(tmp, istr);
608 sscanf(tmp.c_str(),"%d", &blue);
609 obj->m_StyleInfo->m_bg = wxColour(red, green, blue);
610 }
611 return obj;
612 }
613
614
615 wxLayoutObjectCmd::~wxLayoutObjectCmd()
616 {
617 delete m_StyleInfo;
618 }
619
620 wxLayoutStyleInfo *
621 wxLayoutObjectCmd::GetStyle(void) const
622 {
623 return m_StyleInfo;
624 }
625
626 void
627 wxLayoutObjectCmd::Draw(wxDC &dc, wxPoint const & /* coords */,
628 wxLayoutList *wxllist,
629 CoordType begin, CoordType /* len */)
630 {
631 wxASSERT(m_StyleInfo);
632 wxllist->ApplyStyle(*m_StyleInfo, dc);
633 }
634
635 void
636 wxLayoutObjectCmd::Layout(wxDC &dc, class wxLayoutList * llist)
637 {
638 // this get called, so that recalculation uses right font sizes
639 Draw(dc, wxPoint(0,0), llist);
640 }
641
642
643 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
644
645 The wxLayoutLine object
646
647 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
648
649 wxLayoutLine::wxLayoutLine(wxLayoutLine *prev, wxLayoutList *llist)
650 {
651 m_Width = m_Height = 0;
652 m_Length = 0;
653
654 m_updateLeft = -1;
655 MarkDirty(0);
656
657 m_Previous = prev;
658 m_Next = NULL;
659
660 m_LineNumber = 0;
661 RecalculatePosition(llist);
662
663 MarkDirty();
664 if(m_Previous)
665 {
666 m_LineNumber = m_Previous->GetLineNumber() + 1;
667 m_Next = m_Previous->GetNextLine();
668 m_Previous->m_Next = this;
669 }
670
671 if(m_Next)
672 {
673 m_Next->m_Previous = this;
674 m_Next->ReNumber();
675 }
676
677 m_StyleInfo = llist->GetDefaultStyleInfo();
678
679 llist->IncNumLines();
680 }
681
682 wxLayoutLine::~wxLayoutLine()
683 {
684 // kbList cleans itself
685 }
686
687 wxPoint
688 wxLayoutLine::RecalculatePosition(wxLayoutList *llist)
689 {
690 wxASSERT(m_Previous || GetLineNumber() == 0);
691
692 wxPoint posOld(m_Position);
693
694 if(m_Previous)
695 {
696 m_Position = m_Previous->GetPosition();
697 m_Position.y += m_Previous->GetHeight();
698 }
699 else
700 m_Position = wxPoint(0,0);
701
702 if ( m_Position != posOld )
703 {
704 // the whole line moved and must be repainted
705 llist->SetUpdateRect(m_Position);
706 llist->SetUpdateRect(m_Position.x + GetWidth() + MSW_CORRECTION,
707 m_Position.y + GetHeight() + MSW_CORRECTION);
708 llist->SetUpdateRect(posOld);
709 llist->SetUpdateRect(posOld.x + GetWidth() + MSW_CORRECTION,
710 posOld.y + GetHeight() + MSW_CORRECTION);
711 }
712
713 return m_Position;
714 }
715
716
717 wxLayoutObjectList::iterator
718 wxLayoutLine::FindObject(CoordType xpos, CoordType *offset) const
719 {
720 wxASSERT(xpos >= 0);
721 wxASSERT(offset);
722 wxLayoutObjectList::iterator
723 i,
724 found = NULLIT;
725 CoordType x = 0, len;
726
727 /* We search through the objects. As we don't like returning the
728 object that the cursor is behind, we just remember such an
729 object in "found" so we can return it if there is really no
730 further object following it. */
731 for(i = m_ObjectList.begin(); i != NULLIT; i++)
732 {
733 len = (**i).GetLength();
734 if( x <= xpos && xpos <= x + len )
735 {
736 *offset = xpos-x;
737 if(xpos == x + len) // is there another object behind?
738 found = i;
739 else // we are really inside this object
740 return i;
741 }
742 x += (**i).GetLength();
743 }
744 return found; // ==NULL if really none found
745 }
746
747 wxLayoutObjectList::iterator
748 wxLayoutLine::FindObjectScreen(wxDC &dc, wxLayoutList *llist,
749 CoordType xpos, CoordType *cxpos,
750 bool *found) const
751 {
752 wxASSERT(cxpos);
753
754 llist->ApplyStyle(GetStyleInfo(), dc);
755
756 wxLayoutObjectList::iterator i;
757 CoordType x = 0, cx = 0, width;
758
759 for(i = m_ObjectList.begin(); i != NULLIT; i++)
760 {
761 wxLayoutObject *obj = *i;
762 if ( obj->GetType() == WXLO_TYPE_CMD )
763 {
764 // this will set the correct font for the objects which follow
765 obj->Layout(dc, llist);
766 }
767
768 width = obj->GetWidth();
769 if( x <= xpos && xpos <= x + width )
770 {
771 *cxpos = cx + obj->GetOffsetScreen(dc, xpos-x);
772
773 if ( found )
774 *found = true;
775 return i;
776 }
777
778 x += obj->GetWidth();
779 cx += obj->GetLength();
780 }
781
782 // behind last object:
783 *cxpos = cx;
784
785 if (found)
786 *found = false;
787 return m_ObjectList.tail();
788 }
789
790 /** Finds text in this line.
791 @param needle the text to find
792 @param xpos the position where to start the search
793 @return the cursoor coord where it was found or -1
794 */
795 CoordType
796 wxLayoutLine::FindText(const wxString &needle, CoordType xpos) const
797 {
798 int
799 cpos = 0,
800 relpos = -1;
801 wxString const *text;
802
803 for(wxLOiterator i = m_ObjectList.begin(); i != m_ObjectList.end(); i++)
804 {
805 if(cpos >= xpos) // search from here!
806 {
807 if((**i).GetType() == WXLO_TYPE_TEXT)
808 {
809 text = & ((wxLayoutObjectText*)(*i))->GetText();
810 relpos = text->Find(needle);
811 if(relpos >= cpos-xpos) // -1 if not found
812 {
813 return cpos+relpos;
814 }
815 }
816 cpos += (**i).GetLength();
817 }
818 }
819 return -1; // not found
820 }
821
822 bool
823 wxLayoutLine::Insert(CoordType xpos, wxLayoutObject *obj)
824 {
825 wxASSERT(xpos >= 0);
826 wxASSERT(obj != NULL);
827
828 MarkDirty(xpos);
829
830 CoordType offset;
831 wxLOiterator i = FindObject(xpos, &offset);
832 if(i == NULLIT)
833 {
834 if(xpos == 0 ) // aha, empty line!
835 {
836 m_ObjectList.push_back(obj);
837 m_Length += obj->GetLength();
838 return true;
839 }
840 else
841 return false;
842 }
843
844 CoordType len = (**i).GetLength();
845 if(offset == 0 /*&& i != m_ObjectList.begin()*/) // why?
846 { // insert before this object
847 m_ObjectList.insert(i,obj);
848 m_Length += obj->GetLength();
849 return true;
850 }
851 if(offset == len )
852 {
853 if( i == m_ObjectList.tail()) // last object?
854 m_ObjectList.push_back(obj);
855 else
856 { // insert after current object
857 i++;
858 m_ObjectList.insert(i,obj);
859 }
860 m_Length += obj->GetLength();
861 return true;
862 }
863 /* Otherwise we need to split the current object.
864 Fortunately this can only be a text object. */
865 wxASSERT((**i).GetType() == WXLO_TYPE_TEXT);
866 wxString left, right;
867 wxLayoutObjectText *tobj = (wxLayoutObjectText *) *i;
868 left = tobj->GetText().substr(0,offset);
869 right = tobj->GetText().substr(offset,len-offset);
870 // current text object gets set to right half
871 tobj->GetText() = right; // set new text
872 // before it we insert the new object
873 m_ObjectList.insert(i,obj);
874 m_Length += obj->GetLength();
875 // and before that we insert the left half
876 m_ObjectList.insert(i,new wxLayoutObjectText(left));
877 return true;
878 }
879
880 bool
881 wxLayoutLine::Insert(CoordType xpos, const wxString& text)
882 {
883 wxASSERT(xpos >= 0);
884
885 MarkDirty(xpos);
886
887 CoordType offset;
888 wxLOiterator i = FindObject(xpos, &offset);
889 if(i != NULLIT && (**i).GetType() == WXLO_TYPE_TEXT)
890 {
891 wxLayoutObjectText *tobj = (wxLayoutObjectText *) *i;
892 tobj->GetText().insert(offset, text);
893 m_Length += text.Length();
894 }
895 else
896 {
897 if ( !Insert(xpos, new wxLayoutObjectText(text)) )
898 return false;
899 }
900
901 return true;
902 }
903
904 CoordType
905 wxLayoutLine::Delete(CoordType xpos, CoordType npos)
906 {
907 CoordType offset, len;
908
909 wxASSERT(xpos >= 0);
910 wxASSERT(npos >= 0);
911 MarkDirty(xpos);
912 wxLOiterator i = FindObject(xpos, &offset);
913 while(npos > 0)
914 {
915 if(i == NULLIT) return npos;
916 // now delete from that object:
917 if((**i).GetType() != WXLO_TYPE_TEXT)
918 {
919 if(offset != 0) // at end of line after a non-text object
920 return npos;
921 // always len == 1:
922 len = (**i).GetLength();
923 m_Length -= len;
924 npos -= len;
925 m_ObjectList.erase(i);
926 }
927 else
928 {
929 // tidy up: remove empty text objects
930 if((**i).GetLength() == 0)
931 {
932 m_ObjectList.erase(i);
933 continue;
934 }
935 // Text object:
936 CoordType max = (**i).GetLength() - offset;
937 if(npos < max) max = npos;
938 if(max == 0)
939 {
940 if(xpos == GetLength())
941 return npos;
942 else
943 { // at the end of an object
944 // move to begin of next object:
945 i++; offset = 0;
946 continue; // start over
947 }
948 }
949 npos -= max;
950 m_Length -= max;
951 if(offset == 0 && max == (**i).GetLength())
952 m_ObjectList.erase(i); // remove the whole object
953 else
954 ((wxLayoutObjectText *)(*i))->GetText().Remove(offset,max);
955 }
956 }
957
958 return npos;
959 }
960
961 bool
962 wxLayoutLine::DeleteWord(CoordType xpos)
963 {
964 wxASSERT(xpos >= 0);
965 CoordType offset;
966 MarkDirty(xpos);
967
968 wxLOiterator i = FindObject(xpos, &offset);
969
970 for(;;)
971 {
972 if(i == NULLIT) return false;
973 if((**i).GetType() != WXLO_TYPE_TEXT)
974 {
975 // This should only happen when at end of line, behind a non-text
976 // object:
977 if(offset == (**i).GetLength()) return false;
978 m_Length -= (**i).GetLength(); // -1
979 m_ObjectList.erase(i);
980 return true; // we are done
981 }
982 else
983 { // text object:
984 if(offset == (**i).GetLength()) // at end of object
985 {
986 i++; offset = 0;
987 continue;
988 }
989 wxLayoutObjectText *tobj = (wxLayoutObjectText *)*i;
990 size_t count = 0;
991 wxString str = tobj->GetText();
992 str = str.substr(offset,str.Length()-offset);
993 // Find out how many positions we need to delete:
994 // 1. eat leading space
995 while(isspace(str.c_str()[count])) count++;
996 // 2. eat the word itself:
997 while(isalnum(str.c_str()[count])) count++;
998 // now delete it:
999 wxASSERT(count+offset <= (size_t) (**i).GetLength());
1000 ((wxLayoutObjectText *)*i)->GetText().erase(offset,count);
1001 m_Length -= count;
1002 return true;
1003 }
1004 }
1005
1006 wxFAIL_MSG("unreachable");
1007 }
1008
1009 wxLayoutLine *
1010 wxLayoutLine::DeleteLine(bool update, wxLayoutList *llist)
1011 {
1012 // maintain linked list integrity
1013 if(m_Next)
1014 m_Next->m_Previous = m_Previous;
1015 if(m_Previous)
1016 m_Previous->m_Next = m_Next;
1017
1018 // get the line numbers right again
1019 if ( update && m_Next)
1020 m_Next->ReNumber();
1021
1022 MarkDirty();
1023
1024 // we can't use m_Next after "delete this", so we must save this pointer
1025 // first
1026 wxLayoutLine *next = m_Next;
1027 delete this;
1028
1029 llist->DecNumLines();
1030
1031 return next;
1032 }
1033
1034 void
1035 wxLayoutLine::Draw(wxDC &dc,
1036 wxLayoutList *llist,
1037 const wxPoint & offset) const
1038 {
1039 wxLayoutObjectList::iterator i;
1040 wxPoint pos = offset;
1041 pos = pos + GetPosition();
1042
1043 pos.y += m_BaseLine;
1044
1045 CoordType xpos = 0; // cursorpos, lenght of line
1046
1047 CoordType from, to, tempto;
1048
1049 int highlight = llist->IsSelected(this, &from, &to);
1050 // WXLO_DEBUG(("highlight=%d", highlight ));
1051 if(highlight == 1) // we need to draw the whole line inverted!
1052 llist->StartHighlighting(dc);
1053 else
1054 llist->EndHighlighting(dc);
1055
1056 for(i = m_ObjectList.begin(); i != NULLIT; i++)
1057 {
1058 if(highlight == -1) // partially highlight line
1059 {
1060 // parts of the line need highlighting
1061 tempto = xpos+(**i).GetLength();
1062 (**i).Draw(dc, pos, llist, from-xpos, to-xpos);
1063 }
1064 else
1065 (**i).Draw(dc, pos, llist);
1066 pos.x += (**i).GetWidth();
1067 xpos += (**i).GetLength();
1068 }
1069 }
1070
1071 /*
1072 This function does all the recalculation, that is, it should only be
1073 called from within wxLayoutList::Layout(), as it uses the current
1074 list's styleinfo and updates it.
1075 */
1076 void
1077 wxLayoutLine::Layout(wxDC &dc,
1078 wxLayoutList *llist,
1079 wxPoint *cursorPos,
1080 wxPoint *cursorSize,
1081 wxLayoutStyleInfo *cursorStyle,
1082 int cx,
1083 bool suppressSIupdate)
1084 {
1085 wxLayoutObjectList::iterator i;
1086
1087 // when a line becomes dirty, we redraw it from the place where it was
1088 // changed till the end of line (because the following wxLayoutObjects are
1089 // moved when the preceding one changes) - calculate the update rectangle.
1090 CoordType updateTop = m_Position.y,
1091 updateLeft = -1,
1092 updateWidth = m_Width,
1093 updateHeight = m_Height;
1094
1095 CoordType
1096 topHeight = 0,
1097 bottomHeight = 0; // above and below baseline
1098 CoordType
1099 objTopHeight, objBottomHeight; // above and below baseline
1100 CoordType
1101 len, count = 0;
1102
1103 CoordType heightOld = m_Height;
1104
1105 m_Height = 0;
1106 m_Width = 0;
1107 m_BaseLine = 0;
1108
1109 bool cursorFound = false;
1110
1111 RecalculatePosition(llist);
1112
1113 if(cursorPos)
1114 {
1115 *cursorPos = m_Position;
1116 if(cursorSize) *cursorSize = wxPoint(0,0);
1117 }
1118
1119 m_StyleInfo = llist->GetStyleInfo(); // save current style
1120 for(i = m_ObjectList.begin(); i != NULLIT; i++)
1121 {
1122 wxLayoutObject *obj = *i;
1123 obj->Layout(dc, llist);
1124 wxPoint sizeObj = obj->GetSize(&objTopHeight, &objBottomHeight);
1125
1126 if(cursorPos && ! cursorFound)
1127 {
1128 // we need to check whether the text cursor is here
1129 len = obj->GetLength();
1130 if(count <= cx && count+len > cx)
1131 {
1132 if(obj->GetType() == WXLO_TYPE_TEXT)
1133 {
1134 len = cx - count; // pos in object
1135 CoordType width, height, descent;
1136 dc.GetTextExtent((*(wxLayoutObjectText*)*i).GetText().substr(0,len),
1137 &width, &height, &descent);
1138 cursorPos->x += width;
1139 cursorPos->y = m_Position.y;
1140 wxString str;
1141 if(len < obj->GetLength())
1142 str = (*(wxLayoutObjectText*)*i).GetText().substr(len,1);
1143 else
1144 str = WXLO_CURSORCHAR;
1145 dc.GetTextExtent(str, &width, &height, &descent);
1146
1147 if(cursorStyle) // set style info
1148 *cursorStyle = llist->GetStyleInfo();
1149 if ( cursorSize )
1150 {
1151 // Just in case some joker inserted an empty string object:
1152 if(width == 0)
1153 width = WXLO_MINIMUM_CURSOR_WIDTH;
1154 if(height == 0)
1155 height = sizeObj.y;
1156 cursorSize->x = width;
1157 cursorSize->y = height;
1158 }
1159
1160 cursorFound = true; // no more checks
1161 }
1162 else
1163 {
1164 // on some other object
1165 CoordType top, bottom; // unused
1166 if(cursorSize)
1167 *cursorSize = obj->GetSize(&top,&bottom);
1168 cursorPos->y = m_Position.y;
1169 cursorFound = true; // no more checks
1170 }
1171 }
1172 else
1173 {
1174 count += len;
1175 cursorPos->x += obj->GetWidth();
1176 }
1177 } // cursor finding
1178
1179 m_Width += sizeObj.x;
1180 if(sizeObj.y > m_Height)
1181 {
1182 m_Height = sizeObj.y;
1183 }
1184
1185 if(objTopHeight > topHeight)
1186 topHeight = objTopHeight;
1187 if(objBottomHeight > bottomHeight)
1188 bottomHeight = objBottomHeight;
1189 }
1190
1191 if ( IsDirty() )
1192 {
1193 if ( updateHeight < m_Height )
1194 updateHeight = m_Height;
1195 if ( updateWidth < m_Width )
1196 updateWidth = m_Width;
1197
1198 // update all line if we don't know where to start from
1199 if ( updateLeft == -1 )
1200 updateLeft = 0;
1201
1202 llist->SetUpdateRect(updateLeft, updateTop);
1203 llist->SetUpdateRect(updateLeft + updateWidth + MSW_CORRECTION,
1204 updateTop + updateHeight + MSW_CORRECTION);
1205 }
1206
1207 if(topHeight + bottomHeight > m_Height)
1208 {
1209 m_Height = topHeight+bottomHeight;
1210 }
1211
1212 m_BaseLine = topHeight;
1213
1214 if(m_Height == 0)
1215 {
1216 CoordType width, height, descent;
1217 dc.GetTextExtent(WXLO_CURSORCHAR, &width, &height, &descent);
1218 m_Height = height;
1219 m_BaseLine = m_Height - descent;
1220 }
1221
1222 // tell next line about coordinate change
1223 if(m_Next && m_Height != heightOld)
1224 {
1225 m_Next->MarkDirty();
1226 }
1227
1228 // We need to check whether we found a valid cursor size:
1229 if(cursorPos && cursorSize)
1230 {
1231 // this might be the case if the cursor is at the end of the
1232 // line or on a command object:
1233 if(cursorSize->x < WXLO_MINIMUM_CURSOR_WIDTH)
1234 {
1235 CoordType width, height, descent;
1236 dc.GetTextExtent(WXLO_CURSORCHAR, &width, &height, &descent);
1237 cursorSize->x = width;
1238 cursorSize->y = height;
1239 }
1240 if(m_BaseLine >= cursorSize->y) // the normal case anyway
1241 cursorPos->y += m_BaseLine-cursorSize->y;
1242 }
1243 MarkClean();
1244 }
1245
1246
1247 wxLayoutLine *
1248 wxLayoutLine::Break(CoordType xpos, wxLayoutList *llist)
1249 {
1250 wxASSERT(xpos >= 0);
1251
1252 MarkDirty(xpos);
1253
1254 CoordType offset;
1255 wxLOiterator i = FindObject(xpos, &offset);
1256 if(i == NULLIT)
1257 // must be at the end of the line then
1258 return new wxLayoutLine(this, llist);
1259 // split this line:
1260
1261 wxLayoutLine *newLine = new wxLayoutLine(this, llist);
1262 // split object at i:
1263 if((**i).GetType() == WXLO_TYPE_TEXT && offset != 0)
1264 {
1265 wxString left, right;
1266 wxLayoutObjectText *tobj = (wxLayoutObjectText *) *i;
1267 left = tobj->GetText().substr(0,offset);
1268 right = tobj->GetText().substr(offset,tobj->GetLength()-offset);
1269 // current text object gets set to left half
1270 tobj->GetText() = left; // set new text
1271 newLine->Append(new wxLayoutObjectText(right));
1272 m_Length -= right.Length();
1273 i++; // don't move this object to the new list
1274 }
1275 else
1276 {
1277 if(offset > 0)
1278 i++; // move objects from here to new list
1279 }
1280
1281 while(i != m_ObjectList.end())
1282 {
1283 wxLayoutObject *obj = *i;
1284 newLine->Append(obj);
1285 m_Length -= obj->GetLength();
1286
1287 m_ObjectList.remove(i); // remove without deleting it
1288 }
1289 if(m_Next)
1290 m_Next->MarkDirty();
1291 return newLine;
1292 }
1293
1294 void
1295 wxLayoutLine::ReNumber(void)
1296 {
1297 CoordType lineNo = m_Previous ? m_Previous->m_LineNumber+1 : 0;
1298 m_LineNumber = lineNo++;
1299
1300 for(wxLayoutLine *next = GetNextLine();
1301 next; next = next->GetNextLine())
1302 next->m_LineNumber = lineNo++;
1303 }
1304
1305 void
1306 wxLayoutLine::MergeNextLine(wxLayoutList *llist)
1307 {
1308 wxCHECK_RET(GetNextLine(),"wxLayout internal error: no next line to merge");
1309 wxLayoutObjectList &list = GetNextLine()->m_ObjectList;
1310 wxLOiterator i;
1311
1312 MarkDirty(GetWidth());
1313
1314 wxLayoutObject *last = NULL;
1315 for(i = list.begin(); i != list.end();)
1316 {
1317 wxLayoutObject *current = *i;
1318
1319 // merge text objects together for efficiency
1320 if ( last && last->GetType() == WXLO_TYPE_TEXT &&
1321 current->GetType() == WXLO_TYPE_TEXT )
1322 {
1323 wxLayoutObjectText *textObj = (wxLayoutObjectText *)last;
1324 wxString text(textObj->GetText());
1325 text += ((wxLayoutObjectText *)current)->GetText();
1326 textObj->SetText(text);
1327
1328 list.erase(i); // remove and delete it
1329 }
1330 else
1331 {
1332 // just append the object "as was"
1333 Append(current);
1334
1335 list.remove(i); // remove without deleting it
1336 }
1337 }
1338 wxASSERT(list.empty());
1339
1340 wxLayoutLine *oldnext = GetNextLine();
1341 wxLayoutLine *nextLine = oldnext->GetNextLine();
1342 SetNext(nextLine);
1343 if ( nextLine )
1344 {
1345 nextLine->ReNumber();
1346 }
1347 else
1348 {
1349 // this is now done in Delete(), but if this function is ever called
1350 // from elsewhere, we might have to move refresh code back here (in
1351 // order not to duplicate it)
1352 #if 0
1353 wxPoint pos(oldnext->GetPosition());
1354 llist->SetUpdateRect(pos);
1355 llist->SetUpdateRect(pos.x + oldnext->GetWidth() + MSW_CORRECTION,
1356 pos.y + oldnext->GetHeight() + MSW_CORRECTION);
1357 #endif // 0
1358 }
1359
1360 llist->DecNumLines();
1361
1362 delete oldnext;
1363 }
1364
1365 CoordType
1366 wxLayoutLine::GetWrapPosition(CoordType column)
1367 {
1368 CoordType offset;
1369 wxLOiterator i = FindObject(column, &offset);
1370 if(i == NULLIT) return -1; // cannot wrap
1371
1372 // go backwards through the list and look for space in text objects
1373 do
1374 {
1375 if((**i).GetType() == WXLO_TYPE_TEXT)
1376 {
1377 do
1378 {
1379 if( isspace(((wxLayoutObjectText*)*i)->GetText().c_str()[(size_t)offset]))
1380 return column;
1381 else
1382 {
1383 offset--;
1384 column--;
1385 }
1386 }while(offset != -1);
1387 i--; // move on to previous object
1388 }
1389 else
1390 {
1391 column -= (**i).GetLength();
1392 i--;
1393 }
1394 if( i != NULLIT)
1395 offset = (**i).GetLength();
1396 }while(i != NULLIT);
1397 /* If we reached the begin of the list and have more than one
1398 object, that one is longer than the margin, so break behind
1399 it. */
1400 CoordType pos = 0;
1401 i = m_ObjectList.begin();
1402 while(i != NULLIT && (**i).GetType() != WXLO_TYPE_TEXT)
1403 {
1404 pos += (**i).GetLength();
1405 i++;
1406 }
1407 if(i == NULLIT) return -1; //why should this happen?
1408 pos += (**i).GetLength();
1409 i++;
1410 while(i != NULLIT && (**i).GetType() != WXLO_TYPE_TEXT)
1411 {
1412 pos += (**i).GetLength();
1413 i++;
1414 }
1415 if(i == NULLIT) return -1; //this is possible, if there is only one text object
1416 // now we are at the second text object:
1417 pos -= (**i).GetLength();
1418 return pos; // in front of it
1419 }
1420
1421
1422 #ifdef WXLAYOUT_DEBUG
1423 void
1424 wxLayoutLine::Debug(void)
1425 {
1426 wxString tmp;
1427 wxPoint pos = GetPosition();
1428 WXLO_DEBUG(("Line %ld, Pos (%ld,%ld), Height %ld, BL %ld, Font: %d",
1429 (long int) GetLineNumber(),
1430 (long int) pos.x, (long int) pos.y,
1431 (long int) GetHeight(),
1432 (long int) m_BaseLine,
1433 (int) m_StyleInfo.family));
1434 if(m_ObjectList.begin() != NULLIT)
1435 (**m_ObjectList.begin()).Debug();
1436
1437 }
1438 #endif
1439
1440 void
1441 wxLayoutLine::Copy(wxLayoutList *llist,
1442 CoordType from,
1443 CoordType to)
1444 {
1445 CoordType firstOffset, lastOffset;
1446
1447 if(to == -1) to = GetLength();
1448 if(from == to) return;
1449
1450 wxLOiterator first = FindObject(from, &firstOffset);
1451 wxLOiterator last = FindObject(to, &lastOffset);
1452
1453 // Common special case: only one object
1454 if( first != NULLIT && last != NULLIT && *first == *last )
1455 {
1456 if( (**first).GetType() == WXLO_TYPE_TEXT )
1457 {
1458 llist->Insert(new wxLayoutObjectText(
1459 ((wxLayoutObjectText
1460 *)*first)->GetText().substr(firstOffset,
1461 lastOffset-firstOffset))
1462 );
1463 return;
1464 }
1465 else // what can we do?
1466 {
1467 if(lastOffset > firstOffset) // i.e. +1 :-)
1468 llist->Insert( (**first).Copy() );
1469 return;
1470 }
1471 }
1472
1473 // If we reach here, we can safely copy the whole first object from
1474 // the firstOffset position on:
1475 if((**first).GetType() == WXLO_TYPE_TEXT && firstOffset != 0)
1476 {
1477 llist->Insert(new wxLayoutObjectText(
1478 ((wxLayoutObjectText *)*first)->GetText().substr(firstOffset))
1479 );
1480 }
1481 else if(firstOffset == 0)
1482 llist->Insert( (**first).Copy() );
1483 // else nothing to copy :-(
1484
1485 // Now we copy all objects before the last one:
1486 wxLOiterator i = first; i++;
1487 for( ; i != last; i++)
1488 llist->Insert( (**i).Copy() );
1489
1490 // And now the last object:
1491 if(lastOffset != 0)
1492 {
1493 if( (**last).GetType() == WXLO_TYPE_TEXT )
1494 {
1495 llist->Insert(new wxLayoutObjectText(
1496 ((wxLayoutObjectText *)*last)->GetText().substr(0,lastOffset))
1497 );
1498 }
1499 else
1500 llist->Insert( (**last).Copy() );
1501 }
1502 }
1503
1504
1505 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
1506
1507 The wxLayoutList object
1508
1509 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1510
1511 wxLayoutList::wxLayoutList()
1512 {
1513 #ifdef WXLAYOUT_USE_CARET
1514 m_caret = NULL;
1515 #endif // WXLAYOUT_USE_CARET
1516
1517 m_numLines = 0;
1518 m_FirstLine = NULL;
1519 SetAutoFormatting(TRUE);
1520 ForceTotalLayout(TRUE); // for the first time, do all
1521 InvalidateUpdateRect();
1522 Clear();
1523 }
1524
1525 wxLayoutList::~wxLayoutList()
1526 {
1527 SetAutoFormatting(FALSE);
1528 InternalClear();
1529 Empty();
1530 m_FirstLine->DeleteLine(false, this);
1531
1532 wxASSERT_MSG( m_numLines == 0, "line count calculation broken" );
1533 }
1534
1535 void
1536 wxLayoutList::Empty(void)
1537 {
1538 while(m_FirstLine)
1539 m_FirstLine = m_FirstLine->DeleteLine(false, this);
1540
1541 m_CursorPos = wxPoint(0,0);
1542 m_CursorScreenPos = wxPoint(0,0);
1543 m_CursorSize = wxPoint(0,0);
1544 m_movedCursor = true;
1545 m_FirstLine = new wxLayoutLine(NULL, this); // empty first line
1546 m_CursorLine = m_FirstLine;
1547 InvalidateUpdateRect();
1548 }
1549
1550
1551 void
1552 wxLayoutList::InternalClear(void)
1553 {
1554 m_Selection.m_selecting = false;
1555 m_Selection.m_valid = false;
1556
1557 m_DefaultStyleInfo.family = wxSWISS;
1558 m_DefaultStyleInfo.size = WXLO_DEFAULTFONTSIZE;
1559 m_DefaultStyleInfo.style = wxNORMAL;
1560 m_DefaultStyleInfo.weight = wxNORMAL;
1561 m_DefaultStyleInfo.underline = 0;
1562 m_DefaultStyleInfo.m_fg_valid = TRUE;
1563 m_DefaultStyleInfo.m_fg = *wxBLACK;
1564 m_DefaultStyleInfo.m_bg_valid = TRUE;
1565 m_DefaultStyleInfo.m_bg = *wxWHITE;
1566
1567 m_CurrentStyleInfo = m_DefaultStyleInfo;
1568 m_CursorStyleInfo = m_DefaultStyleInfo;
1569 }
1570
1571 void
1572 wxLayoutList::SetFont(int family, int size, int style, int weight,
1573 int underline, wxColour *fg,
1574 wxColour *bg)
1575 {
1576 if(family != -1) m_CurrentStyleInfo.family = family;
1577 if(size != -1) m_CurrentStyleInfo.size = size;
1578 if(style != -1) m_CurrentStyleInfo.style = style;
1579 if(weight != -1) m_CurrentStyleInfo.weight = weight;
1580 if(underline != -1) m_CurrentStyleInfo.underline = underline != 0;
1581 if(fg) m_CurrentStyleInfo.m_fg = *fg;
1582 if(bg) m_CurrentStyleInfo.m_bg = *bg;
1583 Insert(
1584 new wxLayoutObjectCmd(
1585 m_CurrentStyleInfo.family,
1586 m_CurrentStyleInfo.size,
1587 m_CurrentStyleInfo.style,
1588 m_CurrentStyleInfo.weight,
1589 m_CurrentStyleInfo.underline,
1590 fg, bg));
1591 }
1592
1593 void
1594 wxLayoutList::SetFont(int family, int size, int style, int weight,
1595 int underline, char const *fg, char const *bg)
1596
1597 {
1598 wxColour
1599 *cfg = NULL,
1600 *cbg = NULL;
1601
1602 if( fg )
1603 cfg = wxTheColourDatabase->FindColour(fg);
1604 if( bg )
1605 cbg = wxTheColourDatabase->FindColour(bg);
1606
1607 SetFont(family,size,style,weight,underline,cfg,cbg);
1608 }
1609
1610 void
1611 wxLayoutList::Clear(int family, int size, int style, int weight,
1612 int underline, wxColour *fg, wxColour *bg)
1613 {
1614 InternalClear();
1615 m_DefaultStyleInfo = wxLayoutStyleInfo(family, size, style, weight,
1616 underline, fg, bg);
1617 m_CurrentStyleInfo = m_DefaultStyleInfo;
1618
1619 // Empty() should be called after we set m_DefaultStyleInfo because
1620 // otherwise the style info for the first line (created in Empty()) would be
1621 // incorrect
1622 Empty();
1623 }
1624
1625 wxPoint
1626 wxLayoutList::FindText(const wxString &needle, const wxPoint &cpos) const
1627 {
1628 int xpos;
1629
1630 wxLayoutLine *line;
1631 for(line = m_FirstLine;
1632 line;
1633 line = line->GetNextLine())
1634 {
1635 if(line->GetLineNumber() >= cpos.y)
1636 {
1637 xpos = line->FindText(needle,
1638 (line->GetLineNumber() == cpos.y) ?
1639 cpos.x : 0);
1640 if(xpos != -1)
1641 return wxPoint(xpos, line->GetLineNumber());
1642 }
1643 }
1644 return wxPoint(-1,-1);
1645 }
1646
1647
1648 bool
1649 wxLayoutList::MoveCursorTo(wxPoint const &p)
1650 {
1651 AddCursorPosToUpdateRect();
1652
1653 wxPoint cursorPosOld = m_CursorPos;
1654
1655 wxLayoutLine *line = m_FirstLine;
1656 while(line && line->GetLineNumber() != p.y)
1657 line = line->GetNextLine();
1658 if(line && line->GetLineNumber() == p.y) // found it
1659 {
1660 m_CursorPos.y = p.y;
1661 m_CursorLine = line;
1662 CoordType len = line->GetLength();
1663 if(len >= p.x)
1664 {
1665 m_CursorPos.x = p.x;
1666 }
1667 else
1668 {
1669 m_CursorPos.x = len;
1670 }
1671 }
1672
1673 m_movedCursor = m_CursorPos != cursorPosOld;
1674
1675 return m_CursorPos == p;
1676 }
1677
1678 bool
1679 wxLayoutList::MoveCursorVertically(int n)
1680 {
1681 AddCursorPosToUpdateRect();
1682
1683 wxPoint cursorPosOld = m_CursorPos;
1684
1685 bool rc;
1686 if(n < 0) // move up
1687 {
1688 if(m_CursorLine == m_FirstLine) return false;
1689 while(n < 0 && m_CursorLine)
1690 {
1691 m_CursorLine = m_CursorLine->GetPreviousLine();
1692 m_CursorPos.y--;
1693 n++;
1694 }
1695 if(! m_CursorLine)
1696 {
1697 m_CursorLine = m_FirstLine;
1698 m_CursorPos.y = 0;
1699 rc = false;
1700 }
1701 else
1702 {
1703 if(m_CursorPos.x > m_CursorLine->GetLength())
1704 m_CursorPos.x = m_CursorLine->GetLength();
1705 rc = true;
1706 }
1707 }
1708 else // move down
1709 {
1710 wxLayoutLine *last = m_CursorLine;
1711 if(! m_CursorLine->GetNextLine()) return false;
1712 while(n > 0 && m_CursorLine)
1713 {
1714 n--;
1715 m_CursorPos.y ++;
1716 m_CursorLine = m_CursorLine->GetNextLine();
1717 }
1718 if(! m_CursorLine)
1719 {
1720 m_CursorLine = last;
1721 m_CursorPos.y --;
1722 rc = false;
1723 }
1724 else
1725 {
1726 if(m_CursorPos.x > m_CursorLine->GetLength())
1727 m_CursorPos.x = m_CursorLine->GetLength();
1728 rc = true;
1729 }
1730 }
1731
1732 m_movedCursor = m_CursorPos != cursorPosOld;
1733
1734 return rc;
1735 }
1736
1737 bool
1738 wxLayoutList::MoveCursorHorizontally(int n)
1739 {
1740 AddCursorPosToUpdateRect();
1741
1742 wxPoint cursorPosOld = m_CursorPos;
1743
1744 int move;
1745 while(n < 0)
1746 {
1747 if(m_CursorPos.x == 0) // at begin of line
1748 {
1749 if(! MoveCursorVertically(-1))
1750 break;
1751 MoveCursorToEndOfLine();
1752 n++;
1753 continue;
1754 }
1755 move = -n;
1756 if(move > m_CursorPos.x) move = m_CursorPos.x;
1757 m_CursorPos.x -= move; n += move;
1758 }
1759
1760 while(n > 0)
1761 {
1762 int len = m_CursorLine->GetLength();
1763 if(m_CursorPos.x == len) // at end of line
1764 {
1765 if(! MoveCursorVertically(1))
1766 break;
1767 MoveCursorToBeginOfLine();
1768 n--;
1769 continue;
1770 }
1771 move = n;
1772 if( move >= len-m_CursorPos.x) move = len-m_CursorPos.x;
1773 m_CursorPos.x += move;
1774 n -= move;
1775 }
1776
1777 m_movedCursor = m_CursorPos != cursorPosOld;
1778
1779 return n == 0;
1780 }
1781
1782 bool
1783 wxLayoutList::MoveCursorWord(int n, bool untilNext)
1784 {
1785 wxCHECK_MSG( m_CursorLine, false, "no current line" );
1786 wxCHECK_MSG( n == -1 || n == +1, false, "not implemented yet" );
1787
1788 CoordType moveDistance = 0;
1789 CoordType offset;
1790 wxLayoutLine *lineCur = m_CursorLine;
1791 for ( wxLOiterator i = lineCur->FindObject(m_CursorPos.x, &offset);
1792 n != 0;
1793 n > 0 ? i++ : i-- )
1794 {
1795 if ( i == NULLIT )
1796 {
1797 if ( n > 0 )
1798 {
1799 // moving forward, pass to the first object of the next line
1800 moveDistance++;
1801 lineCur = lineCur->GetNextLine();
1802 if ( lineCur )
1803 i = lineCur->GetFirstObject();
1804 }
1805 else
1806 {
1807 // moving backwards, pass to the last object of the prev line
1808 moveDistance--;
1809 lineCur = lineCur->GetPreviousLine();
1810 if ( lineCur )
1811 i = lineCur->GetLastObject();
1812 }
1813
1814 if ( i == NULLIT )
1815 {
1816 // moved to the end/beginning of text
1817 return false;
1818 }
1819
1820 offset = -1;
1821 }
1822
1823 wxLayoutObject *obj = *i;
1824
1825 if ( offset == -1 )
1826 {
1827 // calculate offset: we are either at the very beginning or the very
1828 // end of the object, so it isn't very difficult (the only time when
1829 // offset is != -1 is for the very first iteration when its value is
1830 // returned by FindObject)
1831 if ( n > 0 )
1832 offset = 0;
1833 else
1834 offset = obj->GetLength();
1835 }
1836
1837 if( obj->GetType() != WXLO_TYPE_TEXT )
1838 {
1839 // any visible non text objects count as one word
1840 if ( obj->IsVisibleObject() )
1841 {
1842 n > 0 ? n-- : n++;
1843
1844 moveDistance += obj->GetLength();
1845 }
1846 }
1847 else // text object
1848 {
1849 wxLayoutObjectText *tobj = (wxLayoutObjectText *)obj;
1850
1851 bool canAdvance = true;
1852
1853 if ( offset == tobj->GetLength() )
1854 {
1855 // at end of object
1856 if ( n > 0 )
1857 {
1858 // can't move further in this text object
1859 canAdvance = false;
1860
1861 // still should move over the object border
1862 moveDistance++;
1863 n--;
1864 }
1865 else if ( offset > 0 )
1866 {
1867 // offset is off by 1, make it a valid index
1868 offset--;
1869 }
1870 }
1871
1872 if ( canAdvance )
1873 {
1874 const wxString& text = tobj->GetText();
1875 const char *start = text.c_str();
1876 const char *end = start + text.length();
1877 const char *p = start + offset;
1878
1879 if ( n < 0 )
1880 {
1881 if ( offset > 0 )
1882 p--;
1883 }
1884
1885 // to the beginning/end of the next/prev word
1886 while ( p >= start && p < end && isspace(*p) )
1887 {
1888 n > 0 ? p++ : p--;
1889 }
1890
1891 // go to the end/beginning of the word (in a broad sense...)
1892 while ( p >= start && p < end && !isspace(*p) )
1893 {
1894 n > 0 ? p++ : p--;
1895 }
1896
1897 if ( n > 0 )
1898 {
1899 if ( untilNext )
1900 {
1901 // now advance to the beginning of the next word
1902 while ( isspace(*p) && p < end )
1903 p++;
1904 }
1905 }
1906 else // backwards
1907 {
1908 // in these 2 cases we took 1 char too much
1909 if ( (p < start) || isspace(*p) )
1910 {
1911 p++;
1912 }
1913 }
1914
1915 CoordType moveDelta = p - start - offset;
1916 if ( (n < 0) && (offset == tobj->GetLength() - 1) )
1917 {
1918 // because we substracted 1 from offset in this case above, now
1919 // compensate for it
1920 moveDelta--;
1921 }
1922
1923 if ( moveDelta != 0 )
1924 {
1925 moveDistance += moveDelta;
1926
1927 n > 0 ? n-- : n++;
1928 }
1929 }
1930 }
1931
1932 // except for the first iteration, offset is calculated in the beginning
1933 // of the loop
1934 offset = -1;
1935 }
1936
1937 MoveCursorHorizontally(moveDistance);
1938
1939 return true;
1940 }
1941
1942 bool
1943 wxLayoutList::Insert(wxString const &text)
1944 {
1945 wxASSERT(m_CursorLine);
1946 wxASSERT_MSG( text.Find('\n') == wxNOT_FOUND, "use wxLayoutImportText!" );
1947
1948 if ( !text )
1949 return true;
1950
1951 AddCursorPosToUpdateRect();
1952
1953 if ( !m_CursorLine->Insert(m_CursorPos.x, text) )
1954 return false;
1955
1956 m_CursorPos.x += text.Length();
1957
1958 m_movedCursor = true;
1959
1960 if(m_AutoFormat)
1961 m_CursorLine->MarkDirty();
1962
1963 return true;
1964 }
1965
1966 bool
1967 wxLayoutList::Insert(wxLayoutObject *obj)
1968 {
1969 wxASSERT(m_CursorLine);
1970
1971 if(! m_CursorLine)
1972 m_CursorLine = GetFirstLine();
1973
1974 AddCursorPosToUpdateRect();
1975
1976 m_CursorLine->Insert(m_CursorPos.x, obj);
1977 m_CursorPos.x += obj->GetLength();
1978 m_movedCursor = true;
1979
1980 if(m_AutoFormat)
1981 m_CursorLine->MarkDirty();
1982
1983 return true;
1984 }
1985
1986 bool
1987 wxLayoutList::Insert(wxLayoutList *llist)
1988 {
1989 wxASSERT(llist);
1990 bool rc = TRUE;
1991
1992 for(wxLayoutLine *line = llist->GetFirstLine();
1993 line;
1994 line = line->GetNextLine()
1995 )
1996 {
1997 for(wxLOiterator i = line->GetFirstObject();
1998 i != NULLIT;
1999 i++)
2000 rc |= Insert(*i);
2001 LineBreak();
2002 }
2003 return rc;
2004 }
2005
2006 bool
2007 wxLayoutList::LineBreak(void)
2008 {
2009 wxASSERT(m_CursorLine);
2010
2011 AddCursorPosToUpdateRect();
2012
2013 wxPoint position(m_CursorLine->GetPosition());
2014
2015 CoordType
2016 width = m_CursorLine->GetWidth(),
2017 height = m_CursorLine->GetHeight();
2018
2019 m_CursorLine = m_CursorLine->Break(m_CursorPos.x, this);
2020 if(m_CursorLine->GetPreviousLine() == NULL)
2021 m_FirstLine = m_CursorLine;
2022 m_CursorPos.y++;
2023 m_CursorPos.x = 0;
2024
2025 // The following code will produce a height which is guaranteed to
2026 // be too high: old lineheight + the height of both new lines.
2027 // We can probably drop the old line height and start with height =
2028 // 0. FIXME
2029 wxLayoutLine *prev = m_CursorLine->GetPreviousLine();
2030 if(prev)
2031 height += prev->GetHeight();
2032 height += m_CursorLine->GetHeight();
2033
2034 m_movedCursor = true;
2035
2036 SetUpdateRect(position);
2037 SetUpdateRect(position.x + width + MSW_CORRECTION,
2038 position.y + height + MSW_CORRECTION);
2039
2040 return true;
2041 }
2042
2043 bool
2044 wxLayoutList::WrapLine(CoordType column)
2045 {
2046 if(m_CursorPos.x <= column || column < 1)
2047 return false; // do nothing yet
2048 else
2049 {
2050 CoordType xpos = m_CursorLine->GetWrapPosition(column);
2051 if(xpos == -1)
2052 return false; // cannot break line
2053 //else:
2054 CoordType newpos = m_CursorPos.x - xpos - 1;
2055 m_CursorPos.x = xpos;
2056
2057 AddCursorPosToUpdateRect();
2058
2059 LineBreak();
2060 Delete(1); // delete the space
2061 m_CursorPos.x = newpos;
2062
2063 m_CursorLine->MarkDirty();
2064
2065 m_movedCursor = true;
2066
2067 return true;
2068 }
2069 }
2070
2071 bool
2072 wxLayoutList::Delete(CoordType npos)
2073 {
2074 wxCHECK_MSG(m_CursorLine, false, "can't delete in non existing line");
2075
2076 if ( npos == 0 )
2077 return true;
2078
2079 AddCursorPosToUpdateRect();
2080
2081 // were other lines appended to this one (this is important to know because
2082 // this means that our width _increased_ as the result of deletion)
2083 bool wasMerged = false;
2084
2085 // the size of the region to update
2086 CoordType totalHeight = m_CursorLine->GetHeight(),
2087 totalWidth = m_CursorLine->GetWidth();
2088
2089 CoordType left;
2090 do
2091 {
2092 left = m_CursorLine->Delete(m_CursorPos.x, npos);
2093
2094 if( left > 0 )
2095 {
2096 // More to delete, continue on next line.
2097
2098 // First, check if line is empty:
2099 if(m_CursorLine->GetLength() == 0)
2100 {
2101 // in this case, updating could probably be optimised
2102 #ifdef WXLO_DEBUG
2103 wxASSERT(DeleteLines(1) == 0);
2104 #else
2105 DeleteLines(1);
2106 #endif
2107
2108 left--;
2109 }
2110 else
2111 {
2112 // Need to join next line
2113 if(! m_CursorLine->GetNextLine())
2114 break; // cannot
2115 else
2116 {
2117 wasMerged = true;
2118 wxLayoutLine *next = m_CursorLine->GetNextLine();
2119 if ( next )
2120 {
2121 totalHeight += next->GetHeight();
2122 totalWidth += next->GetWidth();
2123
2124 m_CursorLine->MergeNextLine(this);
2125 left--;
2126 }
2127 else
2128 {
2129 wxFAIL_MSG("can't delete all this");
2130
2131 return false;
2132 }
2133 }
2134 }
2135 }
2136 }
2137 while ( left> 0 );
2138
2139 // we need to update the whole tail of the line and the lines which
2140 // disappeared
2141 if ( wasMerged )
2142 {
2143 wxPoint position(m_CursorLine->GetPosition());
2144 SetUpdateRect(position);
2145 SetUpdateRect(position.x + totalWidth + MSW_CORRECTION,
2146 position.y + totalHeight + MSW_CORRECTION);
2147 }
2148
2149 return left == 0;
2150 }
2151
2152 int
2153 wxLayoutList::DeleteLines(int n)
2154 {
2155 wxASSERT(m_CursorLine);
2156 wxLayoutLine *line;
2157
2158 AddCursorPosToUpdateRect();
2159
2160 while(n > 0)
2161 {
2162 if(!m_CursorLine->GetNextLine())
2163 { // we cannot delete this line, but we can clear it
2164 MoveCursorToBeginOfLine();
2165 DeleteToEndOfLine();
2166 if(m_AutoFormat)
2167 m_CursorLine->MarkDirty();
2168 return n-1;
2169 }
2170 //else:
2171 line = m_CursorLine;
2172 m_CursorLine = m_CursorLine->DeleteLine(true, this);
2173 n--;
2174 if(line == m_FirstLine) m_FirstLine = m_CursorLine;
2175 wxASSERT(m_FirstLine);
2176 wxASSERT(m_CursorLine);
2177 }
2178 if(m_AutoFormat)
2179 m_CursorLine->MarkDirty();
2180 return n;
2181 }
2182
2183 void
2184 wxLayoutList::Recalculate(wxDC &dc, CoordType bottom)
2185 {
2186 if(! m_AutoFormat)
2187 return;
2188 wxLayoutLine *line = m_FirstLine;
2189
2190 // first, make sure everything is calculated - this might not be
2191 // needed, optimise it later
2192 ApplyStyle(m_DefaultStyleInfo, dc);
2193 while(line)
2194 {
2195 line->RecalculatePosition(this); // so we don't need to do it all the time
2196 // little condition to speed up redrawing:
2197 if(bottom != -1 && line->GetPosition().y > bottom) break;
2198 line = line->GetNextLine();
2199 }
2200 }
2201
2202 wxPoint
2203 wxLayoutList::GetCursorScreenPos(void) const
2204 {
2205 return m_CursorScreenPos;
2206 }
2207
2208 /*
2209 Is called before each Draw(). Now, it will re-layout all lines which
2210 have changed.
2211 */
2212 void
2213 wxLayoutList::Layout(wxDC &dc, CoordType bottom, bool forceAll,
2214 wxPoint *cpos, wxPoint *csize)
2215 {
2216 // first, make sure everything is calculated - this might not be
2217 // needed, optimise it later
2218 ApplyStyle(m_DefaultStyleInfo, dc);
2219
2220
2221 if(m_ReLayoutAll)
2222 {
2223 forceAll = TRUE;
2224 bottom = -1;
2225 }
2226 ForceTotalLayout(FALSE);
2227
2228
2229 // If one line was dirty, we need to re-calculate all
2230 // following lines, too.
2231 bool wasDirty = forceAll;
2232 wxLayoutLine *line = m_FirstLine;
2233 while(line)
2234 {
2235 if(! wasDirty)
2236 ApplyStyle(line->GetStyleInfo(), dc);
2237 if(
2238 // if any previous line was dirty, we need to layout all
2239 // following lines:
2240 wasDirty
2241 // layout dirty lines:
2242 || line->IsDirty()
2243 // always layout the cursor line toupdate the cursor
2244 // position and size:
2245 || line == m_CursorLine
2246 // or if it's the line we are asked to look for:
2247 || (cpos && line->GetLineNumber() == cpos->y)
2248 )
2249 {
2250 if(line->IsDirty())
2251 wasDirty = true;
2252
2253 // The following Layout() calls will update our
2254 // m_CurrentStyleInfo if needed.
2255 if(line == m_CursorLine)
2256 {
2257 line->Layout(dc, this,
2258 (wxPoint *)&m_CursorScreenPos,
2259 (wxPoint *)&m_CursorSize,
2260 &m_CursorStyleInfo,
2261 m_CursorPos.x);
2262 // we cannot layout the line twice, so copy the coords:
2263 if(cpos && line ->GetLineNumber() == cpos->y)
2264 {
2265 *cpos = m_CursorScreenPos;
2266 if ( csize )
2267 *csize = m_CursorSize;
2268 }
2269 }
2270 else
2271 if(cpos && line->GetLineNumber() == cpos->y)
2272 line->Layout(dc, this,
2273 cpos,
2274 csize, NULL, cpos->x);
2275 else
2276 line->Layout(dc, this);
2277 // little condition to speed up redrawing:
2278 if(bottom != -1 && line->GetPosition().y > bottom)
2279 break;
2280 }
2281 line = line->GetNextLine();
2282 }
2283
2284 #ifndef WXLAYOUT_USE_CARET
2285 // can only be 0 if we are on the first line and have no next line
2286 wxASSERT(m_CursorSize.x != 0 || (m_CursorLine &&
2287 m_CursorLine->GetNextLine() == NULL &&
2288 m_CursorLine == m_FirstLine));
2289 #endif // WXLAYOUT_USE_CARET
2290 AddCursorPosToUpdateRect();
2291 }
2292
2293 wxPoint
2294 wxLayoutList::GetScreenPos(wxDC &dc, const wxPoint &cpos, wxPoint *csize)
2295 {
2296 wxPoint pos = cpos;
2297 Layout(dc, -1, false, &pos, csize);
2298 return pos;
2299 }
2300
2301 void
2302 wxLayoutList::Draw(wxDC &dc,
2303 wxPoint const &offset,
2304 CoordType top,
2305 CoordType bottom,
2306 bool clipStrictly)
2307 {
2308 wxLayoutLine *line = m_FirstLine;
2309
2310 if ( m_Selection.m_discarded )
2311 {
2312 // calculate them if we don't have them already
2313 if ( !m_Selection.HasValidScreenCoords() )
2314 {
2315 m_Selection.m_ScreenA = GetScreenPos(dc, m_Selection.m_CursorA);
2316 m_Selection.m_ScreenB = GetScreenPos(dc, m_Selection.m_CursorB);
2317 }
2318
2319 // invalidate the area which was previousle selected - and which is not
2320 // selected any more
2321 SetUpdateRect(m_Selection.m_ScreenA);
2322 SetUpdateRect(m_Selection.m_ScreenB);
2323
2324 m_Selection.m_discarded = false;
2325 }
2326
2327 /* This call to Layout() will re-calculate and update all lines
2328 marked as dirty.
2329 */
2330 Layout(dc, bottom);
2331
2332 ApplyStyle(m_DefaultStyleInfo, dc);
2333 wxBrush brush(m_CurrentStyleInfo.m_bg, wxSOLID);
2334 dc.SetBrush(brush);
2335 dc.SetBackgroundMode(wxTRANSPARENT);
2336
2337 while(line)
2338 {
2339 // only draw if between top and bottom:
2340 if((top == -1 ||
2341 line->GetPosition().y + line->GetHeight() > top))
2342 {
2343 ApplyStyle(line->GetStyleInfo(), dc);
2344 // little condition to speed up redrawing:
2345 if( bottom != -1
2346 && line->GetPosition().y
2347 +(clipStrictly ? line->GetHeight() : 0) >= bottom)
2348 break;
2349 line->Draw(dc, this, offset);
2350 }
2351 line = line->GetNextLine();
2352 }
2353 InvalidateUpdateRect();
2354
2355 #ifdef DEBUG
2356 if ( m_Selection.m_valid )
2357 {
2358 WXLO_DEBUG(("Selection is %s : %ld,%ld/%ld,%ld",
2359 m_Selection.m_valid ? "valid" : "invalid",
2360 m_Selection.m_CursorA.x, m_Selection.m_CursorA.y,
2361 m_Selection.m_CursorB.x, m_Selection.m_CursorB.y));
2362 }
2363 #endif
2364 }
2365
2366 wxLayoutObject *
2367 wxLayoutList::FindObjectScreen(wxDC &dc, wxPoint const pos,
2368 wxPoint *cursorPos,
2369 bool *found)
2370 {
2371 // First, find the right line:
2372 wxLayoutLine
2373 *line = m_FirstLine,
2374 *lastline = m_FirstLine;
2375 wxPoint p;
2376
2377 ApplyStyle(m_DefaultStyleInfo, dc);
2378 while(line)
2379 {
2380 p = line->GetPosition();
2381 if(p.y <= pos.y && p.y+line->GetHeight() >= pos.y)
2382 break;
2383 lastline = line;
2384 line = line->GetNextLine();
2385 }
2386
2387 bool didFind = line != NULL;
2388
2389 if ( !line )
2390 {
2391 // use the last line:
2392 line = lastline;
2393 }
2394
2395 if ( cursorPos )
2396 cursorPos->y = line->GetLineNumber();
2397
2398 bool foundinline = true;
2399 long cx = 0;
2400
2401 // Now, find the object in the line:
2402 wxLOiterator i;
2403
2404 if (cursorPos)
2405 {
2406 i = line->FindObjectScreen(dc, this,
2407 pos.x,
2408 &cx,
2409 &foundinline);
2410 cursorPos->x = cx;
2411 }
2412 else
2413 i = line->FindObjectScreen(dc, this,
2414 pos.x,
2415 NULL,
2416 &foundinline);
2417 if ( found )
2418 *found = didFind && foundinline;
2419
2420 return (i == NULLIT) ? NULL : *i;
2421
2422 }
2423
2424 wxPoint
2425 wxLayoutList::GetSize(void) const
2426 {
2427 wxLayoutLine
2428 *line = m_FirstLine,
2429 *last = line;
2430 if(! line)
2431 return wxPoint(0,0);
2432
2433 wxPoint maxPoint(0,0);
2434
2435 // find last line:
2436 while(line)
2437 {
2438 if(line->GetWidth() > maxPoint.x)
2439 maxPoint.x = line->GetWidth();
2440 last = line;
2441 line = line->GetNextLine();
2442 }
2443
2444 maxPoint.y = last->GetPosition().y + last->GetHeight();
2445
2446 // if the line was just added, its height would be 0 and we can't call
2447 // Layout() from here because we don't have a dc and we might be not drawing
2448 // at all, besides... So take the cursor height by default (taking 0 is bad
2449 // because then the scrollbars won't be resized and the new line won't be
2450 // shown at all)
2451 if ( last->IsDirty() )
2452 {
2453 if ( last->GetHeight() == 0 )
2454 maxPoint.y += m_CursorSize.y;
2455 if ( last->GetWidth() == 0 && maxPoint.x < m_CursorSize.x )
2456 maxPoint.x = m_CursorSize.x;
2457 }
2458
2459 return maxPoint;
2460 }
2461
2462
2463 void
2464 wxLayoutList::DrawCursor(wxDC &dc, bool active, wxPoint const &translate)
2465 {
2466 if ( m_movedCursor )
2467 m_movedCursor = false;
2468
2469 wxPoint coords(m_CursorScreenPos);
2470 coords += translate;
2471
2472 #ifdef WXLAYOUT_DEBUG
2473 WXLO_DEBUG(("Drawing cursor (%ld,%ld) at %ld,%ld, size %ld,%ld, line: %ld, len %ld",
2474 (long)m_CursorPos.x, (long)m_CursorPos.y,
2475 (long)coords.x, (long)coords.y,
2476 (long)m_CursorSize.x, (long)m_CursorSize.y,
2477 (long)m_CursorLine->GetLineNumber(),
2478 (long)m_CursorLine->GetLength()));
2479
2480 wxLogStatus("Cursor is at (%d, %d)", m_CursorPos.x, m_CursorPos.y);
2481 #endif
2482
2483 #ifdef WXLAYOUT_USE_CARET
2484 m_caret->Move(coords);
2485 #else // !WXLAYOUT_USE_CARET
2486
2487 wxASSERT(m_CursorSize.x >= WXLO_MINIMUM_CURSOR_WIDTH);
2488 dc.SetBrush(*wxWHITE_BRUSH);
2489 //FIXME: wxGTK XOR is borken at the moment!!!dc.SetLogicalFunction(wxXOR);
2490 dc.SetPen(wxPen(*wxBLACK,1,wxSOLID));
2491 if(active)
2492 {
2493 dc.SetLogicalFunction(wxXOR);
2494 dc.DrawRectangle(coords.x, coords.y,
2495 m_CursorSize.x, m_CursorSize.y);
2496 SetUpdateRect(coords.x, coords.y);
2497 SetUpdateRect(coords.x+m_CursorSize.x, coords.y+m_CursorSize.y);
2498 }
2499 else
2500 {
2501 dc.SetLogicalFunction(wxCOPY);
2502 dc.DrawLine(coords.x, coords.y+m_CursorSize.y-1,
2503 coords.x, coords.y);
2504 SetUpdateRect(coords.x, coords.y+m_CursorSize.y-1);
2505 SetUpdateRect(coords.x, coords.y);
2506 }
2507 dc.SetLogicalFunction(wxCOPY);
2508 //dc.SetBrush(wxNullBrush);
2509 #endif // WXLAYOUT_USE_CARET/!WXLAYOUT_USE_CARET
2510 }
2511
2512 void
2513 wxLayoutList::SetUpdateRect(CoordType x, CoordType y)
2514 {
2515 if(m_UpdateRectValid)
2516 GrowRect(m_UpdateRect, x, y);
2517 else
2518 {
2519 m_UpdateRect.x = x;
2520 m_UpdateRect.y = y;
2521 m_UpdateRect.width = 4; // large enough to avoid surprises from
2522 m_UpdateRect.height = 4;// wxGTK :-)
2523 m_UpdateRectValid = true;
2524 }
2525 }
2526
2527 void
2528 wxLayoutList::StartSelection(const wxPoint& cposOrig, const wxPoint& spos)
2529 {
2530 wxPoint cpos(cposOrig);
2531 if ( cpos.x == -1 )
2532 cpos = m_CursorPos;
2533 WXLO_DEBUG(("Starting selection at %ld/%ld", cpos.x, cpos.y));
2534 m_Selection.m_CursorA = cpos;
2535 m_Selection.m_CursorB = cpos;
2536 m_Selection.m_ScreenA = spos;
2537 m_Selection.m_ScreenB = spos;
2538 m_Selection.m_selecting = true;
2539 m_Selection.m_valid = false;
2540 }
2541
2542 void
2543 wxLayoutList::ContinueSelection(const wxPoint& cposOrig, const wxPoint& spos)
2544 {
2545 wxPoint cpos(cposOrig);
2546 if(cpos.x == -1)
2547 cpos = m_CursorPos;
2548
2549 wxASSERT(m_Selection.m_selecting == true);
2550 wxASSERT(m_Selection.m_valid == false);
2551 WXLO_DEBUG(("Continuing selection at %ld/%ld", cpos.x, cpos.y));
2552
2553 m_Selection.m_ScreenB = spos;
2554 m_Selection.m_CursorB = cpos;
2555 }
2556
2557 void
2558 wxLayoutList::EndSelection(const wxPoint& cposOrig, const wxPoint& spos)
2559 {
2560 wxPoint cpos(cposOrig);
2561 if(cpos.x == -1) cpos = m_CursorPos;
2562 ContinueSelection(cpos, spos);
2563 WXLO_DEBUG(("Ending selection at %ld/%ld", cpos.x, cpos.y));
2564 // we always want m_CursorA <= m_CursorB!
2565 if( m_Selection.m_CursorA > m_Selection.m_CursorB )
2566 {
2567 // exchange the start/end points
2568 wxPoint help = m_Selection.m_CursorB;
2569 m_Selection.m_CursorB = m_Selection.m_CursorA;
2570 m_Selection.m_CursorA = help;
2571
2572 help = m_Selection.m_ScreenB;
2573 m_Selection.m_ScreenB = m_Selection.m_ScreenA;
2574 m_Selection.m_ScreenA = help;
2575 }
2576 m_Selection.m_selecting = false;
2577 m_Selection.m_valid = true;
2578 /// In case we just clicked somewhere, the selection will have zero
2579 /// size, so we discard it immediately.
2580 if(m_Selection.m_CursorA == m_Selection.m_CursorB)
2581 DiscardSelection();
2582 }
2583
2584 void
2585 wxLayoutList::DiscardSelection()
2586 {
2587 if ( !HasSelection() )
2588 return;
2589
2590 m_Selection.m_valid =
2591 m_Selection.m_selecting = false;
2592 m_Selection.m_discarded = true;
2593 }
2594
2595 bool
2596 wxLayoutList::IsSelecting(void) const
2597 {
2598 return m_Selection.m_selecting;
2599 }
2600
2601 bool
2602 wxLayoutList::IsSelected(const wxPoint &cursor) const
2603 {
2604 if ( !HasSelection() )
2605 return false;
2606
2607 return (
2608 (m_Selection.m_CursorA <= cursor
2609 && cursor <= m_Selection.m_CursorB)
2610 || (m_Selection.m_CursorB <= cursor
2611 && cursor <= m_Selection.m_CursorA)
2612 );
2613 }
2614
2615
2616 /** Tests whether this layout line is selected and needs
2617 highlighting.
2618 @param line to test for
2619 @return 0 = not selected, 1 = fully selected, -1 = partially
2620 selected
2621 */
2622 int
2623 wxLayoutList::IsSelected(const wxLayoutLine *line, CoordType *from,
2624 CoordType *to)
2625 {
2626 wxASSERT(line); wxASSERT(to); wxASSERT(from);
2627
2628 if(! m_Selection.m_valid && ! m_Selection.m_selecting)
2629 return 0;
2630
2631 CoordType y = line->GetLineNumber();
2632 if(
2633 (m_Selection.m_CursorA.y < y && m_Selection.m_CursorB.y > y)
2634 || (m_Selection.m_CursorB.y < y && m_Selection.m_CursorA.y > y)
2635 )
2636 return 1;
2637 else if(m_Selection.m_CursorA.y == y)
2638 {
2639 *from = m_Selection.m_CursorA.x;
2640 if(m_Selection.m_CursorB.y == y)
2641 *to = m_Selection.m_CursorB.x;
2642 else
2643 {
2644 if(m_Selection.m_CursorB > m_Selection.m_CursorA)
2645 *to = line->GetLength();
2646 else
2647 *to = 0;
2648 }
2649 if(*to < *from)
2650 {
2651 CoordType help = *to;
2652 *to = *from;
2653 *from = help;
2654 }
2655 return -1;
2656 }
2657 else if(m_Selection.m_CursorB.y == y)
2658 {
2659 *to = m_Selection.m_CursorB.x;
2660 if(m_Selection.m_CursorA.y == y)
2661 *from = m_Selection.m_CursorA.x;
2662 else
2663 {
2664 if(m_Selection.m_CursorB > m_Selection.m_CursorA)
2665 *from = 0;
2666 else
2667 *from = line->GetLength();
2668 }
2669 if(*to < *from)
2670 {
2671 CoordType help = *to;
2672 *to = *from;
2673 *from = help;
2674 }
2675 return -1;
2676 }
2677 else
2678 return 0;
2679 }
2680
2681 void
2682 wxLayoutList::DeleteSelection(void)
2683 {
2684 if(! m_Selection.m_valid)
2685 return;
2686
2687 m_Selection.m_valid = false;
2688
2689 // Only delete part of the current line?
2690 if(m_Selection.m_CursorA.y == m_Selection.m_CursorB.y)
2691 {
2692 MoveCursorTo(m_Selection.m_CursorA);
2693 Delete(m_Selection.m_CursorB.x - m_Selection.m_CursorA.x);
2694 return;
2695 }
2696
2697 // We now know that the two lines are different:
2698
2699 wxLayoutLine
2700 * firstLine = GetLine(m_Selection.m_CursorA.y),
2701 * lastLine = GetLine(m_Selection.m_CursorB.y);
2702 // be a bit paranoid:
2703 if(! firstLine || ! lastLine)
2704 return;
2705
2706 // First, delete what's left of this line:
2707 MoveCursorTo(m_Selection.m_CursorA);
2708 DeleteToEndOfLine();
2709
2710 wxLayoutLine *prevLine = firstLine->GetPreviousLine(),
2711 *nextLine = firstLine->GetNextLine();
2712 while(nextLine && nextLine != lastLine)
2713 nextLine = nextLine->DeleteLine(false, this);
2714
2715 // Now nextLine = lastLine;
2716 Delete(1); // This joins firstLine and nextLine
2717 Delete(m_Selection.m_CursorB.x); // This deletes the first x positions
2718
2719 // Recalculate the line positions and numbers but notice that firstLine
2720 // might not exist any more - it could be deleted by Delete(1) above
2721 wxLayoutLine *firstLine2 = prevLine ? prevLine->GetNextLine() : m_FirstLine;
2722 firstLine2->MarkDirty();
2723 }
2724
2725 /// Starts highlighting the selection
2726 void
2727 wxLayoutList::StartHighlighting(wxDC &dc)
2728 {
2729 #if SHOW_SELECTIONS
2730 dc.SetTextForeground(m_CurrentStyleInfo.m_bg);
2731 dc.SetTextBackground(m_CurrentStyleInfo.m_fg);
2732 dc.SetBackgroundMode(wxSOLID);
2733 #endif
2734 }
2735
2736 /// Ends highlighting the selection
2737 void
2738 wxLayoutList::EndHighlighting(wxDC &dc)
2739 {
2740 #if SHOW_SELECTIONS
2741 dc.SetTextForeground(m_CurrentStyleInfo.m_fg);
2742 dc.SetTextBackground(m_CurrentStyleInfo.m_bg);
2743 dc.SetBackgroundMode(wxTRANSPARENT);
2744 #endif
2745 }
2746
2747
2748 wxLayoutLine *
2749 wxLayoutList::GetLine(CoordType index) const
2750 {
2751 wxASSERT_MSG( (0 <= index) && (index < (CoordType)m_numLines),
2752 "invalid index" );
2753
2754 wxLayoutLine *line;
2755 CoordType n = index;
2756 #ifdef DEBUG
2757 CoordType lineNo = 0;
2758 #endif
2759
2760 for ( line = m_FirstLine; line && n-- > 0; line =
2761 line->GetNextLine() )
2762 {
2763 #ifdef DEBUG
2764 wxASSERT(line->GetLineNumber() == lineNo );
2765 lineNo++;
2766 #endif
2767 }
2768
2769 if ( line )
2770 {
2771 // should be the right one
2772 wxASSERT( line->GetLineNumber() == index );
2773 }
2774
2775 return line;
2776 }
2777
2778
2779 wxLayoutList *
2780 wxLayoutList::Copy(const wxPoint &from,
2781 const wxPoint &to)
2782 {
2783 wxLayoutLine
2784 * firstLine = NULL,
2785 * lastLine = NULL;
2786
2787 for(firstLine = m_FirstLine;
2788 firstLine && firstLine->GetLineNumber() < from.y;
2789 firstLine=firstLine->GetNextLine())
2790 ;
2791 if(!firstLine || firstLine->GetLineNumber() != from.y)
2792 return NULL;
2793
2794 for(lastLine = m_FirstLine;
2795 lastLine && lastLine->GetLineNumber() < to.y;
2796 lastLine=lastLine->GetNextLine())
2797 ;
2798 if(!lastLine || lastLine->GetLineNumber() != to.y)
2799 return NULL;
2800
2801 if(to <= from)
2802 {
2803 wxLayoutLine *tmp = firstLine;
2804 firstLine = lastLine;
2805 lastLine = tmp;
2806 }
2807
2808 wxLayoutList *llist = new wxLayoutList();
2809
2810 if(firstLine == lastLine)
2811 {
2812 firstLine->Copy(llist, from.x, to.x);
2813 }
2814 else
2815 {
2816 // Extract objects from first line
2817 firstLine->Copy(llist, from.x);
2818 llist->LineBreak();
2819 // Extract all lines between
2820 for(wxLayoutLine *line = firstLine->GetNextLine();
2821 line != lastLine;
2822 line = line->GetNextLine())
2823 {
2824 line->Copy(llist);
2825 llist->LineBreak();
2826 }
2827 // Extract objects from last line
2828 lastLine->Copy(llist, 0, to.x);
2829 }
2830 return llist;
2831 }
2832
2833 wxLayoutList *
2834 wxLayoutList::GetSelection(wxLayoutDataObject *wxlo, bool invalidate)
2835 {
2836 if(! m_Selection.m_valid)
2837 {
2838 if(m_Selection.m_selecting)
2839 EndSelection();
2840 else
2841 return NULL;
2842 }
2843
2844 if(invalidate) m_Selection.m_valid = false;
2845
2846 wxLayoutList *llist = Copy( m_Selection.m_CursorA,
2847 m_Selection.m_CursorB );
2848
2849 if(llist && wxlo) // export as data object, too
2850 {
2851 wxString string;
2852
2853 wxLayoutExportObject *exp;
2854 wxLayoutExportStatus status(llist);
2855 while((exp = wxLayoutExport( &status, WXLO_EXPORT_AS_OBJECTS)) != NULL)
2856 {
2857 if(exp->type == WXLO_EXPORT_EMPTYLINE)
2858 ; //FIXME missing support for linebreaks in string format
2859 else
2860 exp->content.object->Write(string);
2861 delete exp;
2862 }
2863
2864 wxlo->SetLayoutData(string);
2865 }
2866 return llist;
2867 }
2868
2869
2870
2871 #define COPY_SI(what) if(si.what != -1) { m_CurrentStyleInfo.what = si.what; fontChanged = TRUE; }
2872
2873 void
2874 wxLayoutList::ApplyStyle(wxLayoutStyleInfo const &si, wxDC &dc)
2875 {
2876 bool fontChanged = FALSE;
2877 COPY_SI(family);
2878 COPY_SI(size);
2879 COPY_SI(style);
2880 COPY_SI(weight);
2881 COPY_SI(underline);
2882 if(fontChanged)
2883 dc.SetFont( m_FontCache.GetFont(m_CurrentStyleInfo) );
2884
2885 if(si.m_fg_valid)
2886 {
2887 m_CurrentStyleInfo.m_fg = si.m_fg;
2888 dc.SetTextForeground(m_CurrentStyleInfo.m_fg);
2889 }
2890 if(si.m_bg_valid)
2891 {
2892 m_CurrentStyleInfo.m_bg = si.m_bg;
2893 dc.SetTextBackground(m_CurrentStyleInfo.m_bg);
2894 }
2895 }
2896
2897
2898 #ifdef WXLAYOUT_DEBUG
2899
2900 void
2901 wxLayoutList::Debug(void)
2902 {
2903 WXLO_DEBUG(("Cursor is in line %d, screen pos = (%d, %d)",
2904 m_CursorLine->GetLineNumber(),
2905 m_CursorScreenPos.x, m_CursorScreenPos.y));
2906
2907 wxLayoutLine *line;
2908 for(line = m_FirstLine; line; line = line->GetNextLine())
2909 {
2910 line->Debug();
2911 }
2912 }
2913
2914 #endif
2915
2916
2917 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
2918
2919 wxLayoutPrintout
2920
2921 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2922
2923 wxLayoutPrintout::wxLayoutPrintout(wxLayoutList *llist,
2924 wxString const & title)
2925 :wxPrintout(title)
2926 {
2927 m_llist = llist;
2928 m_title = title;
2929 // remove any highlighting which could interfere with printing:
2930 m_llist->StartSelection();
2931 m_llist->EndSelection();
2932 // force a full layout of the list:
2933 m_llist->ForceTotalLayout();
2934 // layout is called in ScaleDC() when we have a DC
2935 }
2936
2937 wxLayoutPrintout::~wxLayoutPrintout()
2938 {
2939 }
2940
2941 float
2942 wxLayoutPrintout::ScaleDC(wxDC *dc)
2943 {
2944 // The following bit is taken from the printing sample, let's see
2945 // whether it works for us.
2946
2947 /* You might use THIS code to set the printer DC to ROUGHLY reflect
2948 * the screen text size. This page also draws lines of actual length 5cm
2949 * on the page.
2950 */
2951 // Get the logical pixels per inch of screen and printer
2952 int ppiScreenX, ppiScreenY;
2953 GetPPIScreen(&ppiScreenX, &ppiScreenY);
2954 int ppiPrinterX, ppiPrinterY;
2955 GetPPIPrinter(&ppiPrinterX, &ppiPrinterY);
2956
2957 if(ppiScreenX == 0) // not yet set, need to guess
2958 {
2959 ppiScreenX = 100;
2960 ppiScreenY = 100;
2961 }
2962 if(ppiPrinterX == 0) // not yet set, need to guess
2963 {
2964 ppiPrinterX = 72;
2965 ppiPrinterY = 72;
2966 }
2967
2968 // This scales the DC so that the printout roughly represents the
2969 // the screen scaling. The text point size _should_ be the right size
2970 // but in fact is too small for some reason. This is a detail that will
2971 // need to be addressed at some point but can be fudged for the
2972 // moment.
2973 float scale = (float)((float)ppiPrinterX/(float)ppiScreenX);
2974
2975 // Now we have to check in case our real page size is reduced
2976 // (e.g. because we're drawing to a print preview memory DC)
2977 int pageWidth, pageHeight;
2978 int w, h;
2979 dc->GetSize(&w, &h);
2980 GetPageSizePixels(&pageWidth, &pageHeight);
2981 if(pageWidth != 0) // doesn't work always
2982 {
2983 // If printer pageWidth == current DC width, then this doesn't
2984 // change. But w might be the preview bitmap width, so scale down.
2985 scale = scale * (float)(w/(float)pageWidth);
2986 }
2987 dc->SetUserScale(scale, scale);
2988 return scale;
2989 }
2990
2991 bool wxLayoutPrintout::OnPrintPage(int page)
2992 {
2993 wxDC *dc = GetDC();
2994
2995 ScaleDC(dc);
2996
2997 if (dc)
2998 {
2999 int top, bottom;
3000 top = (page - 1)*m_PrintoutHeight;
3001 bottom = top + m_PrintoutHeight;
3002
3003 WXLO_DEBUG(("OnPrintPage(%d) printing from %d to %d", page, top,
3004 bottom));
3005 // SetDeviceOrigin() doesn't work here, so we need to manually
3006 // translate all coordinates.
3007 wxPoint translate(m_Offset.x,m_Offset.y-top);
3008 m_llist->Draw(*dc, translate, top, bottom, TRUE /* clip strictly
3009 */);
3010 return true;
3011 }
3012 else
3013 return false;
3014 }
3015
3016 void wxLayoutPrintout::GetPageInfo(int *minPage, int *maxPage, int *selPageFrom, int *selPageTo)
3017 {
3018 /* We allocate a temporary wxDC for printing, so that we can
3019 determine the correct paper size and scaling. We don't actually
3020 print anything on it. */
3021 #ifdef __WXMSW__
3022 wxPrinterDC *psdc = new wxPrinterDC("","",WXLLIST_TEMPFILE,false);
3023 #else
3024 wxPostScriptDC *psdc = new wxPostScriptDC(WXLLIST_TEMPFILE,false);
3025 #endif
3026
3027 psdc->StartDoc(m_title);
3028 // before we draw anything, me must make sure the list is properly
3029 // laid out
3030 m_llist->Layout(*psdc);
3031
3032 float scale = ScaleDC(psdc);
3033
3034 psdc->GetSize(&m_PageWidth, &m_PageHeight);
3035
3036 // This sets a left/top origin of 15% and 5%:
3037 m_Offset = wxPoint((15*m_PageWidth)/100, (5*m_PageHeight)/100);
3038
3039 // This is the length of the printable area.
3040 m_PrintoutHeight = m_PageHeight - 2*m_Offset.y;
3041 m_PrintoutHeight = (int)( m_PrintoutHeight / scale); // we want to use the real paper height
3042
3043 m_NumOfPages = 1 +
3044 (int)( m_llist->GetSize().y / (float)(m_PrintoutHeight));
3045
3046 *minPage = 1;
3047 *maxPage = m_NumOfPages;
3048
3049 *selPageFrom = 1;
3050 *selPageTo = m_NumOfPages;
3051 psdc->EndDoc();
3052 delete psdc;
3053 wxRemoveFile(WXLLIST_TEMPFILE);
3054 }
3055
3056 bool wxLayoutPrintout::HasPage(int pageNum)
3057 {
3058 return pageNum <= m_NumOfPages;
3059 }
3060
3061 /*
3062 Stupid wxWindows doesn't draw proper ellipses, so we comment this
3063 out. It's a waste of paper anyway.
3064 */
3065 #if 0
3066 void
3067 wxLayoutPrintout::DrawHeader(wxDC &dc,
3068 wxPoint topleft, wxPoint bottomright,
3069 int pageno)
3070 {
3071 // make backups of all essential parameters
3072 const wxBrush& brush = dc.GetBrush();
3073 const wxPen& pen = dc.GetPen();
3074 const wxFont& font = dc.GetFont();
3075
3076 dc.SetBrush(*wxWHITE_BRUSH);
3077 dc.SetPen(wxPen(*wxBLACK,0,wxSOLID));
3078 dc.DrawRoundedRectangle(topleft.x,
3079 topleft.y,bottomright.x-topleft.x,
3080 bottomright.y-topleft.y);
3081 dc.SetBrush(*wxBLACK_BRUSH);
3082 wxFont myfont = wxFont((WXLO_DEFAULTFONTSIZE*12)/10,
3083 wxSWISS,wxNORMAL,wxBOLD,false,"Helvetica");
3084 dc.SetFont(myfont);
3085
3086 wxString page;
3087 page = "9999/9999 "; // many pages...
3088 long w,h;
3089 dc.GetTextExtent(page,&w,&h);
3090 page.Printf("%d/%d", pageno, (int) m_NumOfPages);
3091 dc.DrawText(page,bottomright.x-w,topleft.y+h/2);
3092 dc.GetTextExtent("XXXX", &w,&h);
3093 dc.DrawText(m_title, topleft.x+w,topleft.y+h/2);
3094
3095 // restore settings
3096 dc.SetPen(pen);
3097 dc.SetBrush(brush);
3098 dc.SetFont(font);
3099 }
3100 #endif
3101
3102
3103 wxFont &
3104 wxFontCache::GetFont(int family, int size, int style, int weight,
3105 bool underline)
3106 {
3107 for(wxFCEList::iterator i = m_FontList.begin();
3108 i != m_FontList.end(); i++)
3109 if( (**i).Matches(family, size, style, weight, underline) )
3110 return (**i).GetFont();
3111 // not found:
3112 wxFontCacheEntry *fce = new wxFontCacheEntry(family, size, style,
3113 weight, underline);
3114 m_FontList.push_back(fce);
3115 return fce->GetFont();
3116 }
3117
wxWidgets (Impactor)