/////////////////////////////////////////////////////////////////////////////
-// Name: htmlwin.cpp
+// Name: src/html/htmlwin.cpp
// Purpose: wxHtmlWindow class for parsing & displaying HTML (implementation)
// Author: Vaclav Slavik
// RCS-ID: $Id$
// Copyright: (c) 1999 Vaclav Slavik
-// Licence: wxWindows Licence
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-#pragma implementation "htmlwin.h"
-#pragma implementation "htmlproc.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/list.h"
#include "wx/log.h"
#include "wx/intl.h"
#include "wx/dcclient.h"
#include "wx/frame.h"
+ #include "wx/dcmemory.h"
+ #include "wx/timer.h"
+ #include "wx/settings.h"
+ #include "wx/dataobj.h"
#endif
#include "wx/html/htmlwin.h"
#include "wx/html/htmlproc.h"
-#include "wx/list.h"
#include "wx/clipbrd.h"
-#include "wx/dataobj.h"
-#include "wx/timer.h"
-#include "wx/dcmemory.h"
#include "wx/arrimpl.cpp"
#include "wx/listimpl.cpp"
+// HTML events:
+IMPLEMENT_DYNAMIC_CLASS(wxHtmlLinkEvent, wxCommandEvent)
+IMPLEMENT_DYNAMIC_CLASS(wxHtmlCellEvent, wxCommandEvent)
+
+DEFINE_EVENT_TYPE(wxEVT_COMMAND_HTML_CELL_CLICKED)
+DEFINE_EVENT_TYPE(wxEVT_COMMAND_HTML_CELL_HOVER)
+DEFINE_EVENT_TYPE(wxEVT_COMMAND_HTML_LINK_CLICKED)
#if wxUSE_CLIPBOARD
//-----------------------------------------------------------------------------
WX_DECLARE_OBJARRAY(wxHtmlHistoryItem, wxHtmlHistoryArray);
-WX_DEFINE_OBJARRAY(wxHtmlHistoryArray);
+WX_DEFINE_OBJARRAY(wxHtmlHistoryArray)
WX_DECLARE_LIST(wxHtmlProcessor, wxHtmlProcessorList);
-WX_DEFINE_LIST(wxHtmlProcessorList);
+WX_DEFINE_LIST(wxHtmlProcessorList)
+
+//-----------------------------------------------------------------------------
+// wxHtmlWindowMouseHelper
+//-----------------------------------------------------------------------------
+
+wxHtmlWindowMouseHelper::wxHtmlWindowMouseHelper(wxHtmlWindowInterface *iface)
+ : m_tmpMouseMoved(false),
+ m_tmpLastLink(NULL),
+ m_tmpLastCell(NULL),
+ m_interface(iface)
+{
+}
+
+void wxHtmlWindowMouseHelper::HandleMouseMoved()
+{
+ m_tmpMouseMoved = true;
+}
+
+bool wxHtmlWindowMouseHelper::HandleMouseClick(wxHtmlCell *rootCell,
+ const wxPoint& pos,
+ const wxMouseEvent& event)
+{
+ if (!rootCell)
+ return false;
+
+ wxHtmlCell *cell = rootCell->FindCellByPos(pos.x, pos.y);
+ // this check is needed because FindCellByPos returns terminal cell and
+ // containers may have empty borders -- in this case NULL will be
+ // returned
+ if (!cell)
+ return false;
+
+ // adjust the coordinates to be relative to this cell:
+ wxPoint relpos = pos - cell->GetAbsPos(rootCell);
+
+ return OnCellClicked(cell, relpos.x, relpos.y, event);
+}
+
+void wxHtmlWindowMouseHelper::HandleIdle(wxHtmlCell *rootCell,
+ const wxPoint& pos)
+{
+ wxHtmlCell *cell = rootCell ? rootCell->FindCellByPos(pos.x, pos.y) : NULL;
+
+ if (cell != m_tmpLastCell)
+ {
+ wxHtmlLinkInfo *lnk = NULL;
+ if (cell)
+ {
+ // adjust the coordinates to be relative to this cell:
+ wxPoint relpos = pos - cell->GetAbsPos(rootCell);
+ lnk = cell->GetLink(relpos.x, relpos.y);
+ }
+
+ wxCursor cur;
+ if (cell)
+ cur = cell->GetMouseCursor(m_interface);
+ else
+ cur = m_interface->GetHTMLCursor(
+ wxHtmlWindowInterface::HTMLCursor_Default);
+
+ m_interface->GetHTMLWindow()->SetCursor(cur);
+
+ if (lnk != m_tmpLastLink)
+ {
+ if (lnk)
+ m_interface->SetHTMLStatusText(lnk->GetHref());
+ else
+ m_interface->SetHTMLStatusText(wxEmptyString);
+
+ m_tmpLastLink = lnk;
+ }
+
+ m_tmpLastCell = cell;
+ }
+ else // mouse moved but stayed in the same cell
+ {
+ if ( cell )
+ {
+ OnCellMouseHover(cell, pos.x, pos.y);
+ }
+ }
+
+ m_tmpMouseMoved = false;
+}
+
+bool wxHtmlWindowMouseHelper::OnCellClicked(wxHtmlCell *cell,
+ wxCoord x, wxCoord y,
+ const wxMouseEvent& event)
+{
+ wxHtmlCellEvent ev(wxEVT_COMMAND_HTML_CELL_CLICKED,
+ m_interface->GetHTMLWindow()->GetId(),
+ cell, wxPoint(x,y), event);
+
+ if (!m_interface->GetHTMLWindow()->GetEventHandler()->ProcessEvent(ev))
+ {
+ // if the event wasn't handled, do the default processing here:
+
+ wxASSERT_MSG( cell, _T("can't be called with NULL cell") );
+
+ cell->ProcessMouseClick(m_interface, ev.GetPoint(), ev.GetMouseEvent());
+ }
+
+ // true if a link was clicked, false otherwise
+ return ev.GetLinkClicked();
+}
+
+void wxHtmlWindowMouseHelper::OnCellMouseHover(wxHtmlCell * cell,
+ wxCoord x,
+ wxCoord y)
+{
+ wxHtmlCellEvent ev(wxEVT_COMMAND_HTML_CELL_HOVER,
+ m_interface->GetHTMLWindow()->GetId(),
+ cell, wxPoint(x,y), wxMouseEvent());
+ m_interface->GetHTMLWindow()->GetEventHandler()->ProcessEvent(ev);
+}
+
+
+
//-----------------------------------------------------------------------------
// wxHtmlWindow
//-----------------------------------------------------------------------------
+wxList wxHtmlWindow::m_Filters;
+wxHtmlFilter *wxHtmlWindow::m_DefaultFilter = NULL;
+wxHtmlProcessorList *wxHtmlWindow::m_GlobalProcessors = NULL;
+wxCursor *wxHtmlWindow::ms_cursorLink = NULL;
+wxCursor *wxHtmlWindow::ms_cursorText = NULL;
+
+void wxHtmlWindow::CleanUpStatics()
+{
+ wxDELETE(m_DefaultFilter);
+ WX_CLEAR_LIST(wxList, m_Filters);
+ if (m_GlobalProcessors)
+ WX_CLEAR_LIST(wxHtmlProcessorList, *m_GlobalProcessors);
+ wxDELETE(m_GlobalProcessors);
+ wxDELETE(ms_cursorLink);
+ wxDELETE(ms_cursorText);
+}
void wxHtmlWindow::Init()
{
- m_tmpMouseMoved = FALSE;
- m_tmpLastLink = NULL;
- m_tmpLastCell = NULL;
m_tmpCanDrawLocks = 0;
m_FS = new wxFileSystem();
+#if wxUSE_STATUSBAR
m_RelatedStatusBar = -1;
+#endif // wxUSE_STATUSBAR
m_RelatedFrame = NULL;
m_TitleFormat = wxT("%s");
m_OpenedPage = m_OpenedAnchor = m_OpenedPageTitle = wxEmptyString;
m_Parser = new wxHtmlWinParser(this);
m_Parser->SetFS(m_FS);
m_HistoryPos = -1;
- m_HistoryOn = TRUE;
+ m_HistoryOn = true;
m_History = new wxHtmlHistoryArray;
m_Processors = NULL;
- m_Style = 0;
SetBorders(10);
m_selection = NULL;
m_makingSelection = false;
m_lastDoubleClick = 0;
#endif // wxUSE_CLIPBOARD
m_backBuffer = NULL;
+ m_eraseBgInOnPaint = false;
+ m_tmpSelFromCell = NULL;
}
bool wxHtmlWindow::Create(wxWindow *parent, wxWindowID id,
if (!wxScrolledWindow::Create(parent, id, pos, size,
style | wxVSCROLL | wxHSCROLL,
name))
- return FALSE;
+ return false;
- m_Style = style;
SetPage(wxT("<html><body></body></html>"));
- return TRUE;
+ return true;
}
+#if wxUSE_STATUSBAR
void wxHtmlWindow::SetRelatedStatusBar(int bar)
{
m_RelatedStatusBar = bar;
}
+#endif // wxUSE_STATUSBAR
-void wxHtmlWindow::SetFonts(wxString normal_face, wxString fixed_face, const int *sizes)
+void wxHtmlWindow::SetFonts(const wxString& normal_face, const wxString& fixed_face, const int *sizes)
{
- wxString op = m_OpenedPage;
-
m_Parser->SetFonts(normal_face, fixed_face, sizes);
- // fonts changed => contents invalid, so reload the page:
- SetPage(wxT("<html><body></body></html>"));
- if (!op.IsEmpty()) LoadPage(op);
+
+ // re-layout the page after changing fonts:
+ DoSetPage(*(m_Parser->GetSource()));
}
+void wxHtmlWindow::SetStandardFonts(int size,
+ const wxString& normal_face,
+ const wxString& fixed_face)
+{
+ m_Parser->SetStandardFonts(size, normal_face, fixed_face);
+ // re-layout the page after changing fonts:
+ DoSetPage(*(m_Parser->GetSource()));
+}
bool wxHtmlWindow::SetPage(const wxString& source)
+{
+ m_OpenedPage = m_OpenedAnchor = m_OpenedPageTitle = wxEmptyString;
+ return DoSetPage(source);
+}
+
+bool wxHtmlWindow::DoSetPage(const wxString& source)
{
wxString newsrc(source);
wxDELETE(m_selection);
+ // we will soon delete all the cells, so clear pointers to them:
+ m_tmpSelFromCell = NULL;
+
// pass HTML through registered processors:
if (m_Processors || m_GlobalProcessors)
{
wxHtmlProcessorList::compatibility_iterator nodeL, nodeG;
int prL, prG;
- nodeL = (m_Processors) ? m_Processors->GetFirst() : wxHtmlProcessorList::compatibility_iterator();
- nodeG = (m_GlobalProcessors) ? m_GlobalProcessors->GetFirst() : wxHtmlProcessorList::compatibility_iterator();
+ if ( m_Processors )
+ nodeL = m_Processors->GetFirst();
+ if ( m_GlobalProcessors )
+ nodeG = m_GlobalProcessors->GetFirst();
// VS: there are two lists, global and local, both of them sorted by
// priority. Since we have to go through _both_ lists with
wxClientDC *dc = new wxClientDC(this);
dc->SetMapMode(wxMM_TEXT);
SetBackgroundColour(wxColour(0xFF, 0xFF, 0xFF));
- m_OpenedPage = m_OpenedAnchor = m_OpenedPageTitle = wxEmptyString;
+ SetBackgroundImage(wxNullBitmap);
+
m_Parser->SetDC(dc);
if (m_Cell)
{
CreateLayout();
if (m_tmpCanDrawLocks == 0)
Refresh();
- return TRUE;
+ return true;
}
bool wxHtmlWindow::AppendToPage(const wxString& source)
{
- return SetPage(*(GetParser()->GetSource()) + source);
+ return DoSetPage(*(GetParser()->GetSource()) + source);
}
bool wxHtmlWindow::LoadPage(const wxString& location)
wxFSFile *f;
bool rt_val;
- bool needs_refresh = FALSE;
+ bool needs_refresh = false;
m_tmpCanDrawLocks++;
if (m_HistoryOn && (m_HistoryPos != -1))
else
{
- needs_refresh = TRUE;
+ needs_refresh = true;
+#if wxUSE_STATUSBAR
// load&display it:
if (m_RelatedStatusBar != -1)
{
m_RelatedFrame->SetStatusText(_("Connecting..."), m_RelatedStatusBar);
- Refresh(FALSE);
+ Refresh(false);
}
+#endif // wxUSE_STATUSBAR
f = m_Parser->OpenURL(wxHTML_URL_PAGE, location);
{
wxLogError(_("Unable to open requested HTML document: %s"), location.c_str());
m_tmpCanDrawLocks--;
- return FALSE;
+ return false;
}
else
wxList::compatibility_iterator node;
wxString src = wxEmptyString;
+#if wxUSE_STATUSBAR
if (m_RelatedStatusBar != -1)
{
wxString msg = _("Loading : ") + location;
m_RelatedFrame->SetStatusText(msg, m_RelatedStatusBar);
- Refresh(FALSE);
+ Refresh(false);
}
+#endif // wxUSE_STATUSBAR
node = m_Filters.GetFirst();
while (node)
delete f;
- if (m_RelatedStatusBar != -1) m_RelatedFrame->SetStatusText(_("Done"), m_RelatedStatusBar);
+#if wxUSE_STATUSBAR
+ if (m_RelatedStatusBar != -1)
+ m_RelatedFrame->SetStatusText(_("Done"), m_RelatedStatusBar);
+#endif // wxUSE_STATUSBAR
}
}
if (!c)
{
wxLogWarning(_("HTML anchor %s does not exist."), anchor.c_str());
- return FALSE;
+ return false;
}
else
{
for (y = 0; c != NULL; c = c->GetParent()) y += c->GetPosY();
Scroll(-1, y / wxHTML_SCROLL_STEP);
m_OpenedAnchor = anchor;
- return TRUE;
+ return true;
}
}
if (!m_Cell) return;
- if (m_Style & wxHW_SCROLLBAR_NEVER)
+ if ( HasFlag(wxHW_SCROLLBAR_NEVER) )
{
- SetScrollbars(wxHTML_SCROLL_STEP, 1, m_Cell->GetWidth() / wxHTML_SCROLL_STEP, 0); // always off
+ SetScrollbars(1, 1, 0, 0); // always off
GetClientSize(&ClientWidth, &ClientHeight);
m_Cell->Layout(ClientWidth);
}
-
- else {
+ else // !wxHW_SCROLLBAR_NEVER
+ {
GetClientSize(&ClientWidth, &ClientHeight);
m_Cell->Layout(ClientWidth);
if (ClientHeight < m_Cell->GetHeight() + GetCharHeight())
{
wxString a, l;
- if (m_HistoryPos < 1) return FALSE;
+ if (m_HistoryPos < 1) return false;
// store scroll position into history item:
int x, y;
l = (*m_History)[m_HistoryPos].GetPage();
a = (*m_History)[m_HistoryPos].GetAnchor();
- m_HistoryOn = FALSE;
+ m_HistoryOn = false;
m_tmpCanDrawLocks++;
if (a == wxEmptyString) LoadPage(l);
else LoadPage(l + wxT("#") + a);
- m_HistoryOn = TRUE;
+ m_HistoryOn = true;
m_tmpCanDrawLocks--;
Scroll(0, (*m_History)[m_HistoryPos].GetPos());
Refresh();
- return TRUE;
+ return true;
}
bool wxHtmlWindow::HistoryCanBack()
{
- if (m_HistoryPos < 1) return FALSE;
- return TRUE ;
+ if (m_HistoryPos < 1) return false;
+ return true ;
}
{
wxString a, l;
- if (m_HistoryPos == -1) return FALSE;
- if (m_HistoryPos >= (int)m_History->GetCount() - 1)return FALSE;
+ if (m_HistoryPos == -1) return false;
+ if (m_HistoryPos >= (int)m_History->GetCount() - 1)return false;
m_OpenedPage = wxEmptyString; // this will disable adding new entry into history in LoadPage()
m_HistoryPos++;
l = (*m_History)[m_HistoryPos].GetPage();
a = (*m_History)[m_HistoryPos].GetAnchor();
- m_HistoryOn = FALSE;
+ m_HistoryOn = false;
m_tmpCanDrawLocks++;
if (a == wxEmptyString) LoadPage(l);
else LoadPage(l + wxT("#") + a);
- m_HistoryOn = TRUE;
+ m_HistoryOn = true;
m_tmpCanDrawLocks--;
Scroll(0, (*m_History)[m_HistoryPos].GetPos());
Refresh();
- return TRUE;
+ return true;
}
bool wxHtmlWindow::HistoryCanForward()
{
- if (m_HistoryPos == -1) return FALSE;
- if (m_HistoryPos >= (int)m_History->GetCount() - 1)return FALSE;
- return TRUE ;
+ if (m_HistoryPos == -1) return false;
+ if (m_HistoryPos >= (int)m_History->GetCount() - 1)return false;
+ return true ;
}
-wxList wxHtmlWindow::m_Filters;
-wxHtmlFilter *wxHtmlWindow::m_DefaultFilter = NULL;
-wxHtmlProcessorList *wxHtmlWindow::m_GlobalProcessors = NULL;
-
-void wxHtmlWindow::CleanUpStatics()
-{
- wxDELETE(m_DefaultFilter);
- WX_CLEAR_LIST(wxList, m_Filters);
- if (m_GlobalProcessors)
- WX_CLEAR_LIST(wxHtmlProcessorList, *m_GlobalProcessors);
- wxDELETE(m_GlobalProcessors);
-}
-
-
-
void wxHtmlWindow::AddFilter(wxHtmlFilter *filter)
{
m_Filters.Append(filter);
bool wxHtmlWindow::IsSelectionEnabled() const
{
#if wxUSE_CLIPBOARD
- return !(m_Style & wxHW_NO_SELECTION);
+ return !HasFlag(wxHW_NO_SELECTION);
#else
return false;
#endif
#if wxUSE_CLIPBOARD
-wxString wxHtmlWindow::SelectionToText()
+wxString wxHtmlWindow::DoSelectionToText(wxHtmlSelection *sel)
{
- if ( !m_selection )
+ if ( !sel )
return wxEmptyString;
wxClientDC dc(this);
- const wxHtmlCell *end = m_selection->GetToCell();
+ const wxHtmlCell *end = sel->GetToCell();
wxString text;
- wxHtmlTerminalCellsInterator i(m_selection->GetFromCell(), end);
+ wxHtmlTerminalCellsInterator i(sel->GetFromCell(), end);
if ( i )
{
- text << i->ConvertToText(m_selection);
+ text << i->ConvertToText(sel);
++i;
}
const wxHtmlCell *prev = *i;
{
if ( prev->GetParent() != i->GetParent() )
text << _T('\n');
- text << i->ConvertToText(*i == end ? m_selection : NULL);
+ text << i->ConvertToText(*i == end ? sel : NULL);
prev = *i;
++i;
}
return text;
}
+wxString wxHtmlWindow::ToText()
+{
+ if (m_Cell)
+ {
+ wxHtmlSelection sel;
+ sel.Set(m_Cell->GetFirstTerminal(), m_Cell->GetLastTerminal());
+ return DoSelectionToText(&sel);
+ }
+ else
+ return wxEmptyString;
+}
+
#endif // wxUSE_CLIPBOARD
bool wxHtmlWindow::CopySelection(ClipboardType t)
#if wxUSE_CLIPBOARD
if ( m_selection )
{
-#ifdef __UNIX__
+#if defined(__UNIX__) && !defined(__WXMAC__)
wxTheClipboard->UsePrimarySelection(t == Primary);
#else // !__UNIX__
// Primary selection exists only under X11, so don't do anything under
return true;
}
}
+#else
+ wxUnusedVar(t);
#endif // wxUSE_CLIPBOARD
return false;
void wxHtmlWindow::OnLinkClicked(const wxHtmlLinkInfo& link)
{
- const wxMouseEvent *e = link.GetEvent();
- if (e == NULL || e->LeftUp())
- LoadPage(link.GetHref());
+ wxHtmlLinkEvent event(GetId(), link);
+ event.SetEventObject(this);
+ if (!GetEventHandler()->ProcessEvent(event))
+ {
+ // the default behaviour is to load the URL in this window
+ const wxMouseEvent *e = event.GetLinkInfo().GetEvent();
+ if (e == NULL || e->LeftUp())
+ LoadPage(event.GetLinkInfo().GetHref());
+ }
}
-void wxHtmlWindow::OnCellClicked(wxHtmlCell *cell,
- wxCoord x, wxCoord y,
- const wxMouseEvent& event)
+void wxHtmlWindow::OnEraseBackground(wxEraseEvent& event)
{
- wxCHECK_RET( cell, _T("can't be called with NULL cell") );
+ if ( !m_bmpBg.Ok() )
+ {
+ // don't even skip the event, if we don't have a bg bitmap we're going
+ // to overwrite background in OnPaint() below anyhow, so letting the
+ // default handling take place would only result in flicker, just set a
+ // flag to erase the background below
+ m_eraseBgInOnPaint = true;
+ return;
+ }
- cell->OnMouseClick(this, x, y, event);
-}
+ wxDC& dc = *event.GetDC();
-void wxHtmlWindow::OnCellMouseHover(wxHtmlCell * WXUNUSED(cell),
- wxCoord WXUNUSED(x), wxCoord WXUNUSED(y))
-{
- // do nothing here
-}
+ // if the image is not fully opaque, we have to erase the background before
+ // drawing it, however avoid doing it for opaque images as this would just
+ // result in extra flicker without any other effect as background is
+ // completely covered anyhow
+ if ( m_bmpBg.GetMask() )
+ {
+ dc.SetBackground(wxBrush(GetBackgroundColour(), wxSOLID));
+ dc.Clear();
+ }
-void wxHtmlWindow::OnEraseBackground(wxEraseEvent& WXUNUSED(event))
-{
+ const wxSize sizeWin(GetClientSize());
+ const wxSize sizeBmp(m_bmpBg.GetWidth(), m_bmpBg.GetHeight());
+ for ( wxCoord x = 0; x < sizeWin.x; x += sizeBmp.x )
+ {
+ for ( wxCoord y = 0; y < sizeWin.y; y += sizeBmp.y )
+ {
+ dc.DrawBitmap(m_bmpBg, x, y, true /* use mask */);
+ }
+ }
}
void wxHtmlWindow::OnPaint(wxPaintEvent& WXUNUSED(event))
{
wxPaintDC dc(this);
- if (m_tmpCanDrawLocks > 0 || m_Cell == NULL) return;
+ if (m_tmpCanDrawLocks > 0 || m_Cell == NULL)
+ return;
int x, y;
GetViewStart(&x, &y);
if ( !m_backBuffer )
m_backBuffer = new wxBitmap(sz.x, sz.y);
dcm.SelectObject(*m_backBuffer);
- dcm.SetBackground(wxBrush(GetBackgroundColour(), wxSOLID));
- dcm.Clear();
+
+ if ( m_eraseBgInOnPaint )
+ {
+ dcm.SetBackground(wxBrush(GetBackgroundColour(), wxSOLID));
+ dcm.Clear();
+
+ m_eraseBgInOnPaint = false;
+ }
+ else // someone has already erased the background, keep it
+ {
+ // preserve the existing background, otherwise we'd erase anything the
+ // user code had drawn in its EVT_ERASE_BACKGROUND handler when we do
+ // the Blit back below
+ dcm.Blit(0, rect.GetTop(),
+ sz.x, rect.GetBottom() - rect.GetTop() + 1,
+ &dc,
+ 0, rect.GetTop());
+ }
+
PrepareDC(dcm);
dcm.SetMapMode(wxMM_TEXT);
dcm.SetBackgroundMode(wxTRANSPARENT);
y * wxHTML_SCROLL_STEP + rect.GetTop(),
y * wxHTML_SCROLL_STEP + rect.GetBottom(),
rinfo);
-
-//#define DEBUG_HTML_SELECTION
+
+//#define DEBUG_HTML_SELECTION
#ifdef DEBUG_HTML_SELECTION
{
int xc, yc, x, y;
ScreenToClient(&xc, &yc);
CalcUnscrolledPosition(xc, yc, &x, &y);
wxHtmlCell *at = m_Cell->FindCellByPos(x, y);
- wxHtmlCell *before =
+ wxHtmlCell *before =
m_Cell->FindCellByPos(x, y, wxHTML_FIND_NEAREST_BEFORE);
- wxHtmlCell *after =
+ wxHtmlCell *after =
m_Cell->FindCellByPos(x, y, wxHTML_FIND_NEAREST_AFTER);
-
+
dcm.SetBrush(*wxTRANSPARENT_BRUSH);
dcm.SetPen(*wxBLACK_PEN);
if (at)
after->GetWidth()-4,after->GetHeight()-4);
}
#endif
-
+
dcm.SetDeviceOrigin(0,0);
dc.Blit(0, rect.GetTop(),
sz.x, rect.GetBottom() - rect.GetTop() + 1,
void wxHtmlWindow::OnMouseMove(wxMouseEvent& WXUNUSED(event))
{
- m_tmpMouseMoved = true;
+ wxHtmlWindowMouseHelper::HandleMouseMoved();
}
void wxHtmlWindow::OnMouseDown(wxMouseEvent& event)
}
}
#endif // wxUSE_CLIPBOARD
+
+ // in any case, let the default handler set focus to this window
+ event.Skip();
}
void wxHtmlWindow::OnMouseUp(wxMouseEvent& event)
ReleaseMouse();
m_makingSelection = false;
- // did the user move the mouse far enough from starting point?
- if ( CopySelection(Primary) )
+ // if m_selection=NULL, the user didn't move the mouse far enough from
+ // starting point and the mouse up event is part of a click, the user
+ // is not selecting text:
+ if ( m_selection )
{
+ CopySelection(Primary);
+
// we don't want mouse up event that ended selecting to be
// handled as mouse click and e.g. follow hyperlink:
return;
}
#endif // wxUSE_CLIPBOARD
- SetFocus();
- if ( m_Cell )
- {
- wxPoint pos = CalcUnscrolledPosition(event.GetPosition());
- wxHtmlCell *cell = m_Cell->FindCellByPos(pos.x, pos.y);
-
- // check is needed because FindCellByPos returns terminal cell and
- // containers may have empty borders -- in this case NULL will be
- // returned
- if ( cell )
- OnCellClicked(cell, pos.x, pos.y, event);
- }
+ wxPoint pos = CalcUnscrolledPosition(event.GetPosition());
+ wxHtmlWindowMouseHelper::HandleMouseClick(m_Cell, pos, event);
}
+#if wxUSE_CLIPBOARD
+void wxHtmlWindow::OnMouseCaptureLost(wxMouseCaptureLostEvent& WXUNUSED(event))
+{
+ if ( !m_makingSelection )
+ return;
+
+ // discard the selecting operation
+ m_makingSelection = false;
+ wxDELETE(m_selection);
+ m_tmpSelFromCell = NULL;
+ Refresh();
+}
+#endif // wxUSE_CLIPBOARD
void wxHtmlWindow::OnInternalIdle()
{
wxWindow::OnInternalIdle();
-
- if (m_tmpMouseMoved && (m_Cell != NULL))
+
+ if (m_Cell != NULL && DidMouseMove())
{
#ifdef DEBUG_HTML_SELECTION
Refresh();
if ( !m_tmpSelFromCell )
m_tmpSelFromCell = m_Cell->FindCellByPos(
m_tmpSelFromPos.x,m_tmpSelFromPos.y);
-
+
// NB: a trick - we adjust selFromPos to be upper left or bottom
// right corner of the first cell of the selection depending
// on whether the mouse is moving to the right or to the left.
dirFromPos.y += m_tmpSelFromCell->GetHeight();
}
}
- bool goingDown = dirFromPos.y < y ||
+ bool goingDown = dirFromPos.y < y ||
(dirFromPos.y == y && dirFromPos.x < x);
// determine selection span:
if ( m_tmpSelFromCell->IsBefore(selcell) )
{
m_selection->Set(m_tmpSelFromPos, m_tmpSelFromCell,
- wxPoint(x,y), selcell); }
+ wxPoint(x,y), selcell);
+ }
else
{
m_selection->Set(wxPoint(x,y), selcell,
}
// handle cursor and status bar text changes:
- if ( cell != m_tmpLastCell )
- {
- wxHtmlLinkInfo *lnk = cell ? cell->GetLink(x, y) : NULL;
- wxCursor cur;
- if (cell)
- cur = cell->GetCursor();
- else
- cur = *wxSTANDARD_CURSOR;
- SetCursor(cur);
- if (lnk != m_tmpLastLink)
- {
- if (lnk == NULL)
- {
- if (m_RelatedStatusBar != -1)
- m_RelatedFrame->SetStatusText(wxEmptyString,
- m_RelatedStatusBar);
- }
- else
- {
- if (m_RelatedStatusBar != -1)
- m_RelatedFrame->SetStatusText(lnk->GetHref(),
- m_RelatedStatusBar);
- }
- m_tmpLastLink = lnk;
- }
-
- m_tmpLastCell = cell;
- }
- else // mouse moved but stayed in the same cell
- {
- if ( cell )
- OnCellMouseHover(cell, x, y);
- }
-
- m_tmpMouseMoved = FALSE;
+ // NB: because we're passing in 'cell' and not 'm_Cell' (so that the
+ // leaf cell lookup isn't done twice), we need to adjust the
+ // position for the new root:
+ wxPoint posInCell(x, y);
+ if (cell)
+ posInCell -= cell->GetAbsPos();
+ wxHtmlWindowMouseHelper::HandleIdle(cell, posInCell);
}
}
void wxHtmlWindow::OnKeyUp(wxKeyEvent& event)
{
if ( IsSelectionEnabled() &&
- event.GetKeyCode() == 'C' && event.ControlDown() )
+ (event.GetKeyCode() == 'C' && event.CmdDown()) )
{
- (void) CopySelection();
+ wxClipboardTextEvent evt(wxEVT_COMMAND_TEXT_COPY, GetId());
+
+ evt.SetEventObject(this);
+
+ GetEventHandler()->ProcessEvent(evt);
}
}
(void) CopySelection();
}
+void wxHtmlWindow::OnClipboardEvent(wxClipboardTextEvent& WXUNUSED(event))
+{
+ (void) CopySelection();
+}
+
void wxHtmlWindow::OnDoubleClick(wxMouseEvent& event)
{
// select word under cursor:
wxBEGIN_PROPERTIES_TABLE(wxHtmlWindow)
/*
- TODO PROPERTIES
- style , wxHW_SCROLLBAR_AUTO
- borders , (dimension)
- url , string
- htmlcode , string
+ TODO PROPERTIES
+ style , wxHW_SCROLLBAR_AUTO
+ borders , (dimension)
+ url , string
+ htmlcode , string
*/
wxEND_PROPERTIES_TABLE()
wxBEGIN_HANDLERS_TABLE(wxHtmlWindow)
wxEND_HANDLERS_TABLE()
-wxCONSTRUCTOR_5( wxHtmlWindow , wxWindow* , Parent , wxWindowID , Id , wxPoint , Position , wxSize , Size , long , WindowStyle )
+wxCONSTRUCTOR_5( wxHtmlWindow , wxWindow* , Parent , wxWindowID , Id , wxPoint , Position , wxSize , Size , long , WindowStyle )
#else
IMPLEMENT_DYNAMIC_CLASS(wxHtmlWindow,wxScrolledWindow)
#endif
EVT_LEFT_DCLICK(wxHtmlWindow::OnDoubleClick)
EVT_ENTER_WINDOW(wxHtmlWindow::OnMouseEnter)
EVT_LEAVE_WINDOW(wxHtmlWindow::OnMouseLeave)
+ EVT_MOUSE_CAPTURE_LOST(wxHtmlWindow::OnMouseCaptureLost)
EVT_KEY_UP(wxHtmlWindow::OnKeyUp)
EVT_MENU(wxID_COPY, wxHtmlWindow::OnCopy)
+ EVT_TEXT_COPY(wxID_ANY, wxHtmlWindow::OnClipboardEvent)
#endif // wxUSE_CLIPBOARD
END_EVENT_TABLE()
+//-----------------------------------------------------------------------------
+// wxHtmlWindowInterface implementation in wxHtmlWindow
+//-----------------------------------------------------------------------------
+
+void wxHtmlWindow::SetHTMLWindowTitle(const wxString& title)
+{
+ OnSetTitle(title);
+}
+
+void wxHtmlWindow::OnHTMLLinkClicked(const wxHtmlLinkInfo& link)
+{
+ OnLinkClicked(link);
+}
+
+wxHtmlOpeningStatus wxHtmlWindow::OnHTMLOpeningURL(wxHtmlURLType type,
+ const wxString& url,
+ wxString *redirect) const
+{
+ return OnOpeningURL(type, url, redirect);
+}
+
+wxPoint wxHtmlWindow::HTMLCoordsToWindow(wxHtmlCell *WXUNUSED(cell),
+ const wxPoint& pos) const
+{
+ return CalcScrolledPosition(pos);
+}
+
+wxWindow* wxHtmlWindow::GetHTMLWindow()
+{
+ return this;
+}
+
+wxColour wxHtmlWindow::GetHTMLBackgroundColour() const
+{
+ return GetBackgroundColour();
+}
+void wxHtmlWindow::SetHTMLBackgroundColour(const wxColour& clr)
+{
+ SetBackgroundColour(clr);
+}
+void wxHtmlWindow::SetHTMLBackgroundImage(const wxBitmap& bmpBg)
+{
+ SetBackgroundImage(bmpBg);
+}
+void wxHtmlWindow::SetHTMLStatusText(const wxString& text)
+{
+#if wxUSE_STATUSBAR
+ if (m_RelatedStatusBar != -1)
+ m_RelatedFrame->SetStatusText(text, m_RelatedStatusBar);
+#else
+ wxUnusedVar(text);
+#endif // wxUSE_STATUSBAR
+}
+
+/*static*/
+wxCursor wxHtmlWindow::GetDefaultHTMLCursor(HTMLCursor type)
+{
+ switch (type)
+ {
+ case HTMLCursor_Link:
+ if ( !ms_cursorLink )
+ ms_cursorLink = new wxCursor(wxCURSOR_HAND);
+ return *ms_cursorLink;
+
+ case HTMLCursor_Text:
+ if ( !ms_cursorText )
+ ms_cursorText = new wxCursor(wxCURSOR_IBEAM);
+ return *ms_cursorText;
+
+ case HTMLCursor_Default:
+ default:
+ return *wxSTANDARD_CURSOR;
+ }
+}
+
+wxCursor wxHtmlWindow::GetHTMLCursor(HTMLCursor type) const
+{
+ return GetDefaultHTMLCursor(type);
+}
+
+
+//-----------------------------------------------------------------------------
+// wxHtmlWinModule
+//-----------------------------------------------------------------------------
// A module to allow initialization/cleanup
// without calling these functions from app.cpp or from
DECLARE_DYNAMIC_CLASS(wxHtmlWinModule)
public:
wxHtmlWinModule() : wxModule() {}
- bool OnInit() { return TRUE; }
+ bool OnInit() { return true; }
void OnExit() { wxHtmlWindow::CleanUpStatics(); }
};
FORCE_WXHTML_MODULES()
#endif // wxUSE_HTML
-
projects / wxWidgets.git / blobdiff