user/wxLayout/wxllist.cpp

   1 /*-*- c++ -*-********************************************************
   2  * wxllist: wxLayoutList, a layout engine for text and graphics     *
   3  *                                                                  *
   4  * (C) 1998 by Karsten Ballüder (Ballueder@usa.net)                 *
   5  *                                                                  *
   6  * $Id$
   7  *******************************************************************/
   8
   9 /*
  10   - each Object knows its size and how to draw itself
  11   - the list is responsible for calculating positions
  12   - the draw coordinates for each object are the top left corner
  13   - coordinates only get calculated when things get redrawn
  14   - The cursor position is the position before an object, i.e. if the
  15     buffer starts with a text-object, cursor 0,0 is just before the
  16     first character. For all non-text objects, the cursor positions
  17     are 0==before or 1==behind. So that all non-text objects count as
  18     one cursor position.
  19   - Linebreaks are at the end of a line, that is a line like "abc\n"
  20     is four cursor positions long. This makes sure that cursor
  21     positions are "as expected", i.e. in "abc\ndef" the 'd' would be
  22     at positions (x=0,y=1).
  23
  24
  25     The redrawing of the cursor no longer erases it at the last
  26     position, because the list gets redrawn anyway.
  27 */
  28
  29 /*
  30   TODO:
  31
  32   - blinking cursor
  33   - mouse click positions cursor
  34   - selection (SetMark(), GetSelection())
  35   - DND acceptance of text / clipboard support
  36   - wxlwindow: formatting menu: problem with checked/unchecked consistency gtk bug?
  37 */
  38
  39
  40 #ifdef __GNUG__
  41 #pragma implementation "wxllist.h"
  42 #endif
  43
  44 //#include "Mpch.h"
  45 #ifdef M_PREFIX
  46 #   include "gui/wxllist.h"
  47 #else
  48 #   include "wxllist.h"
  49 #endif
  50
  51 #ifndef USE_PCH
  52 #   include   "iostream.h"
  53 #   include   <wx/dc.h>
  54 #   include   <wx/dcps.h>
  55 #   include   <wx/print.h>
  56 #   include   <wx/log.h>
  57 #endif
  58
  59 #define   BASELINESTRETCH   12
  60
  61 // This should never really get created
  62 #define   WXLLIST_TEMPFILE   "__wxllist.tmp"
  63
  64 #ifdef WXLAYOUT_DEBUG
  65 static const char *g_aTypeStrings[] =
  66 {
  67    "invalid", "text", "cmd", "icon", "linebreak"
  68 };
  69
  70 #  define   wxLayoutDebug        wxLogDebug
  71 #  define   WXL_VAR(x)           cerr << #x " = " << x << endl;
  72 #  define   WXL_DBG_POINT(p)     wxLayoutDebug(#p ": (%d, %d)", p.x, p.y)
  73 #  define   WXL_TRACE(f)         wxLayoutDebug(#f ": ")
  74 #  define   TypeString(t)        g_aTypeStrings[t]
  75
  76 void
  77 wxLayoutObjectBase::Debug(void)
  78 {
  79    CoordType bl = 0;
  80    wxLayoutDebug("%s: size = %dx%d, pos=%d,%d, bl = %d",
  81                  TypeString(GetType()), GetSize(&bl).x,
  82                  GetSize(&bl).y,
  83                  GetPosition().x, GetPosition().y, bl);
  84 }
  85
  86 #else
  87 #  define   WXL_VAR(x)
  88 #  define   WXL_DBG_POINT(p)
  89 #  define   WXL_TRACE(f)
  90 #  define   ShowCurrentObject()
  91 #  define   TypeString(t)        ""
  92 inline void wxLayoutDebug(const char *, ...) { }
  93 #endif
  94
  95
  96 //-------------------------- wxLayoutObjectText
  97
  98 wxLayoutObjectText::wxLayoutObjectText(const String &txt)
  99 {
 100    m_Text = txt;
 101    m_Width = 0;
 102    m_Height = 0;
 103    m_Position = wxPoint(-1,-1);
 104 }
 105
 106
 107 wxPoint
 108 wxLayoutObjectText::GetSize(CoordType *baseLine) const
 109 {
 110    if(baseLine) *baseLine = m_BaseLine;
 111    return wxPoint(m_Width, m_Height);
 112 }
 113
 114 void
 115 wxLayoutObjectText::Draw(wxDC &dc, wxPoint const &translate)
 116 {
 117    dc.DrawText(Str(m_Text), m_Position.x + translate.x, m_Position.y+translate.y);
 118    m_IsDirty = false;
 119 }
 120
 121
 122 void
 123 wxLayoutObjectText::Layout(wxDC &dc, wxPoint position, CoordType baseLine)
 124 {
 125    long descent = 0l;
 126
 127    if(m_Position.x != position.x || m_Position.y != position.y)
 128       m_IsDirty = true;
 129
 130    m_Position = position;
 131    dc.GetTextExtent(Str(m_Text),&m_Width, &m_Height, &descent);
 132    m_BaseLine = m_Height - descent;
 133    if(m_Position.x != position.x || m_Position.y != position.y)
 134       m_IsDirty = true;
 135 }
 136
 137 #ifdef WXLAYOUT_DEBUG
 138 void
 139 wxLayoutObjectText::Debug(void)
 140 {
 141    wxLayoutObjectBase::Debug();
 142    wxLayoutDebug(" `%s`", m_Text.c_str());
 143 }
 144 #endif
 145
 146 //-------------------------- wxLayoutObjectIcon
 147
 148 wxLayoutObjectIcon::wxLayoutObjectIcon(wxIcon const &icon)
 149 {
 150    m_Position = wxPoint(-1,-1);
 151    m_Icon = new wxIcon(icon);
 152 }
 153
 154 wxLayoutObjectIcon::wxLayoutObjectIcon(wxIcon *icon)
 155 {
 156    m_Icon = icon;
 157 }
 158
 159 void
 160 wxLayoutObjectIcon::Draw(wxDC &dc, wxPoint const &translate)
 161 {
 162    dc.DrawIcon(*m_Icon,m_Position.x+translate.x, m_Position.y+translate.y);
 163 }
 164
 165 void
 166 wxLayoutObjectIcon::Layout(wxDC &dc, wxPoint position, CoordType baseLine)
 167 {
 168    if(m_Position.x != position.x || m_Position.y != position.y)
 169       m_IsDirty = true;
 170    m_Position = position;
 171 }
 172
 173 wxPoint
 174 wxLayoutObjectIcon::GetSize(CoordType *baseLine) const
 175 {
 176    if(baseLine)   *baseLine = m_Icon->GetHeight();
 177    return wxPoint(m_Icon->GetWidth(), m_Icon->GetHeight());
 178 }
 179
 180 //-------------------------- wxLayoutObjectCmd
 181
 182
 183 wxLayoutObjectCmd::wxLayoutObjectCmd(int size, int family, int style, int
 184                                      weight, bool underline,
 185                                      wxColour const *fg, wxColour const *bg)
 186
 187 {
 188    m_font = new wxFont(size,family,style,weight,underline);
 189    m_ColourFG = fg;
 190    m_ColourBG = bg;
 191 }
 192
 193 wxLayoutObjectCmd::~wxLayoutObjectCmd()
 194 {
 195    delete m_font;
 196 }
 197
 198 wxLayoutStyleInfo *
 199 wxLayoutObjectCmd::GetStyle(void) const
 200 {
 201    wxLayoutStyleInfo *si = new wxLayoutStyleInfo();
 202
 203
 204    si->size = m_font->GetPointSize();
 205    si->family = m_font->GetFamily();
 206    si->style = m_font->GetStyle();
 207    si->underline = m_font->GetUnderlined();
 208    si->weight = m_font->GetWeight();
 209
 210    si->fg_red = m_ColourFG->Red();
 211    si->fg_green = m_ColourFG->Green();
 212    si->fg_blue = m_ColourFG->Blue();
 213    si->bg_red = m_ColourBG->Red();
 214    si->bg_green = m_ColourBG->Green();
 215    si->bg_blue = m_ColourBG->Blue();
 216
 217    return si;
 218 }
 219
 220 void
 221 wxLayoutObjectCmd::Draw(wxDC &dc, wxPoint const &translate)
 222 {
 223    wxASSERT(m_font);
 224    dc.SetFont(*m_font);
 225    if(m_ColourFG)
 226       dc.SetTextForeground(*m_ColourFG);
 227    if(m_ColourBG)
 228       dc.SetTextBackground(*m_ColourBG);
 229 }
 230 void
 231 wxLayoutObjectCmd::Layout(wxDC &dc, wxPoint p, CoordType baseline)
 232 {
 233    m_Position = p; // required so we can find the right object for cursor
 234    // this get called, so that recalculation uses right font sizes
 235    Draw(dc,wxPoint(0,0));
 236 }
 237
 238 //-------------------------- wxLayoutList
 239
 240 wxLayoutList::wxLayoutList()
 241 {
 242    m_DefaultSetting = NULL;
 243    m_WrapMargin = -1;
 244    m_Editable = FALSE;
 245    m_boldCursor = FALSE;
 246
 247    Clear();
 248 }
 249
 250 wxLayoutList::~wxLayoutList()
 251 {
 252    if(m_DefaultSetting)
 253       delete m_DefaultSetting;
 254    // no deletion of objects, they are owned by the list
 255 }
 256
 257 void
 258 wxLayoutList::LineBreak(void)
 259 {
 260    Insert(new wxLayoutObjectLineBreak);
 261 }
 262
 263 void
 264 wxLayoutList::SetFont(int family, int size, int style, int weight,
 265                       int underline, wxColour const *fg,
 266                       wxColour const *bg)
 267 {
 268    if(family != -1)    m_FontFamily = family;
 269    if(size != -1)      m_FontPtSize = size;
 270    if(style != -1)     m_FontStyle = style;
 271    if(weight != -1)    m_FontWeight = weight;
 272    if(underline != -1) m_FontUnderline = underline != 0;
 273
 274    if(fg != NULL)     m_ColourFG = fg;
 275    if(bg != NULL)     m_ColourBG = bg;
 276
 277    Insert(
 278       new wxLayoutObjectCmd(m_FontPtSize,m_FontFamily,m_FontStyle,m_FontWeight,m_FontUnderline,
 279                             m_ColourFG, m_ColourBG));
 280 }
 281
 282 void
 283 wxLayoutList::SetFont(int family, int size, int style, int weight,
 284                       int underline, char const *fg, char const *bg)
 285
 286 {
 287    wxColour const
 288       * cfg = NULL,
 289       * cbg = NULL;
 290
 291    if( fg )
 292       cfg = wxTheColourDatabase->FindColour(fg);
 293    if( bg )
 294       cbg = wxTheColourDatabase->FindColour(bg);
 295
 296    SetFont(family,size,style,weight,underline,cfg,cbg);
 297 }
 298
 299
 300 /// for access by wxLayoutWindow:
 301 void
 302 wxLayoutList::GetSize(CoordType *max_x, CoordType *max_y,
 303                       CoordType *lineHeight)
 304 {
 305
 306    if(max_x) *max_x = m_MaxX;
 307    if(max_y) *max_y = m_MaxY;
 308    if(lineHeight) *lineHeight = m_LineHeight;
 309 }
 310
 311 void
 312 wxLayoutList::ResetSettings(wxDC &dc)
 313 {
 314    // setting up the default:
 315    dc.SetTextForeground( *wxBLACK );
 316    dc.SetTextBackground( *wxWHITE );
 317    dc.SetBackgroundMode( wxSOLID ); // to enable setting of text background
 318    dc.SetFont( *wxNORMAL_FONT );
 319    if(m_DefaultSetting)
 320       m_DefaultSetting->Draw(dc,wxPoint(0,0));
 321 }
 322
 323 void
 324 wxLayoutList::Layout(wxDC &dc, wxLayoutMargins *margins)
 325 {
 326    iterator i;
 327
 328    // first object in current line
 329    wxLayoutObjectList::iterator headOfLine;
 330    // where we draw next
 331    wxPoint position, position_HeadOfLine;
 332    // size of last object
 333    wxPoint size;
 334    CoordType baseLine = m_FontPtSize;
 335    CoordType baseLineSkip = (BASELINESTRETCH * baseLine)/10;
 336    CoordType objBaseLine = baseLine;
 337    wxLayoutObjectType type;
 338
 339    // we need to count cursor positions
 340    wxPoint cursorPos = wxPoint(0,0);
 341
 342    if(margins)
 343    {
 344       position.y = margins->top;
 345       position.x = margins->left;
 346    }
 347    else
 348    {
 349       position.y = 0;
 350       position.x = 0;
 351    }
 352
 353    ResetSettings(dc);
 354
 355    i = begin();
 356    headOfLine = i;
 357    position_HeadOfLine = position;
 358
 359    do
 360    {
 361       if(i == end())
 362          return;
 363
 364       type = (*i)->GetType();
 365       (*i)->Layout(dc, position, baseLine);
 366       size = (*i)->GetSize(&objBaseLine);
 367       // calculate next object's position:
 368       position.x += size.x;
 369
 370       // do we need to increase the line's height?
 371       if(size.y > baseLineSkip)
 372       {
 373          baseLineSkip = size.y;
 374          i = headOfLine; position = position_HeadOfLine;
 375          continue;
 376       }
 377       if(objBaseLine > baseLine)
 378       {
 379          baseLine = objBaseLine;
 380          i = headOfLine; position = position_HeadOfLine;
 381          continue;
 382       }
 383
 384       // when we reach here, the coordinates are valid, this part of
 385       // the loop gets run only once per object
 386       if(position.x > m_MaxX)
 387          m_MaxX = position.x;
 388       if(type == WXLO_TYPE_LINEBREAK)
 389       {
 390          cursorPos.x = 0; cursorPos.y ++;
 391       }
 392       else
 393          cursorPos.x += (**i).CountPositions();
 394
 395       // now check whether we have finished handling this line:
 396       if(type == WXLO_TYPE_LINEBREAK && i != tail())
 397       {
 398          position.x = margins ? margins->left : 0;
 399          position.y += baseLineSkip;
 400          baseLine = m_FontPtSize;
 401          objBaseLine = baseLine; // not all objects set it
 402          baseLineSkip = (BASELINESTRETCH * baseLine)/10;
 403          headOfLine = i;
 404          headOfLine++;
 405          position_HeadOfLine = position;
 406       }
 407       if(i == m_CursorObject)
 408          CalculateCursor(dc);
 409       i++;
 410    }
 411    while(i != end());
 412    m_MaxY = position.y + baseLineSkip;
 413 }
 414
 415 void
 416 wxLayoutList::Draw(wxDC &dc,
 417                    CoordType fromLine, CoordType toLine,
 418                    iterator start,
 419                    wxPoint const &translate)
 420 {
 421    //Layout(dc); // FIXME just for now
 422
 423    ResetSettings(dc);
 424
 425    wxLayoutObjectList::iterator i;
 426
 427    if(start == iterator(NULL))
 428       start = begin();
 429    else // we need to restore font settings
 430    {
 431       for( i = begin() ; i != start; i++)
 432          if((**i).GetType() == WXLO_TYPE_CMD)
 433             (**i).Draw(dc,translate);  // apply font settings
 434    }
 435
 436    while( start != end() && (**start).GetPosition().y < fromLine)
 437    {
 438       if((**start).GetType() == WXLO_TYPE_CMD)
 439          (**start).Draw(dc,translate);  // apply font settings
 440       start++;
 441    }
 442    for( i = start ;
 443         i != end() && (toLine == -1 || (**i).GetPosition().y < toLine) ;
 444         i++ )
 445       (*i)->Draw(dc,translate);
 446 }
 447
 448 /** Erase at least to end of line */
 449 void
 450 wxLayoutList::EraseAndDraw(wxDC &dc, iterator start, wxPoint const &translate)
 451 {
 452    //look for begin of line
 453    while(start != end() && start != begin() && (**start).GetType() !=
 454          WXLO_TYPE_LINEBREAK)
 455       start--;
 456    if(start == iterator(NULL))
 457       start = begin();
 458    if(start == iterator(NULL))
 459       return;
 460
 461    wxPoint p = (**start).GetPosition();
 462
 463    //FIXME: wxGTK: MaxX()/MaxY() broken
 464    //WXL_VAR(dc.MaxX()); WXL_VAR(dc.MaxY());
 465
 466    dc.SetBrush(wxBrush(*m_ColourBG, wxSOLID));
 467    dc.SetPen(wxPen(*m_ColourBG,0,wxTRANSPARENT));
 468    dc.DrawRectangle(p.x,p.y,2000,2000); //dc.MaxX(),dc.MaxY());
 469    Draw(dc,-1,-1,start,translate);
 470    //dc.DrawRectangle(p.x,p.y,2000,2000); //dc.MaxX(),dc.MaxY());
 471 }
 472
 473
 474 void
 475 wxLayoutList::CalculateCursor(wxDC &dc)
 476 {
 477    if(! m_CursorMoved)
 478       return;
 479
 480    CoordType width, height, descent;
 481    CoordType baseLineSkip = 20; //FIXME
 482
 483    int cursorWidth = m_boldCursor ? 4 : 2;
 484
 485    if( m_CursorObject == iterator(NULL))  // empty list
 486    {
 487       m_CursorCoords = wxPoint(0,0);
 488       m_CursorSize = wxPoint(cursorWidth,baseLineSkip);
 489       m_CursorMoved = false; // coords are valid
 490       return;
 491    }
 492    wxLayoutObjectBase &obj = **m_CursorObject;
 493
 494    m_CursorCoords = obj.GetPosition();
 495    if(obj.GetType() == WXLO_TYPE_TEXT)
 496    {
 497       wxLayoutObjectText *tobj = (wxLayoutObjectText *)&obj;
 498       String & str = tobj->GetText();
 499       String sstr = str.substr(0,m_CursorOffset);
 500       dc.GetTextExtent(sstr,&width,&height,&descent);
 501       m_CursorCoords = wxPoint(m_CursorCoords.x+width,
 502                                m_CursorCoords.y);
 503       m_CursorSize = wxPoint(cursorWidth,height);
 504    }
 505    else if(obj.GetType() == WXLO_TYPE_LINEBREAK)
 506    {
 507       if(m_CursorOffset == 1) // behind linebreak
 508          m_CursorCoords = wxPoint(0, m_CursorCoords.y + baseLineSkip);
 509       //m_CursorCoords = wxPoint(0, m_CursorCoords.y);
 510       m_CursorSize = wxPoint(cursorWidth,baseLineSkip);
 511    }
 512    else
 513    {
 514       // this is not necessarily the most "beautiful" solution:
 515       //cursorPosition = wxPoint(position.x, position.y);
 516       //cursorSize = wxPoint(size.x > 0 ? size.x : 1,size.y > 0 ? size.y : baseLineSkip);
 517       m_CursorCoords = wxPoint(m_CursorCoords.x+obj.GetSize().x, m_CursorCoords.y);
 518       m_CursorSize = wxPoint(cursorWidth, obj.GetSize().y);
 519       if(m_CursorSize.y < 1) m_CursorSize.y = baseLineSkip;
 520    }
 521    m_CursorMoved = false; // coords are valid
 522 }
 523
 524 void
 525 wxLayoutList::DrawCursor(wxDC &dc, bool erase, wxPoint const &translate)
 526 {
 527    if(! m_Editable)
 528       return;
 529
 530    if(erase)
 531       ;
 532 #if 0
 533    dc.Blit(m_CursorCoords.x+translate.x,
 534               m_CursorCoords.y+translate.y,
 535               m_CursorSize.x,m_CursorSize.y,
 536               &m_CursorMemDC,
 537            0, 0, 0, 0);
 538 #endif
 539    else
 540    {
 541       // erase it at the old position:
 542       if(IsDirty() || CursorMoved())
 543       {
 544          // We don't need to erase the cursor because the screen gets
 545          // redrawn completely.
 546 //         DrawCursor(dc,true);
 547          // this is needed to update the cursor coordinates
 548          Layout(dc);
 549       }
 550 #if      0
 551 // Save background:
 552       wxBitmap bm(m_CursorSize.x+1,m_CursorSize.y+1);
 553       m_CursorMemDC.SelectObject(bm);
 554       m_CursorMemDC.Blit(0, 0,
 555                          m_CursorSize.x, m_CursorSize.y,
 556                          &dc,
 557                          m_CursorCoords.x+translate.x,
 558                          m_CursorCoords.y+translate.y, 0, 0);
 559 #endif
 560       // draw it:
 561       dc.SetBrush(*wxBLACK_BRUSH);
 562       dc.SetPen(wxPen(*wxBLACK,1,wxSOLID));
 563       dc.DrawRectangle(m_CursorCoords.x+translate.x, m_CursorCoords.y+translate.y,
 564                        m_CursorSize.x, m_CursorSize.y);
 565    }
 566 }
 567
 568
 569
 570
 571
 572
 573
 574 #ifdef WXLAYOUT_DEBUG
 575 void
 576 wxLayoutList::Debug(void)
 577 {
 578    wxLayoutObjectList::iterator i;
 579
 580    wxLayoutDebug("------------------------ debug start ------------------------");
 581    for(i = begin(); i != end(); i++)
 582       (*i)->Debug();
 583    wxLayoutDebug("-------------------------- list end -------------------------");
 584
 585    // show current object:
 586    ShowCurrentObject();
 587    wxLayoutDebug("------------------------- debug end -------------------------");
 588 }
 589
 590 void
 591 wxLayoutList::ShowCurrentObject()
 592 {
 593    wxLayoutDebug("CursorPos (%d, %d)", (int) m_CursorPos.x, (int) m_CursorPos.y);
 594    wxLayoutDebug("CursorOffset = %d", (int) m_CursorOffset);
 595    wxLayoutDebug("CursorObject = %p", m_CursorObject);
 596    if(m_CursorObject == iterator(NULL))
 597       wxLayoutDebug("<<no object found>>");
 598    else
 599    {
 600       if((*m_CursorObject)->GetType() == WXLO_TYPE_TEXT)
 601          wxLayoutDebug(" \"%s\", offs: %d",
 602                        ((wxLayoutObjectText *)(*m_CursorObject))->GetText().c_str(),
 603                        m_CursorOffset);
 604       else
 605          wxLayoutDebug(" %s", TypeString((*m_CursorObject)->GetType()));
 606    }
 607    wxLayoutDebug("Line length: %d", GetLineLength(m_CursorObject));
 608
 609 }
 610
 611 #endif
 612
 613 /******************** editing stuff ********************/
 614
 615 // don't change this, I know how to optimise this and will do it real
 616 // soon (KB)
 617
 618 /*
 619  * FindObjectCursor:
 620  * Finds the object belonging to a given cursor position cpos and
 621  * returns an iterator to that object and stores the relative cursor
 622  * position in offset.
 623  *
 624  * For linebreaks, the offset can be 0=before or 1=after.
 625  *
 626  * If the cpos coordinates don't exist, they are modified.
 627  */
 628
 629 wxLayoutObjectList::iterator
 630 wxLayoutList::FindObjectCursor(wxPoint *cpos, CoordType *offset)
 631 {
 632    wxPoint object = wxPoint(0,0);  // runs along the objects
 633    CoordType width = 0;
 634    wxLayoutObjectList::iterator i, begin_it;
 635    int go_up;
 636
 637 //#ifdef WXLAYOUT_DEBUG
 638 //   wxLayoutDebug("Looking for object at (%d, %d)", cpos->x, cpos->y);
 639 //#endif
 640
 641    // optimisation: compare to last looked at object:
 642    if(cpos->y > m_FoundCursor.y || (cpos->y == m_FoundCursor.y &&
 643                                     cpos->x >= m_FoundCursor.x))
 644       go_up = 1;
 645    else
 646       go_up = 0;
 647
 648    //broken at the moment
 649    //begin_it = m_FoundIterator;
 650    //m_FoundCursor = *cpos;
 651    begin_it = begin();
 652    go_up = 1;
 653    for(i = begin_it; i != end() && object.y <= cpos->y; )
 654    {
 655       width = (**i).CountPositions();
 656       if(cpos->y == object.y) // a possible candidate
 657       {
 658          if((**i).GetType() ==WXLO_TYPE_LINEBREAK)
 659          {
 660             if(cpos->x == object.x)
 661             {
 662                if(offset) *offset = 0;
 663                return m_FoundIterator = i;
 664             }
 665             if(offset) *offset=1;
 666             cpos->x = object.x;
 667             return m_FoundIterator = i;
 668          }
 669          if(cpos->x >= object.x && cpos->x <= object.x+width) // overlap
 670          {
 671             if(offset) *offset = cpos->x-object.x;
 672 //#ifdef WXLAYOUT_DEBUG
 673 //            wxLayoutDebug("   found object at (%d, %d), type: %s",
 674 //                          object.x,  object.y, TypeString((*i)->GetType()));
 675 //#endif
 676             return m_FoundIterator = i;
 677          }
 678       }
 679       // no overlap, increment coordinates
 680       object.x += width;
 681       if((**i).GetType() == WXLO_TYPE_LINEBREAK)
 682       {
 683          object.x = 0;
 684          object.y++;
 685       }
 686       if(go_up)
 687          i++;
 688       else
 689          i--;
 690    }//for
 691 //#ifdef WXLAYOUT_DEBUG
 692 //   wxLayoutDebug("   not found");
 693 //#endif
 694 // return last object, coordinates of that one:
 695    i = tail();
 696    if(i == end())
 697       return m_FoundIterator = i;
 698    if((**i).GetType()==WXLO_TYPE_LINEBREAK)
 699    {
 700       if(offset)
 701          *offset = 1;
 702       return m_FoundIterator = i;
 703    }
 704    cpos->x = object.x; // would be the coordinate of next object
 705    cpos->y = object.y;
 706    cpos->x += width; // last object's width
 707    if(*offset)  *offset = cpos->x-object.x;
 708    return m_FoundIterator = i; // not found
 709 }
 710
 711 bool
 712 wxLayoutList::MoveCursor(int dx, int dy)
 713 {
 714    CoordType diff;
 715
 716    m_CursorMoved = true;
 717
 718    enum { up, down} direction;
 719
 720    wxPoint newPos = wxPoint(m_CursorPos.x + dx,
 721                             m_CursorPos.y + dy);
 722
 723    // check for bounds
 724    //if(newPos.x < 0) newPos.x = 0;
 725    if(newPos.y < 0) newPos.y = 0;
 726    else if(newPos.y > m_MaxLine) newPos.y = m_MaxLine;
 727
 728    //FIXME: quick and dirty hack: as last object in buffer should be a
 729    // linebreak, we don't allow to go there
 730    if(newPos.y >= m_MaxLine)
 731       return false;
 732
 733    if(newPos.y > m_CursorPos.y ||
 734       newPos.y == m_CursorPos.y &&
 735       newPos.x >= m_CursorPos.x)
 736       direction = down;
 737    else
 738       direction = up;
 739
 740    if ( !m_CursorObject )
 741    {
 742       // list is empty
 743        return FALSE;
 744    }
 745
 746    // now move cursor forwards until at the new position:
 747
 748    // first, go to the right line:
 749    while(newPos.y != m_CursorPos.y)
 750    {
 751       if(direction == down)
 752       {
 753          m_CursorPos.x +=
 754             (**m_CursorObject).CountPositions() - m_CursorOffset;
 755          if(m_CursorObject == tail())
 756             break;  // can't go any further
 757          if((**m_CursorObject).GetType() == WXLO_TYPE_LINEBREAK
 758             && m_CursorOffset == 0)
 759          {
 760             m_CursorPos.y++; m_CursorPos.x = 0;
 761          }
 762          m_CursorObject ++; m_CursorOffset = 0;
 763       }
 764       else // up
 765       {
 766          if(m_CursorObject == begin())
 767             break;  // can't go any further
 768
 769          if((**m_CursorObject).GetType() == WXLO_TYPE_LINEBREAK &&
 770             m_CursorOffset == 1)
 771          {
 772             m_CursorPos.y--;
 773             m_CursorPos.x = GetLineLength(m_CursorObject);
 774          }
 775          m_CursorPos.x -= m_CursorOffset;
 776          m_CursorObject --; m_CursorOffset = (**m_CursorObject).CountPositions();
 777       }
 778    }
 779    if(newPos.y != m_CursorPos.y) // reached begin/end of list,
 780       newPos.y = m_CursorPos.y;  // exited by break
 781
 782    // now line is right, go to right column:
 783    if(dx == 0) // we are moving up or down only
 784    {
 785       int max_x = GetLineLength(m_CursorObject);
 786       if(max_x <= newPos.x)  // ... so we don't want to cross linebreaks
 787          newPos.x = max_x-1; // but just go to the right column
 788    }
 789    direction = newPos.x >= m_CursorPos.x ? down : up;
 790    while(newPos.x != m_CursorPos.x)
 791    {
 792       if(direction == down)
 793       {
 794          diff = newPos.x - m_CursorPos.x;
 795          if(diff > (**m_CursorObject).CountPositions()-m_CursorOffset)
 796          {
 797             m_CursorPos.x +=
 798                (**m_CursorObject).CountPositions()-m_CursorOffset;
 799             if((**m_CursorObject).GetType() == WXLO_TYPE_LINEBREAK &&
 800                m_CursorOffset == 0)
 801                m_CursorPos = wxPoint(0, m_CursorPos.y+1);
 802             if(m_CursorObject == tail())
 803                break; // cannot go further
 804             m_CursorObject++; m_CursorOffset = 0;
 805          }
 806          else
 807          {
 808             if((**m_CursorObject).GetType() == WXLO_TYPE_LINEBREAK)
 809             {
 810                newPos.y++; newPos.x -= m_CursorPos.x+1;
 811                m_CursorPos = wxPoint(0,m_CursorPos.y+1);
 812             }
 813             else
 814                m_CursorPos.x += diff;
 815             m_CursorOffset += diff;
 816          }
 817       }
 818       else // up
 819       {
 820          if(m_CursorPos.x == 0 && m_CursorOffset == 1 &&
 821             (**m_CursorObject).GetType() == WXLO_TYPE_LINEBREAK) // can we go further up?
 822          {
 823             m_CursorPos.y--;
 824             newPos.y--;
 825             m_CursorOffset = 0;
 826             m_CursorPos.x = GetLineLength(m_CursorObject)-1;
 827             newPos.x += m_CursorPos.x+1;
 828             continue;
 829          }
 830          diff = m_CursorPos.x - newPos.x;
 831          if(diff >= m_CursorOffset)
 832          {
 833             if(m_CursorObject == begin())
 834             {
 835                m_CursorOffset = 0;
 836                m_CursorPos.x = 0;
 837                break; // cannot go further
 838             }
 839             m_CursorObject--;
 840             m_CursorPos.x -= m_CursorOffset;
 841             m_CursorOffset = (**m_CursorObject).CountPositions();
 842          }
 843          else
 844          {
 845             m_CursorPos.x -= diff;
 846             m_CursorOffset -= diff;
 847          }
 848       }
 849    }
 850
 851    return true; // FIXME: when return what?
 852 }
 853 void
 854 wxLayoutList::SetCursor(wxPoint const &p)
 855 {
 856    m_CursorPos = p;
 857    m_CursorObject = FindObjectCursor(&m_CursorPos, &m_CursorOffset);
 858    m_CursorMoved = true;
 859 }
 860
 861 void
 862 wxLayoutList::Delete(CoordType count)
 863 {
 864    WXL_TRACE(Delete);
 865
 866    if(!m_Editable)
 867       return;
 868
 869    m_bModified = true;
 870
 871    CoordType offs = 0;
 872    wxLayoutObjectList::iterator i;
 873
 874    do
 875    {
 876       i  = m_CursorObject;
 877    startover: // ugly, but easiest way to do it
 878       if(i == end())
 879          return; // we cannot delete anything more
 880
 881    /* Here we need to treat linebreaks differently.
 882       If m_CursorOffset==0 we are before the linebreak, otherwise behind.  */
 883       if((*i)->GetType() == WXLO_TYPE_LINEBREAK)
 884       {
 885          if(m_CursorOffset == 0)
 886          {
 887             m_MaxLine--;
 888             erase(i);
 889             m_CursorObject = i; // new i!
 890             m_CursorOffset = 0; // Pos unchanged
 891             count--;
 892             continue; // we're done
 893          }
 894          else // delete the object behind the linebreak
 895          {
 896             i++; // we increment and continue as normal
 897             m_CursorOffset=0;
 898             goto startover;
 899          }
 900       }
 901       else if((*i)->GetType() == WXLO_TYPE_TEXT)
 902       {
 903          wxLayoutObjectText *tobj = (wxLayoutObjectText *)*i;
 904          CoordType len = tobj->CountPositions();
 905          /* If we find the end of a text object, this means that we
 906             have to delete from the object following it. */
 907          if(len == m_CursorOffset)
 908          {
 909             i++;
 910             m_CursorOffset = 0;
 911             goto startover;
 912          }
 913          else
 914          {
 915             if(m_CursorOffset == 0 && len <= count) // delete this object
 916             {
 917                count -= len;
 918                erase(i);
 919                m_CursorObject = i;
 920                m_CursorOffset = 0;
 921                continue;
 922             }
 923
 924             int todelete = count;
 925             if(todelete > len-m_CursorOffset)
 926                todelete = len-m_CursorOffset;
 927
 928             len = len - todelete;
 929             tobj->GetText().erase(m_CursorOffset,todelete);
 930             count -= todelete;
 931             // cursor unchanged
 932             return; // we are done
 933          }
 934       }
 935       else// all other objects: delete the object
 936 // this only works as expected  if the non-text object has 0/1
 937 // as offset values. Not tested with "longer" objects.
 938       {
 939          CoordType len = (*i)->CountPositions();
 940          if(offs == 0)
 941          {
 942             count = count > len ? count -= len : 0;
 943             erase(i); // after this, i is the iterator for the
 944                       // following object
 945             m_CursorObject = i;
 946             m_CursorOffset = 0;
 947             continue;
 948          }
 949          else // delete the following object
 950          {
 951             i++; // we increment and continue as normal
 952             m_CursorOffset=0;
 953             goto startover;
 954          }
 955       }
 956    }
 957    while(count && i != end());
 958 }
 959
 960
 961 void
 962 wxLayoutList::Insert(wxLayoutObjectBase *obj)
 963 {
 964    wxCHECK_RET( obj, "no object to insert" );
 965
 966    m_bModified = true;
 967
 968    wxLayoutObjectList::iterator i = m_CursorObject;
 969
 970    if(i != iterator(NULL) && (*obj).GetType() == WXLO_TYPE_LINEBREAK)
 971    {
 972       m_CursorPos.x = 0; m_CursorPos.y ++;
 973    }
 974
 975    if(i == end())
 976    {
 977       push_back(obj);
 978       m_CursorObject = tail();
 979    }
 980    else if(m_CursorOffset == 0)
 981    {
 982       insert(i,obj);
 983       m_CursorObject = i;
 984    }
 985    // do we have to split a text object?
 986    else if((*i)->GetType() == WXLO_TYPE_TEXT && m_CursorOffset != (*i)->CountPositions())
 987    {
 988       wxLayoutObjectText *tobj = (wxLayoutObjectText *) *i;
 989       String left = tobj->GetText().substr(0,m_CursorOffset); // get part before cursor
 990       tobj->GetText() = tobj->GetText().substr(m_CursorOffset,(*i)->CountPositions()-m_CursorOffset); // keeps the right half
 991       insert(i,obj);
 992       m_CursorObject = i; // == obj
 993       insert(i,new wxLayoutObjectText(left)); // inserts before
 994    }
 995    else
 996    {
 997       // all other cases, append after object:
 998       wxLayoutObjectList::iterator j = i; // we want to apend after this object
 999       j++;
1000       if(j != end())
1001       {
1002          insert(j, obj);
1003          m_CursorObject = j;
1004       }
1005       else
1006       {
1007          push_back(obj);
1008          m_CursorObject = tail();
1009       }
1010    }
1011
1012    if(obj->GetType() != WXLO_TYPE_LINEBREAK) // handled separately above
1013       m_CursorPos.x += obj->CountPositions();
1014    // applies also for linebreak:
1015    m_CursorOffset = obj->CountPositions();
1016
1017    if(obj->GetType() == WXLO_TYPE_LINEBREAK)
1018       m_MaxLine++;
1019    m_CursorMoved = true;
1020 }
1021
1022 void
1023 wxLayoutList::Insert(String const &text)
1024 {
1025    wxLayoutObjectText *tobj = NULL;
1026    wxLayoutObjectList::iterator j;
1027
1028 //   WXL_TRACE(Insert(text));
1029
1030    if(! m_Editable)
1031       return;
1032
1033    m_bModified = true;
1034
1035    wxLayoutObjectList::iterator i = m_CursorObject;
1036
1037    if(i == end())
1038    {
1039       Insert(new wxLayoutObjectText(text));
1040       return;
1041    }
1042
1043    switch((**i).GetType())
1044    {
1045    case WXLO_TYPE_TEXT:
1046 // insert into an existing text object:
1047       tobj = (wxLayoutObjectText *)*i ;
1048       wxASSERT(tobj);
1049       tobj->GetText().insert(m_CursorOffset,text);
1050       m_CursorObject = i;
1051       m_CursorOffset = m_CursorOffset + text.length();
1052       m_CursorPos.x += text.length();
1053       break;
1054    case WXLO_TYPE_LINEBREAK:
1055    default:
1056       j = i;
1057       if(m_CursorOffset == 0) // try to append to previous object
1058       {
1059          j--;
1060          if(j != end() && (**j).GetType() == WXLO_TYPE_TEXT)
1061          {
1062             tobj = (wxLayoutObjectText *)*j;
1063             tobj->GetText()+=text;
1064             m_CursorObject = j;
1065             m_CursorOffset = (**j).CountPositions();
1066             m_CursorPos.x += text.length();
1067          }
1068          else
1069          {
1070             insert(i,new wxLayoutObjectText(text));
1071             m_CursorObject = i;
1072             m_CursorOffset = (**i).CountPositions();
1073             m_CursorPos.x += m_CursorOffset;
1074          }
1075       }
1076       else // offset == 1 : cursor after linebreak
1077       {
1078          j++;
1079          m_CursorObject = j;
1080          m_CursorOffset = 0;
1081          if(j != end() && (**j).GetType() == WXLO_TYPE_TEXT)
1082          {
1083             tobj = (wxLayoutObjectText *)*j;
1084             tobj->GetText()=text+tobj->GetText();
1085             m_CursorOffset = text.length();
1086             m_CursorPos.x += m_CursorOffset;
1087          }
1088          else
1089          {
1090             if(j == end())
1091             {
1092                push_back(new wxLayoutObjectText(text));
1093                m_CursorObject = tail();
1094                m_CursorOffset = (**m_CursorObject).CountPositions();
1095                m_CursorPos.x += text.length();
1096             }
1097             else
1098             {
1099                insert(j,new wxLayoutObjectText(text));
1100                m_CursorObject = j;
1101                m_CursorOffset = (**j).CountPositions();
1102                m_CursorPos.x += text.length();
1103             }
1104          }
1105       }
1106       break;
1107    }
1108    m_CursorMoved = true;
1109 }
1110
1111 CoordType
1112 wxLayoutList::GetLineLength(wxLayoutObjectList::iterator i, CoordType offs)
1113 {
1114    if(i == end())
1115       return 0;
1116
1117    CoordType len = 0;
1118
1119    if(offs == 0 && (**i).GetType() == WXLO_TYPE_LINEBREAK)
1120       if(i != begin())
1121          i--;
1122       else
1123          return 0; // at begin of buffer in front of a linebreak
1124
1125 // search backwards for beginning of line:
1126    while(i != begin() && (*i)->GetType() != WXLO_TYPE_LINEBREAK)
1127       i--;
1128    if((*i)->GetType() == WXLO_TYPE_LINEBREAK)
1129       i++;
1130 // now we can start counting:
1131    while(i != end() && (*i)->GetType() != WXLO_TYPE_LINEBREAK)
1132    {
1133       len += (*i)->CountPositions();
1134       i++;
1135    }
1136    len++; // one extra for the linebreak
1137    return len;
1138 }
1139
1140 void
1141 wxLayoutList::Clear(int family, int size, int style, int weight,
1142                     int underline, char const *fg, char const *bg)
1143 {
1144    m_bModified = true;
1145    m_CursorMoved = true;
1146    m_dirty = true;  // force redraw/recalc
1147    wxLayoutObjectList::iterator i = begin();
1148
1149    wxBitmap bm(4,4);
1150    m_CursorMemDC.SelectObject(bm);
1151
1152    while(i != end()) // == while valid
1153       erase(i);
1154
1155    // set defaults
1156    m_FontPtSize = size;
1157    m_FontUnderline = false;
1158    m_FontFamily = family;
1159    m_FontStyle = style;
1160    m_FontWeight = weight;
1161    m_ColourFG = wxTheColourDatabase->FindColour(fg);
1162    m_ColourBG = wxTheColourDatabase->FindColour(bg);
1163
1164    if(! m_ColourFG) m_ColourFG = wxBLACK;
1165    if(! m_ColourBG) m_ColourBG = wxWHITE;
1166
1167    m_Position = wxPoint(0,0);
1168    m_CursorPos = wxPoint(0,0);
1169    m_CursorObject = iterator(NULL);
1170    m_CursorOffset = 0;
1171    m_CursorSize = wxPoint(2,(BASELINESTRETCH*m_FontPtSize)/10);
1172
1173    m_MaxLine = 0;
1174    m_LineHeight = (BASELINESTRETCH*m_FontPtSize)/10;
1175    m_MaxX = 0; m_MaxY = 0;
1176
1177
1178    m_FoundCursor = wxPoint(0,0);
1179    m_FoundIterator = begin();
1180
1181    if(m_DefaultSetting)
1182       delete m_DefaultSetting;
1183
1184    m_DefaultSetting = new
1185       wxLayoutObjectCmd(m_FontPtSize,m_FontFamily,m_FontStyle,
1186                         m_FontWeight,m_FontUnderline,
1187                         m_ColourFG, m_ColourBG);
1188 }
1189
1190
1191 wxLayoutObjectBase *
1192 wxLayoutList::Find(wxPoint coords) const
1193 {
1194    wxLayoutObjectList::iterator i = begin();
1195
1196    wxPoint topleft, bottomright;
1197
1198    while(i != end()) // == while valid
1199    {
1200       wxLayoutObjectBase *object = *i;
1201       topleft = object->GetPosition();
1202       if(coords.y >= topleft.y && coords.x >= topleft.x)
1203       {
1204          bottomright = topleft;
1205          bottomright.x += object->GetSize().x;
1206          bottomright.y += object->GetSize().y;
1207          if(coords.x <= bottomright.x && coords.y <= bottomright.y)
1208             return *i;
1209       }
1210       i++;
1211    }
1212    return NULL;
1213 }
1214
1215
1216 void
1217 wxLayoutList::SetWrapMargin(long n)
1218 {
1219    m_WrapMargin = n;
1220 }
1221
1222 void
1223 wxLayoutList::WrapLine(void)
1224 {
1225    wxASSERT(m_CursorObject);
1226
1227    iterator i = m_CursorObject;
1228
1229    if(!DoWordWrap() || !i ) // empty list
1230       return;
1231    int cursorpos = m_CursorPos.x, cpos, offset;
1232
1233    if(cursorpos < m_WrapMargin)
1234       return;
1235
1236    // else: break line
1237
1238    // find the right object to break:
1239    // is it the current one?
1240
1241    i = m_CursorObject;
1242    cpos = cursorpos-m_CursorOffset;
1243    while(i != begin() && cpos >= m_WrapMargin)
1244    {
1245       i--;
1246       cpos -= (**i).CountPositions();
1247    }
1248    // now i is the object to break and cpos its position
1249
1250    offset = m_WrapMargin - cpos;
1251    wxASSERT(offset <= (**i).CountPositions());
1252
1253    // split it
1254    if((**i).GetType() == WXLO_TYPE_TEXT)
1255    {
1256       wxLayoutObjectText &t = *(wxLayoutObjectText *)*i;
1257       for(; offset > 0; offset--)
1258          if(t.GetText().c_str()[offset] == ' ' || t.GetText().c_str()[offset] == '\t')
1259          {
1260             String left = t.GetText().substr(0,offset); // get part before cursor
1261             t.GetText() = t.GetText().substr(offset+1,t.CountPositions()-offset-1); // keeps the right halve
1262             insert(i,new wxLayoutObjectLineBreak);
1263             insert(i,new wxLayoutObjectText(left)); // inserts before
1264             break;
1265          }
1266       if(offset == 0)
1267       {
1268          // only insert a line break if there  isn't already one
1269          iterator j = i; j--;
1270          if(j && j != begin() && (**j).GetType() != WXLO_TYPE_LINEBREAK)
1271             insert(i,new wxLayoutObjectLineBreak);
1272          else
1273             return; // do nothing
1274       }
1275    }
1276    else
1277       insert(i,new wxLayoutObjectLineBreak);
1278    m_MaxLine++;
1279    m_CursorPos.y++;
1280    m_CursorPos.x -= offset;
1281    m_CursorOffset -= offset;
1282 }
1283 /******************** printing stuff ********************/
1284
1285 wxLayoutPrintout::wxLayoutPrintout(wxLayoutList &llist,
1286                                    wxString const & title)
1287 :wxPrintout(title)
1288 {
1289    m_llist = &llist;
1290    m_title = title;
1291 }
1292
1293 bool wxLayoutPrintout::OnPrintPage(int page)
1294 {
1295    wxDC *dc = GetDC();
1296    if (dc)
1297    {
1298       DrawHeader(*dc,wxPoint(m_Margins.left,m_Margins.top/2),wxPoint(m_Margins.right,m_Margins.top),page);
1299       int top, bottom;
1300       top = (page - 1)*m_PrintoutHeight;
1301       bottom = top + m_PrintoutHeight;
1302       // SetDeviceOrigin() doesn't work here, so we need to manually
1303       // translate all coordinates.
1304       wxPoint translate(m_Margins.left,-top+m_Margins.top);
1305       m_llist->Draw(*dc,top,bottom,wxLayoutObjectList::iterator(NULL),translate);
1306       return true;
1307    }
1308    else
1309       return false;
1310 }
1311
1312 bool wxLayoutPrintout::OnBeginDocument(int startPage, int endPage)
1313 {
1314    if (!wxPrintout::OnBeginDocument(startPage, endPage))
1315     return false;
1316
1317   return true;
1318 }
1319
1320 void
1321 wxLayoutPrintout::OnPreparePrinting(void)
1322 {
1323
1324 }
1325
1326
1327 void wxLayoutPrintout::GetPageInfo(int *minPage, int *maxPage, int *selPageFrom, int *selPageTo)
1328 {
1329    // ugly hack to get number of pages
1330 #ifdef __WXMSW__
1331    wxPrinterDC psdc("","",WXLLIST_TEMPFILE,false);
1332 #else
1333    wxPostScriptDC psdc(WXLLIST_TEMPFILE,false);
1334 #endif
1335    psdc.GetSize(&m_PageWidth, &m_PageHeight); // that's all we need it for
1336
1337    // We do 5% margins on top and bottom, and a 5% high header line.
1338    m_Margins.top = m_PageHeight / 10 ;      // 10%, half of it header
1339    m_Margins.bottom = m_PageHeight - m_PageHeight / 20;   // 95%
1340    // On the sides we reserve 10% each for the margins.
1341    m_Margins.left = m_PageWidth / 10;
1342    m_Margins.right = m_PageWidth - m_PageWidth / 10;
1343
1344    // This is the length of the printable area.
1345    m_PrintoutHeight = m_PageHeight - (int) (m_PageHeight * 0.15);
1346
1347    //FIXME this is wrong but not used at the moment
1348    m_PageWidth = m_Margins.right - m_Margins.left;
1349
1350    m_NumOfPages = (int)( m_llist->GetSize().y / (float)(m_PrintoutHeight) + 0.5);
1351    *minPage = 1;
1352    *maxPage = m_NumOfPages;
1353
1354    *selPageFrom = 1;
1355    *selPageTo = m_NumOfPages;
1356    wxRemoveFile(WXLLIST_TEMPFILE);
1357 }
1358
1359 bool wxLayoutPrintout::HasPage(int pageNum)
1360 {
1361    return pageNum <= m_NumOfPages;
1362 }
1363
1364
1365 void
1366 wxLayoutPrintout::DrawHeader(wxDC &dc,
1367                              wxPoint topleft, wxPoint bottomright,
1368                              int pageno)
1369 {
1370    // make backups of all essential parameters
1371    const wxBrush& brush = dc.GetBrush();
1372    const wxPen&   pen = dc.GetPen();
1373    const wxFont&  font = dc.GetFont();
1374
1375    dc.SetBrush(*wxWHITE_BRUSH);
1376    dc.SetPen(wxPen(*wxBLACK,0,wxSOLID));
1377    dc.DrawRoundedRectangle(topleft.x,
1378                            topleft.y,bottomright.x-topleft.x,
1379                            bottomright.y-topleft.y);
1380    dc.SetBrush(*wxBLACK_BRUSH);
1381    wxFont myfont = wxFont((WXLO_DEFAULTFONTSIZE*12)/10,
1382                           wxSWISS,wxNORMAL,wxBOLD,false,"Helvetica");
1383    dc.SetFont(myfont);
1384
1385    wxString page;
1386    page = "9999/9999  ";  // many pages...
1387    long w,h;
1388    dc.GetTextExtent(page,&w,&h);
1389    page.Printf("%d/%d", pageno, (int) m_NumOfPages);
1390    dc.DrawText(page,bottomright.x-w,topleft.y+h/2);
1391    dc.GetTextExtent("XXXX", &w,&h);
1392    dc.DrawText(m_title, topleft.x+w,topleft.y+h/2);
1393
1394    // restore settings
1395    dc.SetPen(pen);
1396    dc.SetBrush(brush);
1397    dc.SetFont(font);
1398 }
1399
1400
1401 wxLayoutPrintout *
1402 wxLayoutList::MakePrintout(wxString const &name)
1403 {
1404    return new wxLayoutPrintout(*this,name);
1405 }