// Author: Vaclav Slavik
// RCS-ID: $Id$
// Copyright: (c) 1999 Vaclav Slavik
-// Licence: wxWindows Licence
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma implementation "htmlcell.h"
#endif
#include "wx/html/htmlwin.h"
#include "wx/settings.h"
#include "wx/module.h"
+#include "wx/dynarray.h"
#include <stdlib.h>
wxPoint p2 = toCell ? toCell->GetAbsPos() : wxDefaultPosition;
if ( toCell )
{
- p2.x += toCell->GetWidth()-1;
- p2.y += toCell->GetHeight()-1;
+ p2.x += toCell->GetWidth();
+ p2.y += toCell->GetHeight();
}
Set(p1, fromCell, p2, toCell);
}
-wxColour wxDefaultHtmlRenderingStyle::GetSelectedTextColour(
- const wxColour& clr)
+wxColour
+wxDefaultHtmlRenderingStyle::
+GetSelectedTextColour(const wxColour& WXUNUSED(clr))
{
return wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
}
-wxColour wxDefaultHtmlRenderingStyle::GetSelectedTextBgColour(
- const wxColour& WXUNUSED(clr))
+wxColour
+wxDefaultHtmlRenderingStyle::
+GetSelectedTextBgColour(const wxColour& WXUNUSED(clr))
{
return wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
}
// wxHtmlCell
//-----------------------------------------------------------------------------
+IMPLEMENT_ABSTRACT_CLASS(wxHtmlCell, wxObject)
+
wxHtmlCell::wxHtmlCell() : wxObject()
{
m_Next = NULL;
m_Parent = NULL;
m_Width = m_Height = m_Descent = 0;
- m_CanLiveOnPagebreak = TRUE;
+ m_CanLiveOnPagebreak = true;
m_Link = NULL;
}
m_PosY < *pagebreak && m_PosY + m_Height > *pagebreak)
{
*pagebreak = m_PosY;
- return TRUE;
+ return true;
}
- return FALSE;
+ return false;
}
-void wxHtmlCell::GetHorizontalConstraints(int *left, int *right) const
-{
- if (left)
- *left = m_PosX;
- if (right)
- *right = m_PosX + m_Width;
-}
-
-
-
const wxHtmlCell* wxHtmlCell::Find(int WXUNUSED(condition), const void* WXUNUSED(param)) const
{
return NULL;
// wxHtmlWordCell
//-----------------------------------------------------------------------------
+IMPLEMENT_ABSTRACT_CLASS(wxHtmlWordCell, wxHtmlCell)
+
wxHtmlWordCell::wxHtmlWordCell(const wxString& word, wxDC& dc) : wxHtmlCell()
{
m_Word = word;
dc.GetTextExtent(m_Word, &m_Width, &m_Height, &m_Descent);
- SetCanLiveOnPagebreak(FALSE);
+ SetCanLiveOnPagebreak(false);
m_allowLinebreak = true;
}
wxPoint pt1 = (selFrom == wxDefaultPosition) ?
wxDefaultPosition : selFrom - GetAbsPos();
wxPoint pt2 = (selTo == wxDefaultPosition) ?
- wxPoint(m_Width, -1) : selTo - GetAbsPos();
+ wxPoint(m_Width, wxDefaultCoord) : selTo - GetAbsPos();
wxCoord charW, charH;
unsigned len = m_Word.length();
wxHtmlRenderingInfo& info)
{
#if 0 // useful for debugging
- dc.DrawRectangle(x+m_PosX,y+m_PosY,m_Width,m_Height);
+ dc.SetPen(*wxBLACK_PEN);
+ dc.DrawRectangle(x+m_PosX,y+m_PosY,m_Width /* VZ: +1? */ ,m_Height);
#endif
bool drawSelectionAfterCell = false;
-
+
if ( info.GetState().GetSelectionState() == wxHTML_SEL_CHANGING )
{
// Selection changing, we must draw the word piecewise:
// wxHtmlContainerCell
//-----------------------------------------------------------------------------
+IMPLEMENT_ABSTRACT_CLASS(wxHtmlContainerCell, wxHtmlCell)
wxHtmlContainerCell::wxHtmlContainerCell(wxHtmlContainerCell *parent) : wxHtmlCell()
{
m_Cells = m_LastCell = NULL;
m_Parent = parent;
+ m_MaxTotalWidth = 0;
if (m_Parent) m_Parent->InsertCell(this);
m_AlignHor = wxHTML_ALIGN_LEFT;
m_AlignVer = wxHTML_ALIGN_BOTTOM;
m_IndentLeft = m_IndentRight = m_IndentTop = m_IndentBottom = 0;
m_WidthFloat = 100; m_WidthFloatUnits = wxHTML_UNITS_PERCENT;
- m_UseBkColour = FALSE;
- m_UseBorder = FALSE;
+ m_UseBkColour = false;
+ m_UseBorder = false;
m_MinHeight = 0;
m_MinHeightAlign = wxHTML_ALIGN_TOP;
m_LastLayout = -1;
int wxHtmlContainerCell::GetIndentUnits(int ind) const
{
- bool p = FALSE;
+ bool p = false;
if (ind & wxHTML_INDENT_LEFT) p = m_IndentLeft < 0;
else if (ind & wxHTML_INDENT_RIGHT) p = m_IndentRight < 0;
else if (ind & wxHTML_INDENT_TOP) p = m_IndentTop < 0;
else
{
wxHtmlCell *c = GetFirstChild();
- bool rt = FALSE;
+ bool rt = false;
int pbrk = *pagebreak - m_PosY;
while (c)
{
if (c->AdjustPagebreak(&pbrk, known_pagebreaks, number_of_pages))
- rt = TRUE;
+ rt = true;
c = c->GetNext();
}
if (rt)
return;
}
- wxHtmlCell *cell = m_Cells, *line = m_Cells;
+ wxHtmlCell *cell = m_Cells,
+ *line = m_Cells;
wxHtmlCell *nextCell;
long xpos = 0, ypos = m_IndentTop;
int xdelta = 0, ybasicpos = 0, ydiff;
int s_width, nextWordWidth, s_indent;
int ysizeup = 0, ysizedown = 0;
int MaxLineWidth = 0;
- int xcnt = 0;
+ int curLineWidth = 0;
+ m_MaxTotalWidth = 0;
/*
// layout nonbreakable run of cells:
cell->SetPos(xpos, ybasicpos + cell->GetDescent());
xpos += cell->GetWidth();
+ if (!cell->IsTerminalCell())
+ {
+ // Container cell indicates new line
+ if (curLineWidth > m_MaxTotalWidth)
+ m_MaxTotalWidth = curLineWidth;
+
+ if (wxMax(cell->GetWidth(), cell->GetMaxTotalWidth()) > m_MaxTotalWidth)
+ m_MaxTotalWidth = cell->GetMaxTotalWidth();
+ curLineWidth = 0;
+ }
+ else
+ // Normal cell, add maximum cell width to line width
+ curLineWidth += cell->GetMaxTotalWidth();
+
cell = cell->GetNext();
- xcnt++;
-
+
// compute length of the next word that would be added:
nextWordWidth = 0;
if (cell)
nextCell = nextCell->GetNext();
} while (nextCell && !nextCell->IsLinebreakAllowed());
}
-
+
// force new line if occured:
- if ((cell == NULL) ||
+ if ((cell == NULL) ||
(xpos + nextWordWidth > s_width && cell->IsLinebreakAllowed()))
{
if (xpos > MaxLineWidth) MaxLineWidth = xpos;
ypos += ysizeup;
if (m_AlignHor != wxHTML_ALIGN_JUSTIFY || cell == NULL)
+ {
while (line != cell)
{
line->SetPos(line->GetPosX() + xdelta,
ypos + line->GetPosY());
line = line->GetNext();
}
- else
+ }
+ else // align == justify
{
- int counter = 0;
- int step = (s_width - xpos);
- if (step < 0) step = 0;
- xcnt--;
- if (xcnt > 0) while (line != cell)
+ // we have to distribute the extra horz space between the cells
+ // on this line
+
+ // an added complication is that some cells have fixed size and
+ // shouldn't get any increment (it so happens that these cells
+ // also don't allow line break on them which provides with an
+ // easy way to test for this) -- and neither should the cells
+ // adjacent to them as this could result in a visible space
+ // between two cells separated by, e.g. font change, cell which
+ // is wrong
+
+ int step = s_width - xpos;
+ if ( step > 0 )
{
- line->SetPos(line->GetPosX() + s_indent +
- (counter++ * step / xcnt),
- ypos + line->GetPosY());
- line = line->GetNext();
+ // first count the cells which will get extra space
+ int total = 0;
+
+ const wxHtmlCell *c;
+ if ( line != cell )
+ {
+ for ( c = line->GetNext(); c != cell; c = c->GetNext() )
+ {
+ if ( c->IsLinebreakAllowed() )
+ {
+ total++;
+ }
+ }
+ }
+
+ // and now extra space to those cells which merit it
+ if ( total )
+ {
+ // first cell on line is not moved:
+ line->SetPos(line->GetPosX() + s_indent,
+ line->GetPosY() + ypos);
+
+ line = line->GetNext();
+ for ( int n = 0; line != cell; line = line->GetNext() )
+ {
+ if ( line->IsLinebreakAllowed() )
+ {
+ // offset the next cell relative to this one
+ // thus increasing our size
+ n++;
+ }
+
+ line->SetPos(line->GetPosX() + s_indent +
+ ((n * step) / total),
+ line->GetPosY() + ypos);
+ }
+ }
+ else
+ {
+ // this will cause the code to enter "else branch" below:
+ step = 0;
+ }
+ }
+ // else branch:
+ if ( step <= 0 ) // no extra space to distribute
+ {
+ // just set the indent properly
+ while (line != cell)
+ {
+ line->SetPos(line->GetPosX() + s_indent,
+ line->GetPosY() + ypos);
+ line = line->GetNext();
+ }
}
- xcnt++;
}
ypos += ysizedown;
- xpos = xcnt = 0;
+ xpos = 0;
ysizeup = ysizedown = 0;
line = cell;
}
m_Height = m_MinHeight;
}
+ if (curLineWidth > m_MaxTotalWidth)
+ m_MaxTotalWidth = curLineWidth;
+
+ m_MaxTotalWidth += s_indent + ((m_IndentRight < 0) ? (-m_IndentRight * m_Width / 100) : m_IndentRight);
MaxLineWidth += s_indent + ((m_IndentRight < 0) ? (-m_IndentRight * m_Width / 100) : m_IndentRight);
if (m_Width < MaxLineWidth) m_Width = MaxLineWidth;
void wxHtmlContainerCell::Draw(wxDC& dc, int x, int y, int view_y1, int view_y2,
wxHtmlRenderingInfo& info)
{
- // container visible, draw it:
- if ((y + m_PosY <= view_y2) && (y + m_PosY + m_Height > view_y1))
+#if 0 // useful for debugging
+ dc.SetPen(*wxRED_PEN);
+ dc.DrawRectangle(x+m_PosX,y+m_PosY,m_Width,m_Height);
+#endif
+
+ int xlocal = x + m_PosX;
+ int ylocal = y + m_PosY;
+
+ if (m_UseBkColour)
{
- if (m_UseBkColour)
- {
- wxBrush myb = wxBrush(m_BkColour, wxSOLID);
+ wxBrush myb = wxBrush(m_BkColour, wxSOLID);
- int real_y1 = mMax(y + m_PosY, view_y1);
- int real_y2 = mMin(y + m_PosY + m_Height - 1, view_y2);
+ int real_y1 = mMax(ylocal, view_y1);
+ int real_y2 = mMin(ylocal + m_Height - 1, view_y2);
- dc.SetBrush(myb);
- dc.SetPen(*wxTRANSPARENT_PEN);
- dc.DrawRectangle(x + m_PosX, real_y1, m_Width, real_y2 - real_y1 + 1);
- }
+ dc.SetBrush(myb);
+ dc.SetPen(*wxTRANSPARENT_PEN);
+ dc.DrawRectangle(xlocal, real_y1, m_Width, real_y2 - real_y1 + 1);
+ }
- if (m_UseBorder)
- {
- wxPen mypen1(m_BorderColour1, 1, wxSOLID);
- wxPen mypen2(m_BorderColour2, 1, wxSOLID);
-
- dc.SetPen(mypen1);
- dc.DrawLine(x + m_PosX, y + m_PosY, x + m_PosX, y + m_PosY + m_Height - 1);
- dc.DrawLine(x + m_PosX, y + m_PosY, x + m_PosX + m_Width, y + m_PosY);
- dc.SetPen(mypen2);
- dc.DrawLine(x + m_PosX + m_Width - 1, y + m_PosY, x + m_PosX + m_Width - 1, y + m_PosY + m_Height - 1);
- dc.DrawLine(x + m_PosX, y + m_PosY + m_Height - 1, x + m_PosX + m_Width, y + m_PosY + m_Height - 1);
- }
+ if (m_UseBorder)
+ {
+ wxPen mypen1(m_BorderColour1, 1, wxSOLID);
+ wxPen mypen2(m_BorderColour2, 1, wxSOLID);
+
+ dc.SetPen(mypen1);
+ dc.DrawLine(xlocal, ylocal, xlocal, ylocal + m_Height - 1);
+ dc.DrawLine(xlocal, ylocal, xlocal + m_Width, ylocal);
+ dc.SetPen(mypen2);
+ dc.DrawLine(xlocal + m_Width - 1, ylocal, xlocal + m_Width - 1, ylocal + m_Height - 1);
+ dc.DrawLine(xlocal, ylocal + m_Height - 1, xlocal + m_Width, ylocal + m_Height - 1);
+ }
- if (m_Cells)
+ if (m_Cells)
+ {
+ // draw container's contents:
+ for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
{
- // draw container's contents:
- for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
+
+ // optimize drawing: don't render off-screen content:
+ if ((ylocal + cell->GetPosY() <= view_y2) &&
+ (ylocal + cell->GetPosY() + cell->GetHeight() > view_y1))
{
+ // the cell is visible, draw it:
UpdateRenderingStatePre(info, cell);
cell->Draw(dc,
- x + m_PosX, y + m_PosY, view_y1, view_y2,
+ xlocal, ylocal, view_y1, view_y2,
info);
UpdateRenderingStatePost(info, cell);
}
+ else
+ {
+ // the cell is off-screen, proceed with font+color+etc.
+ // changes only:
+ cell->DrawInvisible(dc, xlocal, ylocal, info);
+ }
}
}
- // container invisible, just proceed font+color changing:
- else
- {
- DrawInvisible(dc, x, y, info);
- }
}
{
if (m_Cells)
{
- const wxHtmlCell *r = NULL;
-
for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
{
- r = cell->Find(condition, param);
+ const wxHtmlCell *r = cell->Find(condition, param);
if (r) return r;
}
}
if ( cell->IsFormattingCell() )
continue;
int cellY = cell->GetPosY();
- if (!( y < cellY || (y < cellY + cell->GetHeight() &&
+ if (!( y < cellY || (y < cellY + cell->GetHeight() &&
x < cell->GetPosX() + cell->GetWidth()) ))
continue;
-
+
c = cell->FindCellByPos(x - cell->GetPosX(), y - cellY, flags);
if (c) return c;
}
-void wxHtmlContainerCell::GetHorizontalConstraints(int *left, int *right) const
-{
- int cleft = m_PosX + m_Width, cright = m_PosX; // worst case
- int l, r;
-
- for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
- {
- cell->GetHorizontalConstraints(&l, &r);
- if (l < cleft)
- cleft = l;
- if (r > cright)
- cright = r;
- }
-
- cleft -= (m_IndentLeft < 0) ? (-m_IndentLeft * m_Width / 100) : m_IndentLeft;
- cright += (m_IndentRight < 0) ? (-m_IndentRight * m_Width / 100) : m_IndentRight;
-
- if (left)
- *left = cleft;
- if (right)
- *right = cright;
-}
-
-
wxHtmlCell *wxHtmlContainerCell::GetFirstTerminal() const
{
if ( m_Cells )
if ( c )
return c;
+ wxHtmlCell *ctmp;
wxHtmlCell *c2 = NULL;
for (c = m_Cells; c; c = c->GetNext())
- c2 = c->GetLastTerminal();
+ {
+ ctmp = c->GetLastTerminal();
+ if ( ctmp )
+ c2 = ctmp;
+ }
return c2;
}
else
}
+static bool IsEmptyContainer(wxHtmlContainerCell *cell)
+{
+ for ( wxHtmlCell *c = cell->GetFirstChild(); c; c = c->GetNext() )
+ {
+ if ( !c->IsTerminalCell() || !c->IsFormattingCell() )
+ return false;
+ }
+ return true;
+}
+
+void wxHtmlContainerCell::RemoveExtraSpacing(bool top, bool bottom)
+{
+ if ( top )
+ SetIndent(0, wxHTML_INDENT_TOP);
+ if ( bottom )
+ SetIndent(0, wxHTML_INDENT_BOTTOM);
+
+ if ( m_Cells )
+ {
+ wxHtmlCell *c;
+ wxHtmlContainerCell *cont;
+ if ( top )
+ {
+ for ( c = m_Cells; c; c = c->GetNext() )
+ {
+ if ( c->IsTerminalCell() )
+ {
+ if ( !c->IsFormattingCell() )
+ break;
+ }
+ else
+ {
+ cont = (wxHtmlContainerCell*)c;
+ if ( IsEmptyContainer(cont) )
+ {
+ cont->SetIndent(0, wxHTML_INDENT_VERTICAL);
+ }
+ else
+ {
+ cont->RemoveExtraSpacing(true, false);
+ break;
+ }
+ }
+ }
+ }
+
+ if ( bottom )
+ {
+ wxArrayPtrVoid arr;
+ for ( c = m_Cells; c; c = c->GetNext() )
+ arr.Add((void*)c);
+
+ for ( int i = arr.GetCount() - 1; i >= 0; i--)
+ {
+ c = (wxHtmlCell*)arr[i];
+ if ( c->IsTerminalCell() )
+ {
+ if ( !c->IsFormattingCell() )
+ break;
+ }
+ else
+ {
+ cont = (wxHtmlContainerCell*)c;
+ if ( IsEmptyContainer(cont) )
+ {
+ cont->SetIndent(0, wxHTML_INDENT_VERTICAL);
+ }
+ else
+ {
+ cont->RemoveExtraSpacing(false, true);
+ break;
+ }
+ }
+ }
+ }
+ }
+}
+
+
// --------------------------------------------------------------------------
// wxHtmlColourCell
// --------------------------------------------------------------------------
+IMPLEMENT_ABSTRACT_CLASS(wxHtmlColourCell, wxHtmlCell)
+
void wxHtmlColourCell::Draw(wxDC& dc,
int x, int y,
int WXUNUSED(view_y1), int WXUNUSED(view_y2),
// wxHtmlFontCell
// ---------------------------------------------------------------------------
+IMPLEMENT_ABSTRACT_CLASS(wxHtmlFontCell, wxHtmlCell)
+
void wxHtmlFontCell::Draw(wxDC& dc,
int WXUNUSED(x), int WXUNUSED(y),
int WXUNUSED(view_y1), int WXUNUSED(view_y2),
// wxHtmlWidgetCell
// ---------------------------------------------------------------------------
+IMPLEMENT_ABSTRACT_CLASS(wxHtmlWidgetCell, wxHtmlCell)
+
wxHtmlWidgetCell::wxHtmlWidgetCell(wxWindow *wnd, int w)
{
int sx, sy;
projects / wxWidgets.git / blobdiff