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


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