src/html/m_layout.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/html/m_layout.cpp
   3 // Purpose:     wxHtml module for basic paragraphs/layout handling
   4 // Author:      Vaclav Slavik
   5 // Copyright:   (c) 1999 Vaclav Slavik
   6 // Licence:     wxWindows licence
   7 /////////////////////////////////////////////////////////////////////////////
   8
   9 #include "wx/wxprec.h"
  10
  11 #ifdef __BORLANDC__
  12     #pragma hdrstop
  13 #endif
  14
  15 #if wxUSE_HTML && wxUSE_STREAMS
  16
  17 #ifndef WX_PRECOMP
  18     #include "wx/image.h"
  19 #endif
  20
  21 #include "wx/html/forcelnk.h"
  22 #include "wx/html/m_templ.h"
  23
  24 #include "wx/html/htmlwin.h"
  25
  26 FORCE_LINK_ME(m_layout)
  27
  28 #ifdef __WXWINCE__
  29     #include "wx/msw/wince/missing.h"       // for bsearch()
  30 #else
  31     #include <stdlib.h>                     // bsearch()
  32 #endif
  33
  34 //-----------------------------------------------------------------------------
  35 // wxHtmlPageBreakCell
  36 //-----------------------------------------------------------------------------
  37
  38 // Since html isn't a page-layout language, it doesn't support page
  39 // page breaks directly--that requires CSS2 support. But a page-break
  40 // facility is handy, and has been requested more than once on the
  41 // mailing lists. This wxHtml tag handler implements just enough of
  42 // CSS2 to support a page break by recognizing only
  43 //   <div style="page-break-before:always">
  44 //
  45 // wxHtml maintains page breaks in wxHtmlPrintout::m_PageBreaks. The
  46 // tag handler below adds appropriate offsets to that array member.
  47 // wxHtmlDCRenderer::Render() accesses that array and makes a new page
  48 // begin after each page-break tag.
  49
  50 // The page-break handler does all its work in AdjustPagebreak(). For
  51 // all tag handlers, that function adjusts the page-break position.
  52 // For other tags, it determines whether the html element can fit on
  53 // the remainder of the page; if it cannot fit, but must not be split,
  54 // then the function moves the page break provided in the argument up,
  55 // and returns 'true' to inform the caller that the argument was
  56 // modified.
  57 //
  58 // Due to its special purpose, the page-break facility differs from
  59 // other tags. It takes up no space, but it behaves as though there is
  60 // never enough room to fit it on the remainder of the page--it always
  61 // forces a page break. Therefore, unlike other elements that trigger
  62 // a page break, it would never 'fit' on the following page either.
  63 // Therefore it's necessary to compare each pagebreak candidate to the
  64 // array wxHtmlPrintout::m_PageBreaks of pagebreaks already set, and
  65 // set a new one only if it's not in that array.
  66
  67 class wxHtmlPageBreakCell : public wxHtmlCell
  68 {
  69 public:
  70     wxHtmlPageBreakCell() {}
  71
  72     bool AdjustPagebreak(int* pagebreak,
  73                          const wxArrayInt& known_pagebreaks,
  74                          int pageHeight) const;
  75
  76     void Draw(wxDC& WXUNUSED(dc),
  77               int WXUNUSED(x), int WXUNUSED(y),
  78               int WXUNUSED(view_y1), int WXUNUSED(view_y2),
  79               wxHtmlRenderingInfo& WXUNUSED(info)) {}
  80
  81 private:
  82     wxDECLARE_NO_COPY_CLASS(wxHtmlPageBreakCell);
  83 };
  84
  85 bool
  86 wxHtmlPageBreakCell::AdjustPagebreak(int* pagebreak,
  87                                      const wxArrayInt& known_pagebreaks,
  88                                      int WXUNUSED(pageHeight)) const
  89 {
  90     // When we are counting pages, 'known_pagebreaks' is non-NULL.
  91     // That's the only time we change 'pagebreak'. Otherwise, pages
  92     // were already counted, 'known_pagebreaks' is NULL, and we don't
  93     // do anything except return false.
  94     //
  95     // We also simply return false if the 'pagebreak' argument is
  96     // less than (vertically above) or the same as the current
  97     // vertical position. Otherwise we'd be setting a pagebreak above
  98     // the current cell, which is incorrect, or duplicating a
  99     // pagebreak that has already been set.
 100     if( known_pagebreaks.GetCount() == 0 || *pagebreak <= m_PosY)
 101     {
 102         return false;
 103     }
 104
 105     // m_PosY is only the vertical offset from the parent. The pagebreak
 106     // required here is the total page offset, so m_PosY must be added
 107     // to the parent's offset and height.
 108     int total_height = m_PosY;
 109     for ( wxHtmlCell *parent = GetParent(); parent; parent = parent->GetParent() )
 110     {
 111         total_height += parent->GetPosY();
 112     }
 113
 114
 115     // Search the array of pagebreaks to see whether we've already set
 116     // a pagebreak here.
 117     int where = known_pagebreaks.Index( total_height);
 118     // Add a pagebreak only if there isn't one already set here.
 119     if( wxNOT_FOUND != where)
 120     {
 121         return false;
 122     }
 123     else
 124     {
 125         *pagebreak = m_PosY;
 126         return true;
 127     }
 128 }
 129
 130
 131
 132 TAG_HANDLER_BEGIN(P, "P")
 133     TAG_HANDLER_CONSTR(P) { }
 134
 135     TAG_HANDLER_PROC(tag)
 136     {
 137         if (m_WParser->GetContainer()->GetFirstChild() != NULL)
 138         {
 139             m_WParser->CloseContainer();
 140             m_WParser->OpenContainer();
 141         }
 142         m_WParser->GetContainer()->SetIndent(m_WParser->GetCharHeight(), wxHTML_INDENT_TOP);
 143         m_WParser->GetContainer()->SetAlign(tag);
 144         return false;
 145     }
 146
 147 TAG_HANDLER_END(P)
 148
 149
 150
 151 TAG_HANDLER_BEGIN(BR, "BR")
 152     TAG_HANDLER_CONSTR(BR) { }
 153
 154     TAG_HANDLER_PROC(tag)
 155     {
 156         int al = m_WParser->GetContainer()->GetAlignHor();
 157         wxHtmlContainerCell *c;
 158
 159         m_WParser->CloseContainer();
 160         c = m_WParser->OpenContainer();
 161         c->SetAlignHor(al);
 162         c->SetAlign(tag);
 163         c->SetMinHeight(m_WParser->GetCharHeight());
 164         return false;
 165     }
 166
 167 TAG_HANDLER_END(BR)
 168
 169
 170
 171 TAG_HANDLER_BEGIN(CENTER, "CENTER")
 172     TAG_HANDLER_CONSTR(CENTER) { }
 173
 174     TAG_HANDLER_PROC(tag)
 175     {
 176         int old = m_WParser->GetAlign();
 177         wxHtmlContainerCell *c = m_WParser->GetContainer();
 178
 179         m_WParser->SetAlign(wxHTML_ALIGN_CENTER);
 180         if (c->GetFirstChild() != NULL)
 181         {
 182             m_WParser->CloseContainer();
 183             m_WParser->OpenContainer();
 184         }
 185         else
 186             c->SetAlignHor(wxHTML_ALIGN_CENTER);
 187
 188         if (tag.HasEnding())
 189         {
 190             ParseInner(tag);
 191
 192             m_WParser->SetAlign(old);
 193             if (c->GetFirstChild() != NULL)
 194             {
 195                 m_WParser->CloseContainer();
 196                 m_WParser->OpenContainer();
 197             }
 198             else
 199                 c->SetAlignHor(old);
 200
 201             return true;
 202         }
 203         else return false;
 204     }
 205
 206 TAG_HANDLER_END(CENTER)
 207
 208
 209
 210 TAG_HANDLER_BEGIN(DIV, "DIV")
 211     TAG_HANDLER_CONSTR(DIV) { }
 212
 213     TAG_HANDLER_PROC(tag)
 214     {
 215         if(tag.HasParam(wxT("STYLE")))
 216         {
 217             if(tag.GetParam(wxT("STYLE")).IsSameAs(wxT("PAGE-BREAK-BEFORE:ALWAYS"), false))
 218             {
 219                 m_WParser->CloseContainer();
 220                 m_WParser->OpenContainer()->InsertCell(new wxHtmlPageBreakCell);
 221                 m_WParser->CloseContainer();
 222                 m_WParser->OpenContainer();
 223                 return false;
 224             }
 225             else
 226             {
 227                 // Treat other STYLE parameters here when they're supported.
 228                 return false;
 229             }
 230         }
 231         else if(tag.HasParam(wxT("ALIGN")))
 232         {
 233             int old = m_WParser->GetAlign();
 234             wxHtmlContainerCell *c = m_WParser->GetContainer();
 235             if (c->GetFirstChild() != NULL)
 236             {
 237                 m_WParser->CloseContainer();
 238                 m_WParser->OpenContainer();
 239                 c = m_WParser->GetContainer();
 240                 c->SetAlign(tag);
 241                 m_WParser->SetAlign(c->GetAlignHor());
 242             }
 243             else
 244             {
 245                 c->SetAlign(tag);
 246                 m_WParser->SetAlign(c->GetAlignHor());
 247             }
 248
 249             ParseInner(tag);
 250
 251             m_WParser->SetAlign(old);
 252             if (c->GetFirstChild() != NULL)
 253             {
 254                 m_WParser->CloseContainer();
 255                 m_WParser->OpenContainer();
 256             }
 257             else
 258                 c->SetAlignHor(old);
 259
 260             return true;
 261         }
 262         else
 263         {
 264             // Same as BR
 265             int al = m_WParser->GetContainer()->GetAlignHor();
 266             wxHtmlContainerCell *c;
 267
 268             m_WParser->CloseContainer();
 269             c = m_WParser->OpenContainer();
 270             c->SetAlignHor(al);
 271             c->SetAlign(tag);
 272             c->SetMinHeight(m_WParser->GetCharHeight());
 273             return false;
 274         }
 275     }
 276
 277 TAG_HANDLER_END(DIV)
 278
 279
 280
 281
 282 TAG_HANDLER_BEGIN(TITLE, "TITLE")
 283     TAG_HANDLER_CONSTR(TITLE) { }
 284
 285     TAG_HANDLER_PROC(tag)
 286     {
 287         wxHtmlWindowInterface *winIface = m_WParser->GetWindowInterface();
 288         if (winIface)
 289         {
 290             wxString title(tag.GetBeginIter(), tag.GetEndIter1());
 291 #if !wxUSE_UNICODE
 292             const wxFontEncoding enc = m_WParser->GetInputEncoding();
 293             if ( enc != wxFONTENCODING_DEFAULT )
 294             {
 295                 // need to convert to the current one
 296                 title = wxString(title.wc_str(wxCSConv(enc)), wxConvLocal);
 297             }
 298 #endif // !wxUSE_UNICODE
 299
 300             title = m_WParser->GetEntitiesParser()->Parse(title);
 301
 302             winIface->SetHTMLWindowTitle(title);
 303         }
 304         return true;
 305     }
 306
 307 TAG_HANDLER_END(TITLE)
 308
 309
 310
 311
 312 TAG_HANDLER_BEGIN(BODY, "BODY")
 313     TAG_HANDLER_CONSTR(BODY) { }
 314
 315     TAG_HANDLER_PROC(tag)
 316     {
 317         wxColour clr;
 318
 319         if (tag.GetParamAsColour(wxT("TEXT"), &clr))
 320         {
 321             m_WParser->SetActualColor(clr);
 322             m_WParser->GetContainer()->InsertCell(new wxHtmlColourCell(clr));
 323         }
 324
 325         if (tag.GetParamAsColour(wxT("LINK"), &clr))
 326             m_WParser->SetLinkColor(clr);
 327
 328         wxHtmlWindowInterface *winIface = m_WParser->GetWindowInterface();
 329         // the rest of this function requires a window:
 330         if ( !winIface )
 331             return false;
 332
 333         if (tag.HasParam(wxT("BACKGROUND")))
 334         {
 335             wxFSFile *fileBgImage = m_WParser->OpenURL
 336                                                (
 337                                                 wxHTML_URL_IMAGE,
 338                                                 tag.GetParam(wxT("BACKGROUND"))
 339                                                );
 340             if ( fileBgImage )
 341             {
 342                 wxInputStream *is = fileBgImage->GetStream();
 343                 if ( is )
 344                 {
 345                     wxImage image(*is);
 346                     if ( image.IsOk() )
 347                         winIface->SetHTMLBackgroundImage(image);
 348                 }
 349
 350                 delete fileBgImage;
 351             }
 352         }
 353
 354         if (tag.GetParamAsColour(wxT("BGCOLOR"), &clr))
 355         {
 356             m_WParser->GetContainer()->InsertCell(
 357                 new wxHtmlColourCell(clr, wxHTML_CLR_TRANSPARENT_BACKGROUND));
 358             winIface->SetHTMLBackgroundColour(clr);
 359         }
 360
 361         return false;
 362     }
 363
 364 TAG_HANDLER_END(BODY)
 365
 366
 367
 368 TAG_HANDLER_BEGIN(BLOCKQUOTE, "BLOCKQUOTE")
 369     TAG_HANDLER_CONSTR(BLOCKQUOTE) { }
 370
 371     TAG_HANDLER_PROC(tag)
 372     {
 373         wxHtmlContainerCell *c;
 374
 375         m_WParser->CloseContainer();
 376         c = m_WParser->OpenContainer();
 377
 378         if (c->GetAlignHor() == wxHTML_ALIGN_RIGHT)
 379             c->SetIndent(5 * m_WParser->GetCharWidth(), wxHTML_INDENT_RIGHT);
 380         else
 381             c->SetIndent(5 * m_WParser->GetCharWidth(), wxHTML_INDENT_LEFT);
 382
 383         c->SetIndent(m_WParser->GetCharHeight(), wxHTML_INDENT_TOP);
 384         m_WParser->OpenContainer();
 385         ParseInner(tag);
 386         c = m_WParser->CloseContainer();
 387         c->SetIndent(m_WParser->GetCharHeight(), wxHTML_INDENT_BOTTOM);
 388         m_WParser->CloseContainer();
 389         m_WParser->OpenContainer();
 390         return true;
 391     }
 392
 393 TAG_HANDLER_END(BLOCKQUOTE)
 394
 395
 396
 397 TAG_HANDLER_BEGIN(SUBSUP, "SUB,SUP")
 398
 399     TAG_HANDLER_PROC(tag)
 400     {
 401         bool issub = (tag.GetName() == wxT("SUB"));
 402         wxHtmlScriptMode oldmode = m_WParser->GetScriptMode();
 403         int oldbase = m_WParser->GetScriptBaseline();
 404         int oldsize = m_WParser->GetFontSize();
 405
 406         wxHtmlContainerCell *cont = m_WParser->GetContainer();
 407         wxHtmlCell *c = cont->GetLastChild();
 408
 409         m_WParser->SetScriptMode(issub ? wxHTML_SCRIPT_SUB : wxHTML_SCRIPT_SUP);
 410         m_WParser->SetScriptBaseline(
 411                 oldbase + c ? c->GetScriptBaseline() : 0);
 412
 413         // select smaller font
 414         m_WParser->SetFontSize(m_WParser->GetFontSize()-2);
 415         cont->InsertCell(new wxHtmlFontCell(m_WParser->CreateCurrentFont()));
 416
 417         ParseInner(tag);
 418
 419         // restore font size
 420         m_WParser->SetFontSize(oldsize);
 421         m_WParser->GetContainer()->InsertCell(
 422             new wxHtmlFontCell(m_WParser->CreateCurrentFont()));
 423
 424         // restore base and alignment
 425         m_WParser->SetScriptBaseline(oldbase);
 426         m_WParser->SetScriptMode(oldmode);
 427
 428         return true;
 429     }
 430
 431 TAG_HANDLER_END(SUBSUP)
 432
 433
 434 // Tag handler for tags that we have to ignore, otherwise non-text data
 435 // would show up as text:
 436 TAG_HANDLER_BEGIN(DoNothing, "SCRIPT")
 437     TAG_HANDLER_CONSTR(DoNothing) { }
 438
 439     TAG_HANDLER_PROC(WXUNUSED(tag))
 440     {
 441         return true;
 442     }
 443 TAG_HANDLER_END(DoNothing)
 444
 445
 446
 447
 448
 449 TAGS_MODULE_BEGIN(Layout)
 450
 451     TAGS_MODULE_ADD(P)
 452     TAGS_MODULE_ADD(BR)
 453     TAGS_MODULE_ADD(CENTER)
 454     TAGS_MODULE_ADD(DIV)
 455     TAGS_MODULE_ADD(TITLE)
 456     TAGS_MODULE_ADD(BODY)
 457     TAGS_MODULE_ADD(BLOCKQUOTE)
 458     TAGS_MODULE_ADD(SUBSUP)
 459     TAGS_MODULE_ADD(DoNothing)
 460
 461 TAGS_MODULE_END(Layout)
 462
 463 #endif