projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
more asserts
[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->y < 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 if(m_CursorPos.x > 0)
2023 m_CursorPos.y++;
2024 m_CursorPos.x = 0;
2025
2026 // The following code will produce a height which is guaranteed to
2027 // be too high: old lineheight + the height of both new lines.
2028 // We can probably drop the old line height and start with height =
2029 // 0. FIXME
2030 wxLayoutLine *prev = m_CursorLine->GetPreviousLine();
2031 if(prev)
2032 height += prev->GetHeight();
2033 height += m_CursorLine->GetHeight();
2034
2035 m_movedCursor = true;
2036
2037 SetUpdateRect(position);
2038 SetUpdateRect(position.x + width + MSW_CORRECTION,
2039 position.y + height + MSW_CORRECTION);
2040
2041 return true;
2042 }
2043
2044 bool
2045 wxLayoutList::WrapLine(CoordType column)
2046 {
2047 if(m_CursorPos.x <= column || column < 1)
2048 return false; // do nothing yet
2049 else
2050 {
2051 CoordType xpos = m_CursorLine->GetWrapPosition(column);
2052 if(xpos == -1)
2053 return false; // cannot break line
2054 //else:
2055 CoordType newpos = m_CursorPos.x - xpos - 1;
2056 m_CursorPos.x = xpos;
2057
2058 AddCursorPosToUpdateRect();
2059
2060 LineBreak();
2061 Delete(1); // delete the space
2062 m_CursorPos.x = newpos;
2063
2064 m_CursorLine->MarkDirty();
2065
2066 m_movedCursor = true;
2067
2068 return true;
2069 }
2070 }
2071
2072 bool
2073 wxLayoutList::Delete(CoordType npos)
2074 {
2075 wxCHECK_MSG(m_CursorLine, false, "can't delete in non existing line");
2076
2077 if ( npos == 0 )
2078 return true;
2079
2080 AddCursorPosToUpdateRect();
2081
2082 // were other lines appended to this one (this is important to know because
2083 // this means that our width _increased_ as the result of deletion)
2084 bool wasMerged = false;
2085
2086 // the size of the region to update
2087 CoordType totalHeight = m_CursorLine->GetHeight(),
2088 totalWidth = m_CursorLine->GetWidth();
2089
2090 CoordType left;
2091 do
2092 {
2093 left = m_CursorLine->Delete(m_CursorPos.x, npos);
2094
2095 if( left > 0 )
2096 {
2097 // More to delete, continue on next line.
2098
2099 // First, check if line is empty:
2100 if(m_CursorLine->GetLength() == 0)
2101 {
2102 // in this case, updating could probably be optimised
2103 #ifdef WXLO_DEBUG
2104 wxASSERT(DeleteLines(1) == 0);
2105 #else
2106 DeleteLines(1);
2107 #endif
2108
2109 left--;
2110 }
2111 else
2112 {
2113 // Need to join next line
2114 if(! m_CursorLine->GetNextLine())
2115 break; // cannot
2116 else
2117 {
2118 wasMerged = true;
2119 wxLayoutLine *next = m_CursorLine->GetNextLine();
2120 if ( next )
2121 {
2122 totalHeight += next->GetHeight();
2123 totalWidth += next->GetWidth();
2124
2125 m_CursorLine->MergeNextLine(this);
2126 left--;
2127 }
2128 else
2129 {
2130 wxFAIL_MSG("can't delete all this");
2131
2132 return false;
2133 }
2134 }
2135 }
2136 }
2137 }
2138 while ( left> 0 );
2139
2140 // we need to update the whole tail of the line and the lines which
2141 // disappeared
2142 if ( wasMerged )
2143 {
2144 wxPoint position(m_CursorLine->GetPosition());
2145 SetUpdateRect(position);
2146 SetUpdateRect(position.x + totalWidth + MSW_CORRECTION,
2147 position.y + totalHeight + MSW_CORRECTION);
2148 }
2149
2150 return left == 0;
2151 }
2152
2153 int
2154 wxLayoutList::DeleteLines(int n)
2155 {
2156 wxASSERT(m_CursorLine);
2157 wxLayoutLine *line;
2158
2159 AddCursorPosToUpdateRect();
2160
2161 while(n > 0)
2162 {
2163 if(!m_CursorLine->GetNextLine())
2164 { // we cannot delete this line, but we can clear it
2165 MoveCursorToBeginOfLine();
2166 DeleteToEndOfLine();
2167 if(m_AutoFormat)
2168 m_CursorLine->MarkDirty();
2169 return n-1;
2170 }
2171 //else:
2172 line = m_CursorLine;
2173 m_CursorLine = m_CursorLine->DeleteLine(true, this);
2174 n--;
2175 if(line == m_FirstLine) m_FirstLine = m_CursorLine;
2176 wxASSERT(m_FirstLine);
2177 wxASSERT(m_CursorLine);
2178 }
2179 if(m_AutoFormat)
2180 m_CursorLine->MarkDirty();
2181 return n;
2182 }
2183
2184 void
2185 wxLayoutList::Recalculate(wxDC &dc, CoordType bottom)
2186 {
2187 if(! m_AutoFormat)
2188 return;
2189 wxLayoutLine *line = m_FirstLine;
2190
2191 // first, make sure everything is calculated - this might not be
2192 // needed, optimise it later
2193 ApplyStyle(m_DefaultStyleInfo, dc);
2194 while(line)
2195 {
2196 line->RecalculatePosition(this); // so we don't need to do it all the time
2197 // little condition to speed up redrawing:
2198 if(bottom != -1 && line->GetPosition().y > bottom) break;
2199 line = line->GetNextLine();
2200 }
2201 }
2202
2203 wxPoint
2204 wxLayoutList::GetCursorScreenPos(void) const
2205 {
2206 return m_CursorScreenPos;
2207 }
2208
2209 /*
2210 Is called before each Draw(). Now, it will re-layout all lines which
2211 have changed.
2212 */
2213 void
2214 wxLayoutList::Layout(wxDC &dc, CoordType bottom, bool forceAll,
2215 wxPoint *cpos, wxPoint *csize)
2216 {
2217 // first, make sure everything is calculated - this might not be
2218 // needed, optimise it later
2219 ApplyStyle(m_DefaultStyleInfo, dc);
2220
2221
2222 if(m_ReLayoutAll)
2223 {
2224 forceAll = TRUE;
2225 bottom = -1;
2226 }
2227 ForceTotalLayout(FALSE);
2228
2229
2230 // If one line was dirty, we need to re-calculate all
2231 // following lines, too.
2232 bool wasDirty = forceAll;
2233 wxLayoutLine *line = m_FirstLine;
2234 while(line)
2235 {
2236 if(! wasDirty)
2237 ApplyStyle(line->GetStyleInfo(), dc);
2238 if(
2239 // if any previous line was dirty, we need to layout all
2240 // following lines:
2241 wasDirty
2242 // layout dirty lines:
2243 || line->IsDirty()
2244 // always layout the cursor line toupdate the cursor
2245 // position and size:
2246 || line == m_CursorLine
2247 // or if it's the line we are asked to look for:
2248 || (cpos && line->GetLineNumber() == cpos->y)
2249 )
2250 {
2251 if(line->IsDirty())
2252 wasDirty = true;
2253
2254 // The following Layout() calls will update our
2255 // m_CurrentStyleInfo if needed.
2256 if(line == m_CursorLine)
2257 {
2258 line->Layout(dc, this,
2259 (wxPoint *)&m_CursorScreenPos,
2260 (wxPoint *)&m_CursorSize,
2261 &m_CursorStyleInfo,
2262 m_CursorPos.x);
2263 // we cannot layout the line twice, so copy the coords:
2264 if(cpos && line ->GetLineNumber() == cpos->y)
2265 {
2266 *cpos = m_CursorScreenPos;
2267 if ( csize )
2268 *csize = m_CursorSize;
2269 }
2270 }
2271 else
2272 if(cpos && line->GetLineNumber() == cpos->y)
2273 line->Layout(dc, this,
2274 cpos,
2275 csize, NULL, cpos->x);
2276 else
2277 line->Layout(dc, this);
2278 // little condition to speed up redrawing:
2279 if(bottom != -1 && line->GetPosition().y > bottom)
2280 break;
2281 }
2282 line = line->GetNextLine();
2283 }
2284
2285 #ifndef WXLAYOUT_USE_CARET
2286 // can only be 0 if we are on the first line and have no next line
2287 wxASSERT(m_CursorSize.x != 0 || (m_CursorLine &&
2288 m_CursorLine->GetNextLine() == NULL &&
2289 m_CursorLine == m_FirstLine));
2290 #endif // WXLAYOUT_USE_CARET
2291 AddCursorPosToUpdateRect();
2292 }
2293
2294 wxPoint
2295 wxLayoutList::GetScreenPos(wxDC &dc, const wxPoint &cpos, wxPoint *csize)
2296 {
2297 wxPoint pos = cpos;
2298 Layout(dc, -1, false, &pos, csize);
2299 return pos;
2300 }
2301
2302 void
2303 wxLayoutList::Draw(wxDC &dc,
2304 wxPoint const &offset,
2305 CoordType top,
2306 CoordType bottom,
2307 bool clipStrictly)
2308 {
2309 wxLayoutLine *line = m_FirstLine;
2310
2311 if ( m_Selection.m_discarded )
2312 {
2313 // calculate them if we don't have them already
2314 if ( !m_Selection.HasValidScreenCoords() )
2315 {
2316 m_Selection.m_ScreenA = GetScreenPos(dc, m_Selection.m_CursorA);
2317 m_Selection.m_ScreenB = GetScreenPos(dc, m_Selection.m_CursorB);
2318 }
2319
2320 // invalidate the area which was previousle selected - and which is not
2321 // selected any more
2322 SetUpdateRect(m_Selection.m_ScreenA);
2323 SetUpdateRect(m_Selection.m_ScreenB);
2324
2325 m_Selection.m_discarded = false;
2326 }
2327
2328 /* This call to Layout() will re-calculate and update all lines
2329 marked as dirty.
2330 */
2331 Layout(dc, bottom);
2332
2333 ApplyStyle(m_DefaultStyleInfo, dc);
2334 wxBrush brush(m_CurrentStyleInfo.m_bg, wxSOLID);
2335 dc.SetBrush(brush);
2336 dc.SetBackgroundMode(wxTRANSPARENT);
2337
2338 while(line)
2339 {
2340 // only draw if between top and bottom:
2341 if((top == -1 ||
2342 line->GetPosition().y + line->GetHeight() > top))
2343 {
2344 ApplyStyle(line->GetStyleInfo(), dc);
2345 // little condition to speed up redrawing:
2346 if( bottom != -1
2347 && line->GetPosition().y
2348 +(clipStrictly ? line->GetHeight() : 0) >= bottom)
2349 break;
2350 line->Draw(dc, this, offset);
2351 }
2352 line = line->GetNextLine();
2353 }
2354 InvalidateUpdateRect();
2355
2356 WXLO_DEBUG(("Selection is %s : l%d,%ld/%ld,%ld",
2357 m_Selection.m_valid ? "valid" : "invalid",
2358 m_Selection.m_CursorA.x, m_Selection.m_CursorA.y,
2359 m_Selection.m_CursorB.x, m_Selection.m_CursorB.y));
2360 }
2361
2362 wxLayoutObject *
2363 wxLayoutList::FindObjectScreen(wxDC &dc, wxPoint const pos,
2364 wxPoint *cursorPos,
2365 bool *found)
2366 {
2367 // First, find the right line:
2368 wxLayoutLine
2369 *line = m_FirstLine,
2370 *lastline = m_FirstLine;
2371 wxPoint p;
2372
2373 ApplyStyle(m_DefaultStyleInfo, dc);
2374 while(line)
2375 {
2376 p = line->GetPosition();
2377 if(p.y <= pos.y && p.y+line->GetHeight() >= pos.y)
2378 break;
2379 lastline = line;
2380 line = line->GetNextLine();
2381 }
2382
2383 bool didFind = line != NULL;
2384
2385 if ( !line )
2386 {
2387 // use the last line:
2388 line = lastline;
2389 }
2390
2391 if ( cursorPos )
2392 cursorPos->y = line->GetLineNumber();
2393
2394 bool foundinline = true;
2395 long cx = 0;
2396
2397 // Now, find the object in the line:
2398 wxLOiterator i;
2399
2400 if (cursorPos)
2401 {
2402 i = line->FindObjectScreen(dc, this,
2403 pos.x,
2404 &cx,
2405 &foundinline);
2406 cursorPos->x = cx;
2407 }
2408 else
2409 i = line->FindObjectScreen(dc, this,
2410 pos.x,
2411 NULL,
2412 &foundinline);
2413 if ( found )
2414 *found = didFind && foundinline;
2415
2416 return (i == NULLIT) ? NULL : *i;
2417
2418 }
2419
2420 wxPoint
2421 wxLayoutList::GetSize(void) const
2422 {
2423 wxLayoutLine
2424 *line = m_FirstLine,
2425 *last = line;
2426 if(! line)
2427 return wxPoint(0,0);
2428
2429 wxPoint maxPoint(0,0);
2430
2431 // find last line:
2432 while(line)
2433 {
2434 if(line->GetWidth() > maxPoint.x)
2435 maxPoint.x = line->GetWidth();
2436 last = line;
2437 line = line->GetNextLine();
2438 }
2439
2440 maxPoint.y = last->GetPosition().y + last->GetHeight();
2441
2442 // if the line was just added, its height would be 0 and we can't call
2443 // Layout() from here because we don't have a dc and we might be not drawing
2444 // at all, besides... So take the cursor height by default (taking 0 is bad
2445 // because then the scrollbars won't be resized and the new line won't be
2446 // shown at all)
2447 if ( last->IsDirty() )
2448 {
2449 if ( last->GetHeight() == 0 )
2450 maxPoint.y += m_CursorSize.y;
2451 if ( last->GetWidth() == 0 && maxPoint.x < m_CursorSize.x )
2452 maxPoint.x = m_CursorSize.x;
2453 }
2454
2455 return maxPoint;
2456 }
2457
2458
2459 void
2460 wxLayoutList::DrawCursor(wxDC &dc, bool active, wxPoint const &translate)
2461 {
2462 if ( m_movedCursor )
2463 m_movedCursor = false;
2464
2465 wxPoint coords(m_CursorScreenPos);
2466 coords += translate;
2467
2468 #ifdef WXLAYOUT_DEBUG
2469 WXLO_DEBUG(("Drawing cursor (%ld,%ld) at %ld,%ld, size %ld,%ld, line: %ld, len %ld",
2470 (long)m_CursorPos.x, (long)m_CursorPos.y,
2471 (long)coords.x, (long)coords.y,
2472 (long)m_CursorSize.x, (long)m_CursorSize.y,
2473 (long)m_CursorLine->GetLineNumber(),
2474 (long)m_CursorLine->GetLength()));
2475
2476 wxLogStatus("Cursor is at (%d, %d)", m_CursorPos.x, m_CursorPos.y);
2477 #endif
2478
2479 #ifdef WXLAYOUT_USE_CARET
2480 m_caret->Move(coords);
2481 #else // !WXLAYOUT_USE_CARET
2482 dc.SetBrush(*wxWHITE_BRUSH);
2483 //FIXME: wxGTK XOR is borken at the moment!!!dc.SetLogicalFunction(wxXOR);
2484 dc.SetPen(wxPen(*wxBLACK,1,wxSOLID));
2485 if(active)
2486 {
2487 dc.SetLogicalFunction(wxXOR);
2488 dc.DrawRectangle(coords.x, coords.y,
2489 m_CursorSize.x, m_CursorSize.y);
2490 SetUpdateRect(coords.x, coords.y);
2491 SetUpdateRect(coords.x+m_CursorSize.x, coords.y+m_CursorSize.y);
2492 }
2493 else
2494 {
2495 dc.SetLogicalFunction(wxCOPY);
2496 dc.DrawLine(coords.x, coords.y+m_CursorSize.y-1,
2497 coords.x, coords.y);
2498 SetUpdateRect(coords.x, coords.y+m_CursorSize.y-1);
2499 SetUpdateRect(coords.x, coords.y);
2500 }
2501 dc.SetLogicalFunction(wxCOPY);
2502 //dc.SetBrush(wxNullBrush);
2503 #endif // WXLAYOUT_USE_CARET/!WXLAYOUT_USE_CARET
2504 }
2505
2506 void
2507 wxLayoutList::SetUpdateRect(CoordType x, CoordType y)
2508 {
2509 if(m_UpdateRectValid)
2510 GrowRect(m_UpdateRect, x, y);
2511 else
2512 {
2513 m_UpdateRect.x = x;
2514 m_UpdateRect.y = y;
2515 m_UpdateRect.width = 4; // large enough to avoid surprises from
2516 m_UpdateRect.height = 4;// wxGTK :-)
2517 m_UpdateRectValid = true;
2518 }
2519 }
2520
2521 void
2522 wxLayoutList::StartSelection(const wxPoint& cposOrig, const wxPoint& spos)
2523 {
2524 wxPoint cpos(cposOrig);
2525 if ( cpos.x == -1 )
2526 cpos = m_CursorPos;
2527 WXLO_DEBUG(("Starting selection at %ld/%ld", cpos.x, cpos.y));
2528 m_Selection.m_CursorA = cpos;
2529 m_Selection.m_CursorB = cpos;
2530 m_Selection.m_ScreenA = spos;
2531 m_Selection.m_ScreenB = spos;
2532 m_Selection.m_selecting = true;
2533 m_Selection.m_valid = false;
2534 }
2535
2536 void
2537 wxLayoutList::ContinueSelection(const wxPoint& cposOrig, const wxPoint& spos)
2538 {
2539 wxPoint cpos(cposOrig);
2540 if(cpos.x == -1)
2541 cpos = m_CursorPos;
2542
2543 wxASSERT(m_Selection.m_selecting == true);
2544 wxASSERT(m_Selection.m_valid == false);
2545 WXLO_DEBUG(("Continuing selection at %ld/%ld", cpos.x, cpos.y));
2546
2547 m_Selection.m_ScreenB = spos;
2548 m_Selection.m_CursorB = cpos;}
2549
2550 void
2551 wxLayoutList::EndSelection(const wxPoint& cposOrig, const wxPoint& spos)
2552 {
2553 wxPoint cpos(cposOrig);
2554 if(cpos.x == -1)
2555 cpos = m_CursorPos;
2556 ContinueSelection(cpos);
2557 WXLO_DEBUG(("Ending selection at %ld/%ld", cpos.x, cpos.y));
2558 // we always want m_CursorA <= m_CursorB!
2559 if( m_Selection.m_CursorA > m_Selection.m_CursorB )
2560 {
2561 // exchange the start/end points
2562 wxPoint help = m_Selection.m_CursorB;
2563 m_Selection.m_CursorB = m_Selection.m_CursorA;
2564 m_Selection.m_CursorA = help;
2565
2566 help = m_Selection.m_ScreenB;
2567 m_Selection.m_ScreenB = m_Selection.m_ScreenA;
2568 m_Selection.m_ScreenA = help;
2569 }
2570 m_Selection.m_selecting = false;
2571 m_Selection.m_valid = true;
2572 /// In case we just clicked somewhere, the selection will have zero
2573 /// size, so we discard it immediately.
2574 if(m_Selection.m_CursorA == m_Selection.m_CursorB)
2575 DiscardSelection();
2576 }
2577
2578 void
2579 wxLayoutList::DiscardSelection()
2580 {
2581 if ( !HasSelection() )
2582 return;
2583
2584 m_Selection.m_valid =
2585 m_Selection.m_selecting = false;
2586 m_Selection.m_discarded = true;
2587 }
2588
2589 bool
2590 wxLayoutList::IsSelecting(void) const
2591 {
2592 return m_Selection.m_selecting;
2593 }
2594
2595 bool
2596 wxLayoutList::IsSelected(const wxPoint &cursor) const
2597 {
2598 if ( !HasSelection() )
2599 return false;
2600
2601 return (
2602 (m_Selection.m_CursorA <= cursor
2603 && cursor <= m_Selection.m_CursorB)
2604 || (m_Selection.m_CursorB <= cursor
2605 && cursor <= m_Selection.m_CursorA)
2606 );
2607 }
2608
2609
2610 /** Tests whether this layout line is selected and needs
2611 highlighting.
2612 @param line to test for
2613 @return 0 = not selected, 1 = fully selected, -1 = partially
2614 selected
2615 */
2616 int
2617 wxLayoutList::IsSelected(const wxLayoutLine *line, CoordType *from,
2618 CoordType *to)
2619 {
2620 wxASSERT(line); wxASSERT(to); wxASSERT(from);
2621
2622 if(! m_Selection.m_valid && ! m_Selection.m_selecting)
2623 return 0;
2624
2625 CoordType y = line->GetLineNumber();
2626 if(
2627 (m_Selection.m_CursorA.y < y && m_Selection.m_CursorB.y > y)
2628 || (m_Selection.m_CursorB.y < y && m_Selection.m_CursorA.y > y)
2629 )
2630 return 1;
2631 else if(m_Selection.m_CursorA.y == y)
2632 {
2633 *from = m_Selection.m_CursorA.x;
2634 if(m_Selection.m_CursorB.y == y)
2635 *to = m_Selection.m_CursorB.x;
2636 else
2637 {
2638 if(m_Selection.m_CursorB > m_Selection.m_CursorA)
2639 *to = line->GetLength();
2640 else
2641 *to = 0;
2642 }
2643 if(*to < *from)
2644 {
2645 CoordType help = *to;
2646 *to = *from;
2647 *from = help;
2648 }
2649 return -1;
2650 }
2651 else if(m_Selection.m_CursorB.y == y)
2652 {
2653 *to = m_Selection.m_CursorB.x;
2654 if(m_Selection.m_CursorA.y == y)
2655 *from = m_Selection.m_CursorA.x;
2656 else
2657 {
2658 if(m_Selection.m_CursorB > m_Selection.m_CursorA)
2659 *from = 0;
2660 else
2661 *from = line->GetLength();
2662 }
2663 if(*to < *from)
2664 {
2665 CoordType help = *to;
2666 *to = *from;
2667 *from = help;
2668 }
2669 return -1;
2670 }
2671 else
2672 return 0;
2673 }
2674
2675 void
2676 wxLayoutList::DeleteSelection(void)
2677 {
2678 if(! m_Selection.m_valid)
2679 return;
2680
2681 m_Selection.m_valid = false;
2682
2683 // Only delete part of the current line?
2684 if(m_Selection.m_CursorA.y == m_Selection.m_CursorB.y)
2685 {
2686 MoveCursorTo(m_Selection.m_CursorA);
2687 Delete(m_Selection.m_CursorB.x - m_Selection.m_CursorA.x);
2688 return;
2689 }
2690
2691 // We now know that the two lines are different:
2692
2693 wxLayoutLine
2694 * firstLine = GetLine(m_Selection.m_CursorA.y),
2695 * lastLine = GetLine(m_Selection.m_CursorB.y);
2696 // be a bit paranoid:
2697 if(! firstLine || ! lastLine)
2698 return;
2699
2700 // First, delete what's left of this line:
2701 MoveCursorTo(m_Selection.m_CursorA);
2702 DeleteToEndOfLine();
2703
2704 wxLayoutLine *prevLine = firstLine->GetPreviousLine(),
2705 *nextLine = firstLine->GetNextLine();
2706 while(nextLine && nextLine != lastLine)
2707 nextLine = nextLine->DeleteLine(false, this);
2708
2709 // Now nextLine = lastLine;
2710 Delete(1); // This joins firstLine and nextLine
2711 Delete(m_Selection.m_CursorB.x); // This deletes the first x positions
2712
2713 // Recalculate the line positions and numbers but notice that firstLine
2714 // might not exist any more - it could be deleted by Delete(1) above
2715 wxLayoutLine *firstLine2 = prevLine ? prevLine->GetNextLine() : m_FirstLine;
2716 firstLine2->MarkDirty();
2717 }
2718
2719 /// Starts highlighting the selection
2720 void
2721 wxLayoutList::StartHighlighting(wxDC &dc)
2722 {
2723 #if SHOW_SELECTIONS
2724 dc.SetTextForeground(m_CurrentStyleInfo.m_bg);
2725 dc.SetTextBackground(m_CurrentStyleInfo.m_fg);
2726 dc.SetBackgroundMode(wxSOLID);
2727 #endif
2728 }
2729
2730 /// Ends highlighting the selection
2731 void
2732 wxLayoutList::EndHighlighting(wxDC &dc)
2733 {
2734 #if SHOW_SELECTIONS
2735 dc.SetTextForeground(m_CurrentStyleInfo.m_fg);
2736 dc.SetTextBackground(m_CurrentStyleInfo.m_bg);
2737 dc.SetBackgroundMode(wxTRANSPARENT);
2738 #endif
2739 }
2740
2741
2742 wxLayoutLine *
2743 wxLayoutList::GetLine(CoordType index) const
2744 {
2745 wxASSERT_MSG( (0 <= index) && (index < (CoordType)m_numLines),
2746 "invalid index" );
2747
2748 wxLayoutLine *line;
2749 CoordType n = index;
2750 #ifdef DEBUG
2751 CoordType lineNo = 0;
2752 #endif
2753
2754 for ( line = m_FirstLine; line && n-- > 0; line =
2755 line->GetNextLine() )
2756 {
2757 #ifdef DEBUG
2758 wxASSERT(line->GetLineNumber() == lineNo );
2759 lineNo++;
2760 #endif
2761 }
2762
2763 if ( line )
2764 {
2765 // should be the right one
2766 wxASSERT( line->GetLineNumber() == index );
2767 }
2768
2769 return line;
2770 }
2771
2772
2773 wxLayoutList *
2774 wxLayoutList::Copy(const wxPoint &from,
2775 const wxPoint &to)
2776 {
2777 wxLayoutLine
2778 * firstLine = NULL,
2779 * lastLine = NULL;
2780
2781 for(firstLine = m_FirstLine;
2782 firstLine && firstLine->GetLineNumber() < from.y;
2783 firstLine=firstLine->GetNextLine())
2784 ;
2785 if(!firstLine || firstLine->GetLineNumber() != from.y)
2786 return NULL;
2787
2788 for(lastLine = m_FirstLine;
2789 lastLine && lastLine->GetLineNumber() < to.y;
2790 lastLine=lastLine->GetNextLine())
2791 ;
2792 if(!lastLine || lastLine->GetLineNumber() != to.y)
2793 return NULL;
2794
2795 if(to <= from)
2796 {
2797 wxLayoutLine *tmp = firstLine;
2798 firstLine = lastLine;
2799 lastLine = tmp;
2800 }
2801
2802 wxLayoutList *llist = new wxLayoutList();
2803
2804 if(firstLine == lastLine)
2805 {
2806 firstLine->Copy(llist, from.x, to.x);
2807 }
2808 else
2809 {
2810 // Extract objects from first line
2811 firstLine->Copy(llist, from.x);
2812 llist->LineBreak();
2813 // Extract all lines between
2814 for(wxLayoutLine *line = firstLine->GetNextLine();
2815 line != lastLine;
2816 line = line->GetNextLine())
2817 {
2818 line->Copy(llist);
2819 llist->LineBreak();
2820 }
2821 // Extract objects from last line
2822 lastLine->Copy(llist, 0, to.x);
2823 }
2824 return llist;
2825 }
2826
2827 wxLayoutList *
2828 wxLayoutList::GetSelection(wxLayoutDataObject *wxlo, bool invalidate)
2829 {
2830 if(! m_Selection.m_valid)
2831 {
2832 if(m_Selection.m_selecting)
2833 EndSelection();
2834 else
2835 return NULL;
2836 }
2837
2838 if(invalidate) m_Selection.m_valid = false;
2839
2840 wxLayoutList *llist = Copy( m_Selection.m_CursorA,
2841 m_Selection.m_CursorB );
2842
2843 if(llist && wxlo) // export as data object, too
2844 {
2845 wxString string;
2846
2847 wxLayoutExportObject *exp;
2848 wxLayoutExportStatus status(llist);
2849 while((exp = wxLayoutExport( &status, WXLO_EXPORT_AS_OBJECTS)) != NULL)
2850 {
2851 if(exp->type == WXLO_EXPORT_EMPTYLINE)
2852 ; //FIXME missing support for linebreaks in string format
2853 else
2854 exp->content.object->Write(string);
2855 delete exp;
2856 }
2857
2858 wxlo->SetLayoutData(string);
2859 }
2860 return llist;
2861 }
2862
2863
2864
2865 #define COPY_SI(what) if(si.what != -1) { m_CurrentStyleInfo.what = si.what; fontChanged = TRUE; }
2866
2867 void
2868 wxLayoutList::ApplyStyle(wxLayoutStyleInfo const &si, wxDC &dc)
2869 {
2870 bool fontChanged = FALSE;
2871 COPY_SI(family);
2872 COPY_SI(size);
2873 COPY_SI(style);
2874 COPY_SI(weight);
2875 COPY_SI(underline);
2876 if(fontChanged)
2877 dc.SetFont( m_FontCache.GetFont(m_CurrentStyleInfo) );
2878
2879 if(si.m_fg_valid)
2880 {
2881 m_CurrentStyleInfo.m_fg = si.m_fg;
2882 dc.SetTextForeground(m_CurrentStyleInfo.m_fg);
2883 }
2884 if(si.m_bg_valid)
2885 {
2886 m_CurrentStyleInfo.m_bg = si.m_bg;
2887 dc.SetTextBackground(m_CurrentStyleInfo.m_bg);
2888 }
2889 }
2890
2891
2892 #ifdef WXLAYOUT_DEBUG
2893
2894 void
2895 wxLayoutList::Debug(void)
2896 {
2897 WXLO_DEBUG(("Cursor is in line %d, screen pos = (%d, %d)",
2898 m_CursorLine->GetLineNumber(),
2899 m_CursorScreenPos.x, m_CursorScreenPos.y));
2900
2901 wxLayoutLine *line;
2902 for(line = m_FirstLine; line; line = line->GetNextLine())
2903 {
2904 line->Debug();
2905 }
2906 }
2907
2908 #endif
2909
2910
2911 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
2912
2913 wxLayoutPrintout
2914
2915 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2916
2917 wxLayoutPrintout::wxLayoutPrintout(wxLayoutList *llist,
2918 wxString const & title)
2919 :wxPrintout(title)
2920 {
2921 m_llist = llist;
2922 m_title = title;
2923 // remove any highlighting which could interfere with printing:
2924 m_llist->StartSelection();
2925 m_llist->EndSelection();
2926 // force a full layout of the list:
2927 m_llist->ForceTotalLayout();
2928 // layout is called in ScaleDC() when we have a DC
2929 }
2930
2931 wxLayoutPrintout::~wxLayoutPrintout()
2932 {
2933 }
2934
2935 float
2936 wxLayoutPrintout::ScaleDC(wxDC *dc)
2937 {
2938 // The following bit is taken from the printing sample, let's see
2939 // whether it works for us.
2940
2941 /* You might use THIS code to set the printer DC to ROUGHLY reflect
2942 * the screen text size. This page also draws lines of actual length 5cm
2943 * on the page.
2944 */
2945 // Get the logical pixels per inch of screen and printer
2946 int ppiScreenX, ppiScreenY;
2947 GetPPIScreen(&ppiScreenX, &ppiScreenY);
2948 int ppiPrinterX, ppiPrinterY;
2949 GetPPIPrinter(&ppiPrinterX, &ppiPrinterY);
2950
2951 if(ppiScreenX == 0) // not yet set, need to guess
2952 {
2953 ppiScreenX = 100;
2954 ppiScreenY = 100;
2955 }
2956 if(ppiPrinterX == 0) // not yet set, need to guess
2957 {
2958 ppiPrinterX = 72;
2959 ppiPrinterY = 72;
2960 }
2961
2962 // This scales the DC so that the printout roughly represents the
2963 // the screen scaling. The text point size _should_ be the right size
2964 // but in fact is too small for some reason. This is a detail that will
2965 // need to be addressed at some point but can be fudged for the
2966 // moment.
2967 float scale = (float)((float)ppiPrinterX/(float)ppiScreenX);
2968
2969 // Now we have to check in case our real page size is reduced
2970 // (e.g. because we're drawing to a print preview memory DC)
2971 int pageWidth, pageHeight;
2972 int w, h;
2973 dc->GetSize(&w, &h);
2974 GetPageSizePixels(&pageWidth, &pageHeight);
2975 if(pageWidth != 0) // doesn't work always
2976 {
2977 // If printer pageWidth == current DC width, then this doesn't
2978 // change. But w might be the preview bitmap width, so scale down.
2979 scale = scale * (float)(w/(float)pageWidth);
2980 }
2981 dc->SetUserScale(scale, scale);
2982 return scale;
2983 }
2984
2985 bool wxLayoutPrintout::OnPrintPage(int page)
2986 {
2987 wxDC *dc = GetDC();
2988
2989 ScaleDC(dc);
2990
2991 if (dc)
2992 {
2993 int top, bottom;
2994 top = (page - 1)*m_PrintoutHeight;
2995 bottom = top + m_PrintoutHeight;
2996
2997 WXLO_DEBUG(("OnPrintPage(%d) printing from %d to %d", page, top,
2998 bottom));
2999 // SetDeviceOrigin() doesn't work here, so we need to manually
3000 // translate all coordinates.
3001 wxPoint translate(m_Offset.x,m_Offset.y-top);
3002 m_llist->Draw(*dc, translate, top, bottom, TRUE /* clip strictly
3003 */);
3004 return true;
3005 }
3006 else
3007 return false;
3008 }
3009
3010 void wxLayoutPrintout::GetPageInfo(int *minPage, int *maxPage, int *selPageFrom, int *selPageTo)
3011 {
3012 /* We allocate a temporary wxDC for printing, so that we can
3013 determine the correct paper size and scaling. We don't actually
3014 print anything on it. */
3015 #ifdef __WXMSW__
3016 wxPrinterDC *psdc = new wxPrinterDC("","",WXLLIST_TEMPFILE,false);
3017 #else
3018 wxPostScriptDC *psdc = new wxPostScriptDC(WXLLIST_TEMPFILE,false);
3019 #endif
3020
3021 psdc->StartDoc(m_title);
3022 // before we draw anything, me must make sure the list is properly
3023 // laid out
3024 m_llist->Layout(*psdc);
3025
3026 float scale = ScaleDC(psdc);
3027
3028 psdc->GetSize(&m_PageWidth, &m_PageHeight);
3029
3030 // This sets a left/top origin of 15% and 5%:
3031 m_Offset = wxPoint((15*m_PageWidth)/100, (5*m_PageHeight)/100);
3032
3033 // This is the length of the printable area.
3034 m_PrintoutHeight = m_PageHeight - 2*m_Offset.y;
3035 m_PrintoutHeight = (int)( m_PrintoutHeight / scale); // we want to use the real paper height
3036
3037 m_NumOfPages = 1 +
3038 (int)( m_llist->GetSize().y / (float)(m_PrintoutHeight));
3039
3040 *minPage = 1;
3041 *maxPage = m_NumOfPages;
3042
3043 *selPageFrom = 1;
3044 *selPageTo = m_NumOfPages;
3045 psdc->EndDoc();
3046 delete psdc;
3047 wxRemoveFile(WXLLIST_TEMPFILE);
3048 }
3049
3050 bool wxLayoutPrintout::HasPage(int pageNum)
3051 {
3052 return pageNum <= m_NumOfPages;
3053 }
3054
3055 /*
3056 Stupid wxWindows doesn't draw proper ellipses, so we comment this
3057 out. It's a waste of paper anyway.
3058 */
3059 #if 0
3060 void
3061 wxLayoutPrintout::DrawHeader(wxDC &dc,
3062 wxPoint topleft, wxPoint bottomright,
3063 int pageno)
3064 {
3065 // make backups of all essential parameters
3066 const wxBrush& brush = dc.GetBrush();
3067 const wxPen& pen = dc.GetPen();
3068 const wxFont& font = dc.GetFont();
3069
3070 dc.SetBrush(*wxWHITE_BRUSH);
3071 dc.SetPen(wxPen(*wxBLACK,0,wxSOLID));
3072 dc.DrawRoundedRectangle(topleft.x,
3073 topleft.y,bottomright.x-topleft.x,
3074 bottomright.y-topleft.y);
3075 dc.SetBrush(*wxBLACK_BRUSH);
3076 wxFont myfont = wxFont((WXLO_DEFAULTFONTSIZE*12)/10,
3077 wxSWISS,wxNORMAL,wxBOLD,false,"Helvetica");
3078 dc.SetFont(myfont);
3079
3080 wxString page;
3081 page = "9999/9999 "; // many pages...
3082 long w,h;
3083 dc.GetTextExtent(page,&w,&h);
3084 page.Printf("%d/%d", pageno, (int) m_NumOfPages);
3085 dc.DrawText(page,bottomright.x-w,topleft.y+h/2);
3086 dc.GetTextExtent("XXXX", &w,&h);
3087 dc.DrawText(m_title, topleft.x+w,topleft.y+h/2);
3088
3089 // restore settings
3090 dc.SetPen(pen);
3091 dc.SetBrush(brush);
3092 dc.SetFont(font);
3093 }
3094 #endif
3095
3096
3097 wxFont &
3098 wxFontCache::GetFont(int family, int size, int style, int weight,
3099 bool underline)
3100 {
3101 for(wxFCEList::iterator i = m_FontList.begin();
3102 i != m_FontList.end(); i++)
3103 if( (**i).Matches(family, size, style, weight, underline) )
3104 return (**i).GetFont();
3105 // not found:
3106 wxFontCacheEntry *fce = new wxFontCacheEntry(family, size, style,
3107 weight, underline);
3108 m_FontList.push_back(fce);
3109 return fce->GetFont();
3110 }
3111
wxWidgets (Impactor)