/////////////////////////////////////////////////////////////////////////////
-// Name: htmlcell.cpp
+// Name: src/html/htmlcell.cpp
// Purpose: wxHtmlCell - basic element of HTML output
// Author: Vaclav Slavik
// RCS-ID: $Id$
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-#pragma implementation "htmlcell.h"
-#endif
-
#include "wx/wxprec.h"
-#include "wx/defs.h"
-
-#if wxUSE_HTML && wxUSE_STREAMS
-
#ifdef __BORLANDC__
-#pragma hdrstop
+ #pragma hdrstop
#endif
-#ifndef WXPRECOMP
+#if wxUSE_HTML && wxUSE_STREAMS
+
+#ifndef WX_PRECOMP
+ #include "wx/dynarray.h"
#include "wx/brush.h"
#include "wx/colour.h"
#include "wx/dc.h"
+ #include "wx/settings.h"
+ #include "wx/module.h"
+ #include "wx/wxcrtvararg.h"
#endif
#include "wx/html/htmlcell.h"
#include "wx/html/htmlwin.h"
-#include "wx/settings.h"
-#include "wx/module.h"
-#include "wx/dynarray.h"
#include <stdlib.h>
-//-----------------------------------------------------------------------------
-// Global variables
-//-----------------------------------------------------------------------------
-
-static wxCursor *gs_cursorLink = NULL;
-static wxCursor *gs_cursorText = NULL;
-
-
//-----------------------------------------------------------------------------
// Helper classes
//-----------------------------------------------------------------------------
m_Next = NULL;
m_Parent = NULL;
m_Width = m_Height = m_Descent = 0;
+ m_ScriptMode = wxHTML_SCRIPT_NORMAL; // <sub> or <sup> mode
+ m_ScriptBaseline = 0; // <sub> or <sup> baseline
m_CanLiveOnPagebreak = true;
m_Link = NULL;
}
delete m_Link;
}
+// Update the descent value when whe are in a <sub> or <sup>.
+// prevbase is the parent base
+void wxHtmlCell::SetScriptMode(wxHtmlScriptMode mode, long previousBase)
+{
+ m_ScriptMode = mode;
+
+ if (mode == wxHTML_SCRIPT_SUP)
+ m_ScriptBaseline = previousBase - (m_Height + 1) / 2;
+ else if (mode == wxHTML_SCRIPT_SUB)
+ m_ScriptBaseline = previousBase + (m_Height + 1) / 6;
+ else
+ m_ScriptBaseline = 0;
+
+ m_Descent += m_ScriptBaseline;
+}
+
+#if WXWIN_COMPATIBILITY_2_6
+
+struct wxHtmlCellOnMouseClickCompatHelper;
+
+static wxHtmlCellOnMouseClickCompatHelper *gs_helperOnMouseClick = NULL;
+
+// helper for routing calls to new ProcessMouseClick() method to deprecated
+// OnMouseClick() method
+struct wxHtmlCellOnMouseClickCompatHelper
+{
+ wxHtmlCellOnMouseClickCompatHelper(wxHtmlWindowInterface *window_,
+ const wxPoint& pos_,
+ const wxMouseEvent& event_)
+ : window(window_), pos(pos_), event(event_), retval(false)
+ {
+ }
+
+ bool CallOnMouseClick(wxHtmlCell *cell)
+ {
+ wxHtmlCellOnMouseClickCompatHelper *oldHelper = gs_helperOnMouseClick;
+ gs_helperOnMouseClick = this;
+ cell->OnMouseClick
+ (
+ window ? window->GetHTMLWindow() : NULL,
+ pos.x, pos.y,
+ event
+ );
+ gs_helperOnMouseClick = oldHelper;
+ return retval;
+ }
-void wxHtmlCell::OnMouseClick(wxWindow *parent, int x, int y,
- const wxMouseEvent& event)
+ wxHtmlWindowInterface *window;
+ const wxPoint& pos;
+ const wxMouseEvent& event;
+ bool retval;
+};
+#endif // WXWIN_COMPATIBILITY_2_6
+
+bool wxHtmlCell::ProcessMouseClick(wxHtmlWindowInterface *window,
+ const wxPoint& pos,
+ const wxMouseEvent& event)
{
- wxHtmlLinkInfo *lnk = GetLink(x, y);
- if (lnk != NULL)
+ wxCHECK_MSG( window, false, _T("window interface must be provided") );
+
+#if WXWIN_COMPATIBILITY_2_6
+ // NB: this hack puts the body of ProcessMouseClick() into OnMouseClick()
+ // (for which it has to pass the arguments and return value via a
+ // helper variable because these two methods have different
+ // signatures), so that old code overriding OnMouseClick will continue
+ // to work
+ wxHtmlCellOnMouseClickCompatHelper compat(window, pos, event);
+ return compat.CallOnMouseClick(this);
+}
+
+void wxHtmlCell::OnMouseClick(wxWindow *, int, int, const wxMouseEvent& event)
+{
+ wxCHECK_RET( gs_helperOnMouseClick, _T("unexpected call to OnMouseClick") );
+ wxHtmlWindowInterface *window = gs_helperOnMouseClick->window;
+ const wxPoint& pos = gs_helperOnMouseClick->pos;
+#endif // WXWIN_COMPATIBILITY_2_6
+
+ wxHtmlLinkInfo *lnk = GetLink(pos.x, pos.y);
+ bool retval = false;
+
+ if (lnk)
{
wxHtmlLinkInfo lnk2(*lnk);
lnk2.SetEvent(&event);
lnk2.SetHtmlCell(this);
- // note : this cast is legal because parent is *always* wxHtmlWindow
- wxStaticCast(parent, wxHtmlWindow)->OnLinkClicked(lnk2);
+ window->OnHTMLLinkClicked(lnk2);
+ retval = true;
}
-}
+#if WXWIN_COMPATIBILITY_2_6
+ gs_helperOnMouseClick->retval = retval;
+#else
+ return retval;
+#endif // WXWIN_COMPATIBILITY_2_6
+}
+#if WXWIN_COMPATIBILITY_2_6
wxCursor wxHtmlCell::GetCursor() const
{
+ return wxNullCursor;
+}
+#endif // WXWIN_COMPATIBILITY_2_6
+
+wxCursor wxHtmlCell::GetMouseCursor(wxHtmlWindowInterface *window) const
+{
+#if WXWIN_COMPATIBILITY_2_6
+ // NB: Older versions of wx used GetCursor() virtual method in place of
+ // GetMouseCursor(interface). This code ensures that user code that
+ // overriden GetCursor() continues to work. The trick is that the base
+ // wxHtmlCell::GetCursor() method simply returns wxNullCursor, so we
+ // know that GetCursor() was overriden iff it returns valid cursor.
+ wxCursor cur = GetCursor();
+ if (cur.Ok())
+ return cur;
+#endif // WXWIN_COMPATIBILITY_2_6
+
if ( GetLink() )
{
- if ( !gs_cursorLink )
- gs_cursorLink = new wxCursor(wxCURSOR_HAND);
- return *gs_cursorLink;
+ return window->GetHTMLCursor(wxHtmlWindowInterface::HTMLCursor_Link);
}
else
- return *wxSTANDARD_CURSOR;
+ {
+ return window->GetHTMLCursor(wxHtmlWindowInterface::HTMLCursor_Default);
+ }
}
-bool wxHtmlCell::AdjustPagebreak(int *pagebreak, int* WXUNUSED(known_pagebreaks), int WXUNUSED(number_of_pages)) const
+bool wxHtmlCell::AdjustPagebreak(int *pagebreak,
+ wxArrayInt& WXUNUSED(known_pagebreaks)) const
{
if ((!m_CanLiveOnPagebreak) &&
m_PosY < *pagebreak && m_PosY + m_Height > *pagebreak)
}
-wxPoint wxHtmlCell::GetAbsPos() const
+wxPoint wxHtmlCell::GetAbsPos(wxHtmlCell *rootCell) const
{
wxPoint p(m_PosX, m_PosY);
- for (wxHtmlCell *parent = m_Parent; parent; parent = parent->m_Parent)
+ for (wxHtmlCell *parent = m_Parent; parent && parent != rootCell;
+ parent = parent->m_Parent)
{
p.x += parent->m_PosX;
p.y += parent->m_PosY;
return p;
}
+wxHtmlCell *wxHtmlCell::GetRootCell() const
+{
+ wxHtmlCell *c = wxConstCast(this, wxHtmlCell);
+ while ( c->m_Parent )
+ c = c->m_Parent;
+ return c;
+}
+
unsigned wxHtmlCell::GetDepth() const
{
unsigned d = 0;
IMPLEMENT_ABSTRACT_CLASS(wxHtmlWordCell, wxHtmlCell)
-wxHtmlWordCell::wxHtmlWordCell(const wxString& word, wxDC& dc) : wxHtmlCell()
+wxHtmlWordCell::wxHtmlWordCell(const wxString& word, const wxDC& dc) : wxHtmlCell()
{
m_Word = word;
- dc.GetTextExtent(m_Word, &m_Width, &m_Height, &m_Descent);
+ wxCoord w, h, d;
+ dc.GetTextExtent(m_Word, &w, &h, &d);
+ m_Width = w;
+ m_Height = h;
+ m_Descent = d;
SetCanLiveOnPagebreak(false);
m_allowLinebreak = true;
}
// Splits m_Word into up to three parts according to selection, returns
// substring before, in and after selection and the points (in relative coords)
// where s2 and s3 start:
-void wxHtmlWordCell::Split(wxDC& dc,
+void wxHtmlWordCell::Split(const wxDC& dc,
const wxPoint& selFrom, const wxPoint& selTo,
unsigned& pos1, unsigned& pos2) const
{
wxPoint pt1 = (selFrom == wxDefaultPosition) ?
wxDefaultPosition : selFrom - GetAbsPos();
wxPoint pt2 = (selTo == wxDefaultPosition) ?
- wxPoint(m_Width, wxDefaultPosition.y) : selTo - GetAbsPos();
+ wxPoint(m_Width, wxDefaultCoord) : selTo - GetAbsPos();
+
+ // if the selection is entirely within this cell, make sure pt1 < pt2 in
+ // order to make the rest of this function simpler:
+ if ( selFrom != wxDefaultPosition && selTo != wxDefaultPosition &&
+ selFrom.x > selTo.x )
+ {
+ wxPoint tmp = pt1;
+ pt1 = pt2;
+ pt2 = tmp;
+ }
- wxCoord charW, charH;
unsigned len = m_Word.length();
unsigned i = 0;
pos1 = 0;
pt2.x = m_Width;
// before selection:
+ // (include character under caret only if in first half of width)
+#ifdef __WXMAC__
+ // implementation using PartialExtents to support fractional widths
+ wxArrayInt widths ;
+ dc.GetPartialTextExtents(m_Word,widths) ;
+ while( i < len && pt1.x >= widths[i] )
+ i++ ;
+ if ( i < len )
+ {
+ int charW = (i > 0) ? widths[i] - widths[i-1] : widths[i];
+ if ( widths[i] - pt1.x < charW/2 )
+ i++;
+ }
+#else // !__WXMAC__
+ wxCoord charW, charH;
while ( pt1.x > 0 && i < len )
{
dc.GetTextExtent(m_Word[i], &charW, &charH);
pt1.x -= charW;
- if ( pt1.x >= 0 )
+ if ( pt1.x >= -charW/2 )
{
pos1 += charW;
i++;
}
}
+#endif // __WXMAC__/!__WXMAC__
// in selection:
+ // (include character under caret only if in first half of width)
unsigned j = i;
+#ifdef __WXMAC__
+ while( j < len && pt2.x >= widths[j] )
+ j++ ;
+ if ( j < len )
+ {
+ int charW = (j > 0) ? widths[j] - widths[j-1] : widths[j];
+ if ( widths[j] - pt2.x < charW/2 )
+ j++;
+ }
+#else // !__WXMAC__
pos2 = pos1;
pt2.x -= pos2;
while ( pt2.x > 0 && j < len )
{
dc.GetTextExtent(m_Word[j], &charW, &charH);
pt2.x -= charW;
- if ( pt2.x >= 0 )
+ if ( pt2.x >= -charW/2 )
{
pos2 += charW;
j++;
}
}
+#endif // __WXMAC__/!__WXMAC__
pos1 = i;
pos2 = j;
+
+ wxASSERT( pos2 >= pos1 );
}
-void wxHtmlWordCell::SetSelectionPrivPos(wxDC& dc, wxHtmlSelection *s) const
+void wxHtmlWordCell::SetSelectionPrivPos(const wxDC& dc, wxHtmlSelection *s) const
{
unsigned p1, p2;
if ( toSelection )
{
- dc.SetBackgroundMode(wxSOLID);
+ dc.SetBackgroundMode(wxBRUSHSTYLE_SOLID);
dc.SetTextForeground(info.GetStyle().GetSelectedTextColour(fg));
dc.SetTextBackground(info.GetStyle().GetSelectedTextBgColour(bg));
dc.SetBackground(wxBrush(info.GetStyle().GetSelectedTextBgColour(bg),
- wxSOLID));
+ wxBRUSHSTYLE_SOLID));
}
else
{
- dc.SetBackgroundMode(wxTRANSPARENT);
+ dc.SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT);
dc.SetTextForeground(fg);
dc.SetTextBackground(bg);
- dc.SetBackground(wxBrush(bg, wxSOLID));
+ dc.SetBackground(wxBrush(bg, wxBRUSHSTYLE_SOLID));
}
}
#endif
bool drawSelectionAfterCell = false;
-
+
if ( info.GetState().GetSelectionState() == wxHTML_SEL_CHANGING )
{
// Selection changing, we must draw the word piecewise:
wxHtmlSelectionState selstate = info.GetState().GetSelectionState();
// Not changing selection state, draw the word in single mode:
if ( selstate != wxHTML_SEL_OUT &&
- dc.GetBackgroundMode() != wxSOLID )
+ dc.GetBackgroundMode() != wxBRUSHSTYLE_SOLID )
{
SwitchSelState(dc, info, true);
}
else if ( selstate == wxHTML_SEL_OUT &&
- dc.GetBackgroundMode() == wxSOLID )
+ dc.GetBackgroundMode() == wxBRUSHSTYLE_SOLID )
{
SwitchSelState(dc, info, false);
}
}
}
+wxCursor wxHtmlWordCell::GetMouseCursor(wxHtmlWindowInterface *window) const
+{
+ if ( !GetLink() )
+ {
+ return window->GetHTMLCursor(wxHtmlWindowInterface::HTMLCursor_Text);
+ }
+ else
+ {
+ return wxHtmlCell::GetMouseCursor(window);
+ }
+}
wxString wxHtmlWordCell::ConvertToText(wxHtmlSelection *s) const
{
// TODO: but this really needs to be fixed in some better way later...
if ( priv != wxDefaultPosition )
{
- int part1 = priv.x;
- int part2 = priv.y;
- return m_Word.Mid(part1, part2-part1);
+ const int part1 = priv.x;
+ const int part2 = priv.y;
+ if ( part1 == part2 )
+ return wxEmptyString;
+ return GetPartAsText(part1, part2);
}
//else: return the whole word below
}
- return m_Word;
+ return GetAllAsText();
}
-wxCursor wxHtmlWordCell::GetCursor() const
+wxString wxHtmlWordWithTabsCell::GetAllAsText() const
{
- if ( !GetLink() )
+ return m_wordOrig;
+}
+
+wxString wxHtmlWordWithTabsCell::GetPartAsText(int begin, int end) const
+{
+ // NB: The 'begin' and 'end' positions are in the _displayed_ text
+ // (stored in m_Word) and not in the text with tabs that should
+ // be copied to clipboard (m_wordOrig).
+ //
+ // NB: Because selection is performed on displayed text, it's possible
+ // to select e.g. "half of TAB character" -- IOW, 'begin' and 'end'
+ // may be in the middle of TAB character expansion into ' 's. In this
+ // case, we copy the TAB character to clipboard once.
+
+ wxASSERT( begin < end );
+
+ const unsigned SPACES_PER_TAB = 8;
+
+ wxString sel;
+
+ int pos = 0;
+ wxString::const_iterator i = m_wordOrig.begin();
+
+ // find the beginning of text to copy:
+ for ( ; pos < begin; ++i )
+ {
+ if ( *i == '\t' )
+ {
+ pos += 8 - (m_linepos + pos) % SPACES_PER_TAB;
+ if ( pos >= begin )
+ {
+ sel += '\t';
+ }
+ }
+ else
+ {
+ ++pos;
+ }
+ }
+
+ // copy the content until we reach 'end':
+ for ( ; pos < end; ++i )
{
- if ( !gs_cursorText )
- gs_cursorText = new wxCursor(wxCURSOR_IBEAM);
- return *gs_cursorText;
+ const wxChar c = *i;
+ sel += c;
+
+ if ( c == '\t' )
+ pos += 8 - (m_linepos + pos) % SPACES_PER_TAB;
+ else
+ ++pos;
}
- else
- return wxHtmlCell::GetCursor();
+
+ return sel;
}
+
//-----------------------------------------------------------------------------
// wxHtmlContainerCell
//-----------------------------------------------------------------------------
}
-
-bool wxHtmlContainerCell::AdjustPagebreak(int *pagebreak, int* known_pagebreaks, int number_of_pages) const
+bool wxHtmlContainerCell::AdjustPagebreak(int *pagebreak,
+ wxArrayInt& known_pagebreaks) const
{
if (!m_CanLiveOnPagebreak)
- return wxHtmlCell::AdjustPagebreak(pagebreak, known_pagebreaks, number_of_pages);
+ return wxHtmlCell::AdjustPagebreak(pagebreak, known_pagebreaks);
- else
- {
- wxHtmlCell *c = GetFirstChild();
- bool rt = false;
- int pbrk = *pagebreak - m_PosY;
+ wxHtmlCell *c = GetFirstChild();
+ bool rt = false;
+ int pbrk = *pagebreak - m_PosY;
- while (c)
- {
- if (c->AdjustPagebreak(&pbrk, known_pagebreaks, number_of_pages))
- rt = true;
- c = c->GetNext();
- }
- if (rt)
- *pagebreak = pbrk + m_PosY;
- return rt;
+ while (c)
+ {
+ if (c->AdjustPagebreak(&pbrk, known_pagebreaks))
+ rt = true;
+ c = c->GetNext();
}
+ if (rt)
+ *pagebreak = pbrk + m_PosY;
+ return rt;
}
-
void wxHtmlContainerCell::Layout(int w)
{
wxHtmlCell::Layout(w);
- if (m_LastLayout == w) return;
+ if (m_LastLayout == w)
+ return;
+ m_LastLayout = w;
// VS: Any attempt to layout with negative or zero width leads to hell,
// but we can't ignore such attempts completely, since it sometimes
return;
}
- wxHtmlCell *cell = m_Cells,
- *line = m_Cells;
wxHtmlCell *nextCell;
long xpos = 0, ypos = m_IndentTop;
int xdelta = 0, ybasicpos = 0, ydiff;
s_width = m_Width - s_indent - ((m_IndentRight < 0) ? (-m_IndentRight * m_Width / 100) : m_IndentRight);
// my own layouting:
+ wxHtmlCell *cell = m_Cells,
+ *line = m_Cells;
while (cell != NULL)
{
switch (m_AlignVer)
curLineWidth += cell->GetMaxTotalWidth();
cell = cell->GetNext();
-
+
// 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) ||
+
+ // force new line if occurred:
+ if ((cell == NULL) ||
(xpos + nextWordWidth > s_width && cell->IsLinebreakAllowed()))
{
if (xpos > MaxLineWidth) MaxLineWidth = xpos;
// between two cells separated by, e.g. font change, cell which
// is wrong
- const int step = s_width - xpos;
+ int step = s_width - xpos;
if ( step > 0 )
{
// first count the cells which will get extra space
- int total = 0;
+ int total = -1;
- const wxHtmlCell *c,
- *prev = NULL,
- *next = NULL;
- for ( c = line; c != cell; prev = c, c = next )
+ const wxHtmlCell *c;
+ if ( line != cell )
{
- next = c->GetNext();
- if ( c->IsLinebreakAllowed() &&
- (next == cell || next->IsLinebreakAllowed()) &&
- (!prev || prev->IsLinebreakAllowed()) )
+ for ( c = line; c != cell; c = c->GetNext() )
{
- total++;
+ if ( c->IsLinebreakAllowed() )
+ {
+ total++;
+ }
}
}
// and now extra space to those cells which merit it
if ( total )
{
- prev =
- next = NULL;
- for ( int n = 0; line != cell; prev = line, line = next )
+ // first visible cell on line is not moved:
+ while (line !=cell && !line->IsLinebreakAllowed())
{
- line->SetPos(line->GetPosX() + s_indent +
- ((n * step) / total),
- line->GetPosY() + ypos);
+ line->SetPos(line->GetPosX() + s_indent,
+ line->GetPosY() + ypos);
+ line = line->GetNext();
+ }
+
+ if (line != cell)
+ {
+ line->SetPos(line->GetPosX() + s_indent,
+ line->GetPosY() + ypos);
- next = line->GetNext();
- if ( line->IsLinebreakAllowed() &&
- (next == cell ||
- next->IsLinebreakAllowed()) &&
- (!prev || prev->IsLinebreakAllowed()) )
+ 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 // no extra space to distribute
+ // else branch:
+ if ( step <= 0 ) // no extra space to distribute
{
// just set the indent properly
while (line != cell)
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;
-
- m_LastLayout = w;
}
void wxHtmlContainerCell::UpdateRenderingStatePre(wxHtmlRenderingInfo& info,
dc.SetPen(*wxRED_PEN);
dc.DrawRectangle(x+m_PosX,y+m_PosY,m_Width,m_Height);
#endif
- // container visible, draw it:
- if ((y + m_PosY <= view_y2) && (y + m_PosY + m_Height > view_y1))
+
+ 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, wxBRUSHSTYLE_SOLID);
- 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, wxPENSTYLE_SOLID);
+ wxPen mypen2(m_BorderColour2, 1, wxPENSTYLE_SOLID);
+
+ 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);
- }
}
int wdi;
wxString wd = tag.GetParam(wxT("WIDTH"));
- if (wd[wd.Length()-1] == wxT('%'))
+ if (wd[wd.length()-1] == wxT('%'))
{
wxSscanf(wd.c_str(), wxT("%i%%"), &wdi);
SetWidthFloat(wdi, wxHTML_UNITS_PERCENT);
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::OnMouseClick(wxWindow *parent, int x, int y, const wxMouseEvent& event)
+bool wxHtmlContainerCell::ProcessMouseClick(wxHtmlWindowInterface *window,
+ const wxPoint& pos,
+ const wxMouseEvent& event)
{
- wxHtmlCell *cell = FindCellByPos(x, y);
- if ( cell )
- cell->OnMouseClick(parent, x, y, event);
+#if WXWIN_COMPATIBILITY_2_6
+ wxHtmlCellOnMouseClickCompatHelper compat(window, pos, event);
+ return compat.CallOnMouseClick(this);
}
+void wxHtmlContainerCell::OnMouseClick(wxWindow*,
+ int, int, const wxMouseEvent& event)
+{
+ wxCHECK_RET( gs_helperOnMouseClick, _T("unexpected call to OnMouseClick") );
+ wxHtmlWindowInterface *window = gs_helperOnMouseClick->window;
+ const wxPoint& pos = gs_helperOnMouseClick->pos;
+#endif // WXWIN_COMPATIBILITY_2_6
+
+ bool retval = false;
+ wxHtmlCell *cell = FindCellByPos(pos.x, pos.y);
+ if ( cell )
+ retval = cell->ProcessMouseClick(window, pos, event);
+
+#if WXWIN_COMPATIBILITY_2_6
+ gs_helperOnMouseClick->retval = retval;
+#else
+ return retval;
+#endif // WXWIN_COMPATIBILITY_2_6
+}
wxHtmlCell *wxHtmlContainerCell::GetFirstTerminal() const
}
void wxHtmlContainerCell::RemoveExtraSpacing(bool top, bool bottom)
-{
+{
if ( top )
SetIndent(0, wxHTML_INDENT_TOP);
if ( bottom )
}
}
}
-
+
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];
cont = (wxHtmlContainerCell*)c;
if ( IsEmptyContainer(cont) )
{
- cont->SetIndent(0, wxHTML_INDENT_VERTICAL); }
+ cont->SetIndent(0, wxHTML_INDENT_VERTICAL);
+ }
else
{
cont->RemoveExtraSpacing(false, true);
if (state.GetSelectionState() != wxHTML_SEL_IN)
{
dc.SetTextBackground(m_Colour);
- dc.SetBackground(wxBrush(m_Colour, wxSOLID));
+ dc.SetBackground(wxBrush(m_Colour, wxBRUSHSTYLE_SOLID));
}
else
{
wxColour c = info.GetStyle().GetSelectedTextBgColour(m_Colour);
dc.SetTextBackground(c);
- dc.SetBackground(wxBrush(c, wxSOLID));
+ dc.SetBackground(wxBrush(c, wxBRUSHSTYLE_SOLID));
}
}
}
c = c->GetParent();
}
- ((wxScrolledWindow*)(m_Wnd->GetParent()))->GetViewStart(&stx, &sty);
- m_Wnd->SetSize(absx - wxHTML_SCROLL_STEP * stx, absy - wxHTML_SCROLL_STEP * sty, m_Width, m_Height);
+ wxScrolledWindow *scrolwin =
+ wxDynamicCast(m_Wnd->GetParent(), wxScrolledWindow);
+ wxCHECK_RET( scrolwin,
+ _T("widget cells can only be placed in wxHtmlWindow") );
+
+ scrolwin->GetViewStart(&stx, &sty);
+ m_Wnd->SetSize(absx - wxHTML_SCROLL_STEP * stx,
+ absy - wxHTML_SCROLL_STEP * sty,
+ m_Width, m_Height);
}
return m_pos;
}
-
-
-
-
-
-
-//-----------------------------------------------------------------------------
-// Cleanup
-//-----------------------------------------------------------------------------
-
-class wxHtmlCellModule: public wxModule
-{
-DECLARE_DYNAMIC_CLASS(wxHtmlCellModule)
-public:
- wxHtmlCellModule() : wxModule() {}
- bool OnInit() { return true; }
- void OnExit()
- {
- wxDELETE(gs_cursorLink);
- wxDELETE(gs_cursorText);
- }
-};
-
-IMPLEMENT_DYNAMIC_CLASS(wxHtmlCellModule, wxModule)
-
#endif
projects / wxWidgets.git / blobdiff