src/html/htmlcell.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        htmlcell.cpp
   3 // Purpose:     wxHtmlCell - basic element of HTML output
   4 // Author:      Vaclav Slavik
   5 // RCS-ID:      $Id$
   6 // Copyright:   (c) 1999 Vaclav Slavik
   7 // Licence:     wxWindows Licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 #ifdef __GNUG__
  11 #pragma implementation
  12 #endif
  13
  14 #include "wx/wxprec.h"
  15
  16 #include "wx/defs.h"
  17
  18 #if wxUSE_HTML && wxUSE_STREAMS
  19
  20 #ifdef __BORDLANDC__
  21 #pragma hdrstop
  22 #endif
  23
  24 #ifndef WXPRECOMP
  25     #include "wx/brush.h"
  26     #include "wx/colour.h"
  27     #include "wx/dc.h"
  28 #endif
  29
  30 #include "wx/html/htmlcell.h"
  31 #include "wx/html/htmlwin.h"
  32 #include <stdlib.h>
  33
  34
  35 //-----------------------------------------------------------------------------
  36 // wxHtmlCell
  37 //-----------------------------------------------------------------------------
  38
  39 wxHtmlCell::wxHtmlCell() : wxObject()
  40 {
  41     m_Next = NULL;
  42     m_Parent = NULL;
  43     m_Width = m_Height = m_Descent = 0;
  44     m_CanLiveOnPagebreak = TRUE;
  45     m_Link = NULL;
  46 }
  47
  48 wxHtmlCell::~wxHtmlCell()
  49 {
  50     if (m_Link) delete m_Link;
  51 }
  52
  53
  54 void wxHtmlCell::OnMouseClick(wxWindow *parent, int x, int y,
  55                               const wxMouseEvent& event)
  56 {
  57     wxHtmlLinkInfo *lnk = GetLink(x, y);
  58     if (lnk != NULL)
  59     {
  60         wxHtmlLinkInfo lnk2(*lnk);
  61         lnk2.SetEvent(&event);
  62         lnk2.SetHtmlCell(this);
  63         ((wxHtmlWindow*)parent)->OnLinkClicked(lnk2);
  64         // note : this overcasting is legal because parent is *always* wxHtmlWindow
  65     }
  66 }
  67
  68
  69
  70 bool wxHtmlCell::AdjustPagebreak(int *pagebreak) const
  71 {
  72     if ((!m_CanLiveOnPagebreak) &&
  73                 m_PosY < *pagebreak && m_PosY + m_Height > *pagebreak)
  74         {
  75         *pagebreak = m_PosY;
  76         return TRUE;
  77     }
  78     else
  79         return FALSE;
  80 }
  81
  82
  83
  84 void wxHtmlCell::SetLink(const wxHtmlLinkInfo& link)
  85 {
  86     if (m_Link) delete m_Link;
  87     m_Link = NULL;
  88     if (link.GetHref() != wxEmptyString)
  89         m_Link = new wxHtmlLinkInfo(link);
  90 }
  91
  92
  93
  94 void wxHtmlCell::Layout(int w)
  95 {
  96     SetPos(0, 0);
  97 }
  98
  99
 100 const wxHtmlCell* wxHtmlCell::Find(int condition, const void* param) const
 101 {
 102     return NULL;
 103 }
 104
 105
 106
 107 //-----------------------------------------------------------------------------
 108 // wxHtmlWordCell
 109 //-----------------------------------------------------------------------------
 110
 111 wxHtmlWordCell::wxHtmlWordCell(const wxString& word, wxDC& dc) : wxHtmlCell()
 112 {
 113     m_Word = word;
 114     dc.GetTextExtent(m_Word, &m_Width, &m_Height, &m_Descent);
 115     SetCanLiveOnPagebreak(FALSE);
 116 }
 117
 118
 119
 120 void wxHtmlWordCell::Draw(wxDC& dc, int x, int y, int view_y1, int view_y2)
 121 {
 122     dc.DrawText(m_Word, x + m_PosX, y + m_PosY);
 123 }
 124
 125
 126
 127 //-----------------------------------------------------------------------------
 128 // wxHtmlContainerCell
 129 //-----------------------------------------------------------------------------
 130
 131
 132 wxHtmlContainerCell::wxHtmlContainerCell(wxHtmlContainerCell *parent) : wxHtmlCell()
 133 {
 134     m_Cells = m_LastCell = NULL;
 135     m_Parent = parent;
 136     if (m_Parent) m_Parent->InsertCell(this);
 137     m_AlignHor = wxHTML_ALIGN_LEFT;
 138     m_AlignVer = wxHTML_ALIGN_BOTTOM;
 139     m_IndentLeft = m_IndentRight = m_IndentTop = m_IndentBottom = 0;
 140     m_WidthFloat = 100; m_WidthFloatUnits = wxHTML_UNITS_PERCENT;
 141     m_UseBkColour = FALSE;
 142     m_UseBorder = FALSE;
 143     m_MinHeight = 0;
 144     m_MinHeightAlign = wxHTML_ALIGN_TOP;
 145     m_LastLayout = -1;
 146 }
 147
 148 wxHtmlContainerCell::~wxHtmlContainerCell()
 149 {
 150     if (m_Cells)
 151     {
 152         for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
 153             delete cell;
 154     }
 155 }
 156
 157
 158
 159 void wxHtmlContainerCell::SetIndent(int i, int what, int units)
 160 {
 161     int val = (units == wxHTML_UNITS_PIXELS) ? i : -i;
 162     if (what & wxHTML_INDENT_LEFT) m_IndentLeft = val;
 163     if (what & wxHTML_INDENT_RIGHT) m_IndentRight = val;
 164     if (what & wxHTML_INDENT_TOP) m_IndentTop = val;
 165     if (what & wxHTML_INDENT_BOTTOM) m_IndentBottom = val;
 166     m_LastLayout = -1;
 167 }
 168
 169
 170
 171 int wxHtmlContainerCell::GetIndent(int ind) const
 172 {
 173     if (ind & wxHTML_INDENT_LEFT) return m_IndentLeft;
 174     else if (ind & wxHTML_INDENT_RIGHT) return m_IndentRight;
 175     else if (ind & wxHTML_INDENT_TOP) return m_IndentTop;
 176     else if (ind & wxHTML_INDENT_BOTTOM) return m_IndentBottom;
 177     else return -1; /* BUG! Should not be called... */
 178 }
 179
 180
 181
 182
 183 int wxHtmlContainerCell::GetIndentUnits(int ind) const
 184 {
 185     bool p = FALSE;
 186     if (ind & wxHTML_INDENT_LEFT) p = m_IndentLeft < 0;
 187     else if (ind & wxHTML_INDENT_RIGHT) p = m_IndentRight < 0;
 188     else if (ind & wxHTML_INDENT_TOP) p = m_IndentTop < 0;
 189     else if (ind & wxHTML_INDENT_BOTTOM) p = m_IndentBottom < 0;
 190     if (p) return wxHTML_UNITS_PERCENT;
 191     else return wxHTML_UNITS_PIXELS;
 192 }
 193
 194
 195
 196 bool wxHtmlContainerCell::AdjustPagebreak(int *pagebreak) const
 197 {
 198     if (!m_CanLiveOnPagebreak)
 199         return wxHtmlCell::AdjustPagebreak(pagebreak);
 200
 201     else
 202     {
 203         wxHtmlCell *c = GetFirstCell();
 204         bool rt = FALSE;
 205         int pbrk = *pagebreak - m_PosY;
 206
 207         while (c)
 208             {
 209             if (c->AdjustPagebreak(&pbrk))
 210                 rt = TRUE;
 211             c = c->GetNext();
 212         }
 213         if (rt)
 214             *pagebreak = pbrk + m_PosY;
 215         return rt;
 216     }
 217 }
 218
 219
 220
 221 void wxHtmlContainerCell::Layout(int w)
 222 {
 223     if (m_LastLayout == w)
 224     {
 225         wxHtmlCell::Layout(w);
 226         return;
 227     }
 228
 229     wxHtmlCell *cell = m_Cells, *line = m_Cells;
 230     long xpos = 0, ypos = m_IndentTop;
 231     int xdelta = 0, ybasicpos = 0, ydiff;
 232     int s_width, s_indent;
 233     int ysizeup = 0, ysizedown = 0;
 234     int MaxLineWidth = 0;
 235     int xcnt = 0;
 236
 237
 238     /*
 239
 240     WIDTH ADJUSTING :
 241
 242     */
 243
 244     if (m_WidthFloatUnits == wxHTML_UNITS_PERCENT)
 245     {
 246         if (m_WidthFloat < 0) m_Width = (100 + m_WidthFloat) * w / 100;
 247         else m_Width = m_WidthFloat * w / 100;
 248     }
 249     else
 250     {
 251         if (m_WidthFloat < 0) m_Width = w + m_WidthFloat;
 252         else m_Width = m_WidthFloat;
 253     }
 254
 255     if (m_Cells)
 256     {
 257         int l = (m_IndentLeft < 0) ? (-m_IndentLeft * m_Width / 100) : m_IndentLeft;
 258         int r = (m_IndentRight < 0) ? (-m_IndentRight * m_Width / 100) : m_IndentRight;
 259         for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
 260             cell->Layout(m_Width - (l + r));
 261     }
 262
 263     /*
 264
 265     LAYOUTING :
 266
 267     */
 268
 269     // adjust indentation:
 270     s_indent = (m_IndentLeft < 0) ? (-m_IndentLeft * m_Width / 100) : m_IndentLeft;
 271     s_width = m_Width - s_indent - ((m_IndentRight < 0) ? (-m_IndentRight * m_Width / 100) : m_IndentRight);
 272
 273     // my own layouting:
 274     while (cell != NULL)
 275     {
 276         switch (m_AlignVer)
 277             {
 278             case wxHTML_ALIGN_TOP :      ybasicpos = 0; break;
 279             case wxHTML_ALIGN_BOTTOM :   ybasicpos = - cell->GetHeight(); break;
 280             case wxHTML_ALIGN_CENTER :   ybasicpos = - cell->GetHeight() / 2; break;
 281         }
 282         ydiff = cell->GetHeight() + ybasicpos;
 283
 284         if (cell->GetDescent() + ydiff > ysizedown) ysizedown = cell->GetDescent() + ydiff;
 285         if (ybasicpos + cell->GetDescent() < -ysizeup) ysizeup = - (ybasicpos + cell->GetDescent());
 286
 287         cell->SetPos(xpos, ybasicpos + cell->GetDescent());
 288         xpos += cell->GetWidth();
 289         cell = cell->GetNext();
 290         xcnt++;
 291
 292         // force new line if occured:
 293         if ((cell == NULL) || (xpos + cell->GetWidth() > s_width))
 294             {
 295             if (xpos > MaxLineWidth) MaxLineWidth = xpos;
 296             if (ysizeup < 0) ysizeup = 0;
 297             if (ysizedown < 0) ysizedown = 0;
 298             switch (m_AlignHor) {
 299                 case wxHTML_ALIGN_LEFT :
 300                 case wxHTML_ALIGN_JUSTIFY :
 301                          xdelta = 0;
 302                          break;
 303                 case wxHTML_ALIGN_RIGHT :
 304                          xdelta = 0 + (s_width - xpos);
 305                          break;
 306                 case wxHTML_ALIGN_CENTER :
 307                          xdelta = 0 + (s_width - xpos) / 2;
 308                          break;
 309             }
 310             if (xdelta < 0) xdelta = 0;
 311             xdelta += s_indent;
 312
 313             ypos += ysizeup;
 314
 315             if (m_AlignHor != wxHTML_ALIGN_JUSTIFY || cell == NULL)
 316                 while (line != cell)
 317                         {
 318                     line->SetPos(line->GetPosX() + xdelta,
 319                                    ypos + line->GetPosY());
 320                     line = line->GetNext();
 321                 }
 322             else
 323             {
 324                 int counter = 0;
 325                 int step = (s_width - xpos);
 326                 if (step < 0) step = 0;
 327                 xcnt--;
 328                 if (xcnt > 0) while (line != cell)
 329                         {
 330                     line->SetPos(line->GetPosX() + s_indent +
 331                                    (counter++ * step / xcnt),
 332                                    ypos + line->GetPosY());
 333                     line = line->GetNext();
 334                 }
 335                 xcnt++;
 336             }
 337
 338             ypos += ysizedown;
 339             xpos = xcnt = 0;
 340             ysizeup = ysizedown = 0;
 341             line = cell;
 342         }
 343     }
 344
 345     // setup height & width, depending on container layout:
 346     m_Height = ypos + (ysizedown + ysizeup) + m_IndentBottom;
 347
 348     if (m_Height < m_MinHeight)
 349     {
 350         if (m_MinHeightAlign != wxHTML_ALIGN_TOP)
 351             {
 352             int diff = m_MinHeight - m_Height;
 353             if (m_MinHeightAlign == wxHTML_ALIGN_CENTER) diff /= 2;
 354             cell = m_Cells;
 355             while (cell)
 356                 {
 357                 cell->SetPos(cell->GetPosX(), cell->GetPosY() + diff);
 358                 cell = cell->GetNext();
 359             }
 360         }
 361         m_Height = m_MinHeight;
 362     }
 363
 364     MaxLineWidth += s_indent + ((m_IndentRight < 0) ? (-m_IndentRight * m_Width / 100) : m_IndentRight);
 365     if (m_Width < MaxLineWidth) m_Width = MaxLineWidth;
 366
 367     m_LastLayout = w;
 368
 369     wxHtmlCell::Layout(w);
 370 }
 371
 372
 373 #define mMin(a, b) (((a) < (b)) ? (a) : (b))
 374 #define mMax(a, b) (((a) < (b)) ? (b) : (a))
 375
 376 void wxHtmlContainerCell::Draw(wxDC& dc, int x, int y, int view_y1, int view_y2)
 377 {
 378     // container visible, draw it:
 379     if ((y + m_PosY < view_y2) && (y + m_PosY + m_Height > view_y1))
 380     {
 381
 382         if (m_UseBkColour)
 383             {
 384             wxBrush myb = wxBrush(m_BkColour, wxSOLID);
 385
 386             int real_y1 = mMax(y + m_PosY, view_y1);
 387             int real_y2 = mMin(y + m_PosY + m_Height - 1, view_y2);
 388
 389             dc.SetBrush(myb);
 390             dc.SetPen(*wxTRANSPARENT_PEN);
 391             dc.DrawRectangle(x + m_PosX, real_y1, m_Width, real_y2 - real_y1 + 1);
 392         }
 393
 394         if (m_UseBorder)
 395             {
 396             wxPen mypen1(m_BorderColour1, 1, wxSOLID);
 397             wxPen mypen2(m_BorderColour2, 1, wxSOLID);
 398
 399             dc.SetPen(mypen1);
 400             dc.DrawLine(x + m_PosX, y + m_PosY, x + m_PosX, y + m_PosY + m_Height - 1);
 401             dc.DrawLine(x + m_PosX, y + m_PosY, x + m_PosX + m_Width - 1, y + m_PosY);
 402             dc.SetPen(mypen2);
 403             dc.DrawLine(x + m_PosX + m_Width - 1, y + m_PosY, x + m_PosX +  m_Width - 1, y + m_PosY + m_Height - 1);
 404             dc.DrawLine(x + m_PosX, y + m_PosY + m_Height - 1, x + m_PosX + m_Width - 1, y + m_PosY + m_Height - 1);
 405         }
 406
 407         if (m_Cells)
 408         {
 409             for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
 410                 cell->Draw(dc, x + m_PosX, y + m_PosY, view_y1, view_y2);
 411         }
 412     }
 413     // container invisible, just proceed font+color changing:
 414     else
 415     {
 416         if (m_Cells)
 417         {
 418             for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
 419                 cell->DrawInvisible(dc, x + m_PosX, y + m_PosY);
 420         }
 421     }
 422 }
 423
 424
 425
 426 void wxHtmlContainerCell::DrawInvisible(wxDC& dc, int x, int y)
 427 {
 428     if (m_Cells)
 429     {
 430         for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
 431             cell->DrawInvisible(dc, x + m_PosX, y + m_PosY);
 432     }
 433 }
 434
 435
 436
 437 wxHtmlLinkInfo *wxHtmlContainerCell::GetLink(int x, int y) const
 438 {
 439     wxHtmlCell *c = m_Cells;
 440     int cx, cy, cw, ch;
 441
 442     while (c)
 443     {
 444         cx = c->GetPosX(), cy = c->GetPosY();
 445         cw = c->GetWidth(), ch = c->GetHeight();
 446         if ((x >= cx) && (x < cx + cw) && (y >= cy) && (y < cy + ch))
 447             return c->GetLink(x - cx, y - cy);
 448         c = c->GetNext();
 449     }
 450     return NULL;
 451 }
 452
 453
 454
 455 void wxHtmlContainerCell::InsertCell(wxHtmlCell *f)
 456 {
 457     if (!m_Cells) m_Cells = m_LastCell = f;
 458     else
 459     {
 460         m_LastCell->SetNext(f);
 461         m_LastCell = f;
 462         if (m_LastCell) while (m_LastCell->GetNext()) m_LastCell = m_LastCell->GetNext();
 463     }
 464     f->SetParent(this);
 465     m_LastLayout = -1;
 466 }
 467
 468
 469
 470 void wxHtmlContainerCell::SetAlign(const wxHtmlTag& tag)
 471 {
 472     if (tag.HasParam(wxT("ALIGN")))
 473     {
 474         wxString alg = tag.GetParam(wxT("ALIGN"));
 475         alg.MakeUpper();
 476         if (alg == wxT("CENTER"))
 477             SetAlignHor(wxHTML_ALIGN_CENTER);
 478         else if (alg == wxT("LEFT"))
 479             SetAlignHor(wxHTML_ALIGN_LEFT);
 480         else if (alg == wxT("JUSTIFY"))
 481             SetAlignHor(wxHTML_ALIGN_JUSTIFY);
 482         else if (alg == wxT("RIGHT"))
 483             SetAlignHor(wxHTML_ALIGN_RIGHT);
 484         m_LastLayout = -1;
 485     }
 486 }
 487
 488
 489
 490 void wxHtmlContainerCell::SetWidthFloat(const wxHtmlTag& tag, double pixel_scale)
 491 {
 492     if (tag.HasParam(wxT("WIDTH")))
 493     {
 494         int wdi;
 495         wxString wd = tag.GetParam(wxT("WIDTH"));
 496
 497         if (wd[wd.Length()-1] == wxT('%'))
 498             {
 499             wxSscanf(wd.c_str(), wxT("%i%%"), &wdi);
 500             SetWidthFloat(wdi, wxHTML_UNITS_PERCENT);
 501         }
 502         else
 503             {
 504             wxSscanf(wd.c_str(), wxT("%i"), &wdi);
 505             SetWidthFloat((int)(pixel_scale * (double)wdi), wxHTML_UNITS_PIXELS);
 506         }
 507         m_LastLayout = -1;
 508     }
 509 }
 510
 511
 512
 513 const wxHtmlCell* wxHtmlContainerCell::Find(int condition, const void* param) const
 514 {
 515     if (m_Cells)
 516     {
 517         const wxHtmlCell *r = NULL;
 518
 519         for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
 520         {
 521             r = cell->Find(condition, param);
 522             if (r) return r;
 523         }
 524     }
 525     return NULL;
 526 }
 527
 528
 529
 530 void wxHtmlContainerCell::OnMouseClick(wxWindow *parent, int x, int y, const wxMouseEvent& event)
 531 {
 532     if (m_Cells)
 533     {
 534         wxHtmlCell *c = m_Cells;
 535         while (c)
 536             {
 537             if (    (c->GetPosX() <= x) &&
 538                     (c->GetPosY() <= y) &&
 539                     (c->GetPosX() + c->GetWidth() > x) &&
 540                     (c->GetPosY() + c->GetHeight() > y))
 541                     {
 542                 c->OnMouseClick(parent, x - c->GetPosX(), y - c->GetPosY(), event);
 543                 break;
 544             }
 545             c = c->GetNext();
 546         }
 547     }
 548 }
 549
 550
 551
 552
 553
 554 //--------------------------------------------------------------------------------
 555 // wxHtmlColourCell
 556 //--------------------------------------------------------------------------------
 557
 558 void wxHtmlColourCell::Draw(wxDC& dc, int x, int y, int view_y1, int view_y2)
 559 {
 560     if (m_Flags & wxHTML_CLR_FOREGROUND)
 561         dc.SetTextForeground(m_Colour);
 562     if (m_Flags & wxHTML_CLR_BACKGROUND)
 563     {
 564         dc.SetBackground(wxBrush(m_Colour, wxSOLID));
 565         dc.SetTextBackground(m_Colour);
 566     }
 567 }
 568
 569 void wxHtmlColourCell::DrawInvisible(wxDC& dc, int x, int y)
 570 {
 571     if (m_Flags & wxHTML_CLR_FOREGROUND)
 572         dc.SetTextForeground(m_Colour);
 573     if (m_Flags & wxHTML_CLR_BACKGROUND)
 574     {
 575         dc.SetBackground(wxBrush(m_Colour, wxSOLID));
 576         dc.SetTextBackground(m_Colour);
 577     }
 578 }
 579
 580
 581
 582
 583 //--------------------------------------------------------------------------------
 584 // wxHtmlFontCell
 585 //--------------------------------------------------------------------------------
 586
 587 void wxHtmlFontCell::Draw(wxDC& dc, int x, int y, int view_y1, int view_y2)
 588 {
 589     dc.SetFont(m_Font);
 590 }
 591
 592 void wxHtmlFontCell::DrawInvisible(wxDC& dc, int x, int y)
 593 {
 594     dc.SetFont(m_Font);
 595 }
 596
 597
 598
 599
 600
 601
 602
 603
 604 //--------------------------------------------------------------------------------
 605 // wxHtmlWidgetCell
 606 //--------------------------------------------------------------------------------
 607
 608 wxHtmlWidgetCell::wxHtmlWidgetCell(wxWindow *wnd, int w)
 609 {
 610     int sx, sy;
 611     m_Wnd = wnd;
 612     m_Wnd->GetSize(&sx, &sy);
 613     m_Width = sx, m_Height = sy;
 614     m_WidthFloat = w;
 615 }
 616
 617
 618 void wxHtmlWidgetCell::Draw(wxDC& dc, int x, int y, int view_y1, int view_y2)
 619 {
 620     int absx = 0, absy = 0, stx, sty;
 621     wxHtmlCell *c = this;
 622
 623     while (c)
 624     {
 625         absx += c->GetPosX();
 626         absy += c->GetPosY();
 627         c = c->GetParent();
 628     }
 629
 630     ((wxScrolledWindow*)(m_Wnd->GetParent()))->GetViewStart(&stx, &sty);
 631     m_Wnd->SetSize(absx - wxHTML_SCROLL_STEP * stx, absy  - wxHTML_SCROLL_STEP * sty, m_Width, m_Height);
 632 }
 633
 634
 635
 636 void wxHtmlWidgetCell::DrawInvisible(wxDC& dc, int x, int y)
 637 {
 638     int absx = 0, absy = 0, stx, sty;
 639     wxHtmlCell *c = this;
 640
 641     while (c)
 642     {
 643         absx += c->GetPosX();
 644         absy += c->GetPosY();
 645         c = c->GetParent();
 646     }
 647
 648     ((wxScrolledWindow*)(m_Wnd->GetParent()))->GetViewStart(&stx, &sty);
 649     m_Wnd->SetSize(absx - wxHTML_SCROLL_STEP * stx, absy  - wxHTML_SCROLL_STEP * sty, m_Width, m_Height);
 650 }
 651
 652
 653
 654 void wxHtmlWidgetCell::Layout(int w)
 655 {
 656     if (m_WidthFloat != 0)
 657     {
 658         m_Width = (w * m_WidthFloat) / 100;
 659         m_Wnd->SetSize(m_Width, m_Height);
 660     }
 661
 662     wxHtmlCell::Layout(w);
 663 }
 664
 665 #endif