File indexing completed on 2023-05-30 09:09:58

 /* This file is part of the KDE project
  *
  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
  *                     1999 Lars Knoll <knoll@kde.org>
  *                     1999 Antti Koivisto <koivisto@kde.org>
  *                     2000-2004 Dirk Mueller <mueller@kde.org>
  *                     2003 Leo Savernik <l.savernik@aon.at>
  *                     2003-2008 Apple Computer, Inc.
  *                     2008 Allan Sandfeld Jensen <kde@carewolf.com>
  *                     2006-2008 Germain Garand <germain@ebooksfrance.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "khtmlview.h"
 
 #include "khtml_part.h"
 #include "khtml_events.h"
 #include <config-khtml.h>
 #if HAVE_X11
 #include <qx11info_x11.h>
 #endif
 
 #include "html/html_documentimpl.h"
 #include "html/html_inlineimpl.h"
 #include "html/html_formimpl.h"
 #include "html/htmltokenizer.h"
 #include "editing/editor.h"
 #include "rendering/render_arena.h"
 #include "rendering/render_canvas.h"
 #include "rendering/render_frames.h"
 #include "rendering/render_replaced.h"
 #include "rendering/render_form.h"
 #include "rendering/render_layer.h"
 #include "rendering/render_line.h"
 #include "rendering/render_table.h"
 // removeme
 #define protected public
 #include "rendering/render_text.h"
 #undef protected
 #include "xml/dom2_eventsimpl.h"
 #include "css/cssstyleselector.h"
 #include "misc/loader.h"
 #include "khtml_settings.h"
 #include "khtml_printsettings.h"
 
 #include "khtmlpart_p.h"
 
 #include <kcursor.h>
 #include "khtml_debug.h"
 #include <kiconloader.h>
 #include <knotification.h>
 #include <kconfig.h>
 #include <../khtml_version.h>
 
 #include <kstringhandler.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 #include <KWindowSystem>
 
 #include <QBitmap>
 #include <QDialog>
 #include <QDialogButtonBox>
 #include <QLabel>
 #include <QKeyEvent>
 #include <QObject>
 #include <QPainter>
 #include <QHash>
 #include <QToolTip>
 #include <QString>
 #include <QTextDocument>
 #include <QTimer>
 #include <QAbstractEventDispatcher>
 #include <QVector>
 #include <QAbstractScrollArea>
 #include <QPrinter>
 #include <QPrintDialog>
 #include <qstandardpaths.h>
 
 //#define DEBUG_FLICKER
 
 #include <limits.h>
 #if HAVE_X11
 #include <X11/Xlib.h>
 #include <fixx11h.h>
 #elif defined(Q_OS_WIN)
 #include <windows.h>
 #endif
 
 #if 0
 namespace khtml
 {
 void dumpLineBoxes(RenderFlow *flow);
 }
 #endif
 
 using namespace DOM;
 using namespace khtml;
 
 #ifndef NDEBUG
 static const int sFirstLayoutDelay = 520;
 static const int sParsingLayoutsInterval = 380;
 static const int sLayoutAttemptDelay = 300;
 #else
 static const int sFirstLayoutDelay = 280;
 static const int sParsingLayoutsInterval = 320;
 static const int sLayoutAttemptDelay = 200;
 #endif
 static const int sLayoutAttemptIncrement = 20;
 static const int sParsingLayoutsIncrement = 60;
 
 static const int sSmoothScrollTime = 128;
 static const int sSmoothScrollTick = 16;
 static const int sSmoothScrollMinStaticPixels = 320 * 200;
 
 static const int sMaxMissedDeadlines = 12;
 static const int sWayTooMany = -1;
 
 class KHTMLViewPrivate
 {
     friend class KHTMLView;
 public:
 
     enum PseudoFocusNodes {
         PFNone,
         PFTop,
         PFBottom
     };
 
     enum StaticBackgroundState {
         SBNone = 0,
         SBPartial,
         SBFull
     };
 
     enum CompletedState {
         CSNone = 0,
         CSFull,
         CSActionPending
     };
 
     KHTMLViewPrivate(KHTMLView *v)
         : underMouse(nullptr), underMouseNonShared(nullptr), oldUnderMouse(nullptr)
     {
         postponed_autorepeat = nullptr;
         scrollingFromWheelTimerId = 0;
         smoothScrollMode = KHTMLView::SSMWhenEfficient;
 
         reset();
         vpolicy = Qt::ScrollBarAsNeeded;
         hpolicy = Qt::ScrollBarAsNeeded;
         formCompletions = nullptr;
         prevScrollbarVisible = true;
 
         possibleTripleClick = false;
         emitCompletedAfterRepaint = CSNone;
         cursorIconWidget = nullptr;
         cursorIconType   = KHTMLView::LINK_NORMAL;
         m_mouseScrollTimer = nullptr;
         m_mouseScrollIndicator = nullptr;
         contentsX = 0;
         contentsY = 0;
         view = v;
     }
     ~KHTMLViewPrivate()
     {
         delete formCompletions;
         delete postponed_autorepeat;
         if (underMouse) {
             underMouse->deref();
         }
         if (underMouseNonShared) {
             underMouseNonShared->deref();
         }
         if (oldUnderMouse) {
             oldUnderMouse->deref();
         }
 
         delete cursorIconWidget;
         delete m_mouseScrollTimer;
         delete m_mouseScrollIndicator;
     }
     void reset()
     {
         if (underMouse) {
             underMouse->deref();
         }
         underMouse = nullptr;
         if (underMouseNonShared) {
             underMouseNonShared->deref();
         }
         underMouseNonShared = nullptr;
         if (oldUnderMouse) {
             oldUnderMouse->deref();
         }
         oldUnderMouse = nullptr;
         linkPressed = false;
         staticWidget = SBNone;
         fixedObjectsCount = 0;
         staticObjectsCount = 0;
         tabMovePending = false;
         lastTabbingDirection = true;
         pseudoFocusNode = PFNone;
         zoomLevel = 100;
 #ifndef KHTML_NO_SCROLLBARS
         //We don't turn off the toolbars here
         //since if the user turns them
         //off, then chances are they want them turned
         //off always - even after a reset.
 #else
         vpolicy = ScrollBarAlwaysOff;
         hpolicy = ScrollBarAlwaysOff;
 #endif
         scrollBarMoved = false;
         contentsMoving = false;
         ignoreWheelEvents = false;
         scrollingFromWheel = QPoint(-1, -1);
         borderX = 30;
         borderY = 30;
         steps = 0;
         dx = dy = 0;
         paged = false;
         clickX = -1;
         clickY = -1;
         clickCount = 0;
         isDoubleClick = false;
         scrollingSelf = false;
         delete postponed_autorepeat;
         postponed_autorepeat = nullptr;
         layoutTimerId = 0;
         repaintTimerId = 0;
         scrollTimerId = 0;
         scrollSuspended = false;
         scrollSuspendPreActivate = false;
         smoothScrolling = false;
         smoothScrollModeIsDefault = true;
         shouldSmoothScroll = false;
         smoothScrollMissedDeadlines = 0;
         hasFrameset = false;
         complete = false;
         firstLayoutPending = true;
 #ifdef SPEED_DEBUG
         firstRepaintPending = true;
 #endif
         needsFullRepaint = true;
         dirtyLayout = false;
         layoutSchedulingEnabled = true;
         painting = false;
         layoutCounter = 0;
         layoutAttemptCounter = 0;
         scheduledLayoutCounter = 0;
         updateRegion = QRegion();
         m_dialogsAllowed = true;
         accessKeysActivated = false;
         accessKeysPreActivate = false;
 
         // the view might have been built before the part it will be assigned to,
         // so exceptionally, we need to directly ref/deref KHTMLGlobal to
         // account for this transitory case.
         KHTMLGlobal::ref();
         accessKeysEnabled = KHTMLGlobal::defaultHTMLSettings()->accessKeysEnabled();
         KHTMLGlobal::deref();
 
         emitCompletedAfterRepaint = CSNone;
         m_mouseEventsTarget = nullptr;
         m_clipHolder = nullptr;
     }
     void newScrollTimer(QWidget *view, int tid)
     {
         //qCDebug(KHTML_LOG) << "newScrollTimer timer " << tid;
         view->killTimer(scrollTimerId);
         scrollTimerId = tid;
         scrollSuspended = false;
     }
     enum ScrollDirection { ScrollLeft, ScrollRight, ScrollUp, ScrollDown };
 
     void adjustScroller(QWidget *view, ScrollDirection direction, ScrollDirection oppositedir)
     {
         static const struct {
             int msec, pixels;
         } timings [] = {
             {320, 1}, {224, 1}, {160, 1}, {112, 1}, {80, 1}, {56, 1}, {40, 1},
             {28, 1}, {20, 1}, {20, 2}, {20, 3}, {20, 4}, {20, 6}, {20, 8}, {0, 0}
         };
         if (!scrollTimerId ||
                 (static_cast<int>(scrollDirection) != direction &&
                  (static_cast<int>(scrollDirection) != oppositedir || scrollSuspended))) {
             scrollTiming = 6;
             scrollBy = timings[scrollTiming].pixels;
             scrollDirection = direction;
             newScrollTimer(view, view->startTimer(timings[scrollTiming].msec));
         } else if (scrollDirection == direction &&
                    timings[scrollTiming + 1].msec && !scrollSuspended) {
             scrollBy = timings[++scrollTiming].pixels;
             newScrollTimer(view, view->startTimer(timings[scrollTiming].msec));
         } else if (scrollDirection == oppositedir) {
             if (scrollTiming) {
                 scrollBy = timings[--scrollTiming].pixels;
                 newScrollTimer(view, view->startTimer(timings[scrollTiming].msec));
             }
         }
         scrollSuspended = false;
     }
 
     bool haveZoom() const
     {
         return zoomLevel != 100;
     }
 
     void startScrolling()
     {
         smoothScrolling = true;
         smoothScrollTimer.start(sSmoothScrollTick);
         shouldSmoothScroll = false;
     }
 
     void stopScrolling()
     {
         smoothScrollTimer.stop();
         dx = dy = 0;
         steps = 0;
         updateContentsXY();
         smoothScrolling = false;
         shouldSmoothScroll = false;
     }
 
     void updateContentsXY()
     {
         contentsX = QApplication::isRightToLeft() ?
                     view->horizontalScrollBar()->maximum() - view->horizontalScrollBar()->value() : view->horizontalScrollBar()->value();
         contentsY = view->verticalScrollBar()->value();
     }
     void scrollAccessKeys(int dx, int dy)
     {
         QList<QLabel *> wl = view->widget()->findChildren<QLabel *>("KHTMLAccessKey");
         foreach (QLabel *w, wl) {
             w->move(w->pos() + QPoint(dx, dy));
         }
     }
     void scrollExternalWidgets(int dx, int dy)
     {
         if (visibleWidgets.isEmpty()) {
             return;
         }
 
         QHashIterator<void *, QWidget *> it(visibleWidgets);
         while (it.hasNext()) {
             it.next();
             it.value()->move(it.value()->pos() + QPoint(dx, dy));
         }
     }
 
     NodeImpl *underMouse;
     NodeImpl *underMouseNonShared;
     NodeImpl *oldUnderMouse;
 
     // Do not adjust bitfield enums sizes.
     // They are oversized because they are signed on some platforms.
     bool tabMovePending: 1;
     bool lastTabbingDirection: 1;
     PseudoFocusNodes pseudoFocusNode: 3;
     bool scrollBarMoved: 1;
     bool contentsMoving: 1;
 
     Qt::ScrollBarPolicy vpolicy;
     Qt::ScrollBarPolicy hpolicy;
     bool prevScrollbarVisible: 1;
     bool linkPressed: 1;
     bool ignoreWheelEvents: 1;
     StaticBackgroundState staticWidget: 3;
     int staticObjectsCount;
     int fixedObjectsCount;
 
     int zoomLevel;
     int borderX, borderY;
     int dx, dy;
     int steps;
     KConfig *formCompletions;
 
     int clickX, clickY, clickCount;
     bool isDoubleClick;
 
     bool paged;
 
     bool scrollingSelf;
     int contentsX, contentsY;
     int layoutTimerId;
     QKeyEvent *postponed_autorepeat;
 
     int repaintTimerId;
     int scrollTimerId;
     int scrollTiming;
     int scrollBy;
     ScrollDirection scrollDirection     : 3;
     bool scrollSuspended            : 1;
     bool scrollSuspendPreActivate       : 1;
     KHTMLView::SmoothScrollingMode smoothScrollMode : 3;
     bool smoothScrolling                          : 1;
     bool smoothScrollModeIsDefault                : 1;
     bool shouldSmoothScroll                       : 1;
     bool hasFrameset                              : 1;
     bool complete               : 1;
     bool firstLayoutPending         : 1;
 #ifdef SPEED_DEBUG
     bool firstRepaintPending                    : 1;
 #endif
     bool layoutSchedulingEnabled        : 1;
     bool needsFullRepaint           : 1;
     bool painting               : 1;
     bool possibleTripleClick            : 1;
     bool dirtyLayout                           : 1;
     bool m_dialogsAllowed           : 1;
     short smoothScrollMissedDeadlines;
     int layoutCounter;
     int layoutAttemptCounter;
     int scheduledLayoutCounter;
     QRegion updateRegion;
     QTimer smoothScrollTimer;
     QTime smoothScrollStopwatch;
     QHash<void *, QWidget *> visibleWidgets;
     bool accessKeysEnabled;
     bool accessKeysActivated;
     bool accessKeysPreActivate;
     CompletedState emitCompletedAfterRepaint;
 
     QLabel               *cursorIconWidget;
     KHTMLView::LinkCursor cursorIconType;
 
     // scrolling activated by MMB
     short m_mouseScroll_byX;
     short m_mouseScroll_byY;
     QPoint scrollingFromWheel;
     int scrollingFromWheelTimerId;
     QTimer *m_mouseScrollTimer;
     QWidget *m_mouseScrollIndicator;
     QPointer<QWidget> m_mouseEventsTarget;
     QStack<QRegion> *m_clipHolder;
     KHTMLView *view;
 };
 
 #ifndef QT_NO_TOOLTIP
 
 /** calculates the client-side image map rectangle for the given image element
  * @param img image element
  * @param scrollOfs scroll offset of viewport in content coordinates
  * @param p position to be probed in viewport coordinates
  * @param r returns the bounding rectangle in content coordinates
  * @param s returns the title string
  * @return true if an appropriate area was found -- only in this case r and
  *  s are valid, false otherwise
  */
 static bool findImageMapRect(HTMLImageElementImpl *img, const QPoint &scrollOfs,
                              const QPoint &p, QRect &r, QString &s)
 {
     HTMLMapElementImpl *map;
     if (img && img->document()->isHTMLDocument() &&
             (map = static_cast<HTMLDocumentImpl *>(img->document())->getMap(img->imageMap()))) {
         RenderObject::NodeInfo info(true, false);
         RenderObject *rend = img->renderer();
         int ax, ay;
         if (!rend || !rend->absolutePosition(ax, ay)) {
             return false;
         }
         // we're a client side image map
         bool inside = map->mapMouseEvent(p.x() - ax + scrollOfs.x(),
                                          p.y() - ay + scrollOfs.y(), rend->contentWidth(),
                                          rend->contentHeight(), info);
         if (inside && info.URLElement()) {
             HTMLAreaElementImpl *area = static_cast<HTMLAreaElementImpl *>(info.URLElement());
             Q_ASSERT(area->id() == ID_AREA);
             s = area->getAttribute(ATTR_TITLE).string();
             QRegion reg = area->cachedRegion();
             if (!s.isEmpty() && !reg.isEmpty()) {
                 r = reg.boundingRect();
                 r.translate(ax, ay);
                 return true;
             }
         }
     }
     return false;
 }
 
 bool KHTMLView::event(QEvent *e)
 {
     switch (e->type()) {
     case QEvent::ToolTip: {
         QHelpEvent *he = static_cast<QHelpEvent *>(e);
         QPoint     p   = he->pos();
 
         DOM::NodeImpl *node = d->underMouseNonShared;
         QRect region;
         while (node) {
             if (node->isElementNode()) {
                 DOM::ElementImpl *e = static_cast<DOM::ElementImpl *>(node);
                 QRect r;
                 QString s;
                 bool found = false;
                 // for images, check if it is part of a client-side image map,
                 // and query the <area>s' title attributes, too
                 if (e->id() == ID_IMG && !e->getAttribute(ATTR_USEMAP).isEmpty()) {
                     found = findImageMapRect(static_cast<HTMLImageElementImpl *>(e),
                                              viewportToContents(QPoint(0, 0)), p, r, s);
                 }
                 if (!found) {
                     s = e->getAttribute(ATTR_TITLE).string().trimmed();
                     r = node->getRect();
                 }
                 region |= QRect(contentsToViewport(r.topLeft()), r.size());
                 if (!s.isEmpty()) {
                     QToolTip::showText(he->globalPos(),
                                        Qt::convertFromPlainText(s, Qt::WhiteSpaceNormal),
                                        widget(), region);
                     break;
                 }
             }
             node = node->parentNode();
         }
         // Qt makes tooltip events happen nearly immediately when a preceding one was processed in the past few seconds.
         // We don't want that feature to apply to web tootlips however, as it clashes with dhtml menus.
         // So we'll just pretend we did not process that event.
         return false;
     }
 
     case QEvent::DragEnter:
     case QEvent::DragMove:
     case QEvent::DragLeave:
     case QEvent::Drop:
         // In Qt4, one needs to both call accept() on the DND event and return
         // true on ::event for the candidate widget for the drop to be possible.
         // Apps hosting us, such as konq, can do the former but not the later.
         // We will do the second bit, as it's a no-op unless someone else explicitly
         // accepts the event. We need to skip the scrollarea to do that,
         // since it will just skip the events, both killing the drop, and
         // not permitting us to forward it up the part hiearchy in our dragEnterEvent,
         // etc. handlers
         return QWidget::event(e);
     case QEvent::StyleChange:
     case QEvent::LayoutRequest: {
         updateScrollBars();
         return QAbstractScrollArea::event(e);
     }
     case QEvent::PaletteChange:
         slotPaletteChanged();
         return QScrollArea::event(e);
     default:
         return QScrollArea::event(e);
     }
 }
 #endif
 
 KHTMLView::KHTMLView(KHTMLPart *part, QWidget *parent)
     : QScrollArea(parent), d(new KHTMLViewPrivate(this))
 {
     m_medium = "screen";
 
     m_part = part;
 
     QScrollArea::setVerticalScrollBarPolicy(d->vpolicy);
     QScrollArea::setHorizontalScrollBarPolicy(d->hpolicy);
 
     initWidget();
     widget()->setMouseTracking(true);
 }
 
 KHTMLView::~KHTMLView()
 {
     closeChildDialogs();
     if (m_part) {
         DOM::DocumentImpl *doc = m_part->xmlDocImpl();
         if (doc) {
             doc->detach();
         }
     }
     delete d;
 }
 
 void KHTMLView::setPart(KHTMLPart *part)
 {
     assert(part && !m_part);
     m_part = part;
 }
 
 void KHTMLView::initWidget()
 {
     // Do not access the part here. It might not be fully constructed.
 
     setFrameStyle(QFrame::NoFrame);
     setFocusPolicy(Qt::StrongFocus);
     viewport()->setFocusProxy(this);
 
     _marginWidth = -1; // undefined
     _marginHeight = -1;
     _width = 0;
     _height = 0;
 
     installEventFilter(this);
 
     setAcceptDrops(true);
     if (!widget()) {
         setWidget(new QWidget(this));
     }
     widget()->setAttribute(Qt::WA_NoSystemBackground);
 
     // Do *not* remove this attribute frivolously.
     // You might not notice a change of behaviour in Debug builds
     // but removing opaque events will make QWidget::scroll fail horribly
     // in Release builds.
     widget()->setAttribute(Qt::WA_OpaquePaintEvent);
 
     verticalScrollBar()->setCursor(Qt::ArrowCursor);
     horizontalScrollBar()->setCursor(Qt::ArrowCursor);
 
     connect(&d->smoothScrollTimer, SIGNAL(timeout()), this, SLOT(scrollTick()));
 }
 
 void KHTMLView::resizeContentsToViewport()
 {
     QSize s = viewport()->size();
     resizeContents(s.width(), s.height());
 }
 
 // called by KHTMLPart::clear()
 void KHTMLView::clear()
 {
     if (d->accessKeysEnabled && d->accessKeysActivated) {
         accessKeysTimeout();
     }
     viewport()->unsetCursor();
     if (d->cursorIconWidget) {
         d->cursorIconWidget->hide();
     }
     if (d->smoothScrolling) {
         d->stopScrolling();
     }
     d->reset();
     QAbstractEventDispatcher::instance()->unregisterTimers(this);
     emit cleared();
 
     QScrollArea::setHorizontalScrollBarPolicy(d->hpolicy);
     QScrollArea::setVerticalScrollBarPolicy(d->vpolicy);
     verticalScrollBar()->setEnabled(false);
     horizontalScrollBar()->setEnabled(false);
 
 }
 
 void KHTMLView::hideEvent(QHideEvent *e)
 {
     QScrollArea::hideEvent(e);
 }
 
 void KHTMLView::showEvent(QShowEvent *e)
 {
     QScrollArea::showEvent(e);
 }
 
 void KHTMLView::setMouseEventsTarget(QWidget *w)
 {
     d->m_mouseEventsTarget = w;
 }
 
 QWidget *KHTMLView::mouseEventsTarget() const
 {
     return d->m_mouseEventsTarget;
 }
 
 void KHTMLView::setClipHolder(QStack<QRegion> *ch)
 {
     d->m_clipHolder = ch;
 }
 
 QStack<QRegion> *KHTMLView::clipHolder() const
 {
     return d->m_clipHolder;
 }
 
 int KHTMLView::contentsWidth() const
 {
     return widget() ? widget()->width() : 0;
 }
 
 int KHTMLView::contentsHeight() const
 {
     return widget() ? widget()->height() : 0;
 }
 
 void KHTMLView::resizeContents(int w, int h)
 {
     if (!widget()) {
         return;
     }
     widget()->resize(w, h);
     if (!widget()->isVisible()) {
         updateScrollBars();
     }
 }
 
 int KHTMLView::contentsX() const
 {
     return d->contentsX;
 }
 
 int KHTMLView::contentsY() const
 {
     return d->contentsY;
 }
 
 int KHTMLView::visibleWidth() const
 {
     if (m_kwp->isRedirected()) {
         // our RenderWidget knows better
         if (RenderWidget *rw = m_kwp->renderWidget()) {
             int ret = rw->width() - rw->paddingLeft() - rw->paddingRight() - rw->borderLeft() - rw->borderRight();
             if (verticalScrollBar()->isVisible()) {
                 ret -= verticalScrollBar()->sizeHint().width();
                 ret = qMax(0, ret);
             }
             return ret;
         }
     }
     return viewport()->width();
 }
 
 int KHTMLView::visibleHeight() const
 {
     if (m_kwp->isRedirected()) {
         // our RenderWidget knows better
         if (RenderWidget *rw = m_kwp->renderWidget()) {
             int ret = rw->height() - rw->paddingBottom() - rw->paddingTop() - rw->borderTop() - rw->borderBottom();
             if (horizontalScrollBar()->isVisible()) {
                 ret -= horizontalScrollBar()->sizeHint().height();
                 ret = qMax(0, ret);
             }
             return ret;
         }
     }
     return viewport()->height();
 }
 
 void KHTMLView::setContentsPos(int x, int y)
 {
     horizontalScrollBar()->setValue(QApplication::isRightToLeft() ?
                                     horizontalScrollBar()->maximum() - x : x);
     verticalScrollBar()->setValue(y);
 }
 
 void KHTMLView::scrollBy(int x, int y)
 {
     if (d->scrollTimerId) {
         d->newScrollTimer(this, 0);
     }
     horizontalScrollBar()->setValue(horizontalScrollBar()->value() + x);
     verticalScrollBar()->setValue(verticalScrollBar()->value() + y);
 }
 
 QPoint KHTMLView::contentsToViewport(const QPoint &p) const
 {
     return QPoint(p.x() - contentsX(), p.y() - contentsY());
 }
 
 void KHTMLView::contentsToViewport(int x, int y, int &cx, int &cy) const
 {
     QPoint p(x, y);
     p = contentsToViewport(p);
     cx = p.x();
     cy = p.y();
 }
 
 QPoint KHTMLView::viewportToContents(const QPoint &p) const
 {
     return QPoint(p.x() + contentsX(), p.y() + contentsY());
 }
 
 void KHTMLView::viewportToContents(int x, int y, int &cx, int &cy) const
 {
     QPoint p(x, y);
     p = viewportToContents(p);
     cx = p.x();
     cy = p.y();
 }
 
 void KHTMLView::updateContents(int x, int y, int w, int h)
 {
     applyTransforms(x, y, w, h);
     if (m_kwp->isRedirected()) {
         QPoint off = m_kwp->absolutePos();
         KHTMLView *pview = m_part->parentPart()->view();
         pview->updateContents(x + off.x(), y + off.y(), w, h);
     } else {
         widget()->update(x, y, w, h);
     }
 }
 
 void KHTMLView::updateContents(const QRect &r)
 {
     updateContents(r.x(), r.y(), r.width(), r.height());
 }
 
 void KHTMLView::repaintContents(int x, int y, int w, int h)
 {
     applyTransforms(x, y, w, h);
     if (m_kwp->isRedirected()) {
         QPoint off = m_kwp->absolutePos();
         KHTMLView *pview = m_part->parentPart()->view();
         pview->repaintContents(x + off.x(), y + off.y(), w, h);
     } else {
         widget()->repaint(x, y, w, h);
     }
 }
 
 void KHTMLView::repaintContents(const QRect &r)
 {
     repaintContents(r.x(), r.y(), r.width(), r.height());
 }
 
 void KHTMLView::applyTransforms(int &x, int &y, int &w, int &h) const
 {
     if (d->haveZoom()) {
         const int z = d->zoomLevel;
         x = x * z / 100;
         y = y * z / 100;
         w = w * z / 100;
         h = h * z / 100;
     }
     x -= contentsX();
     y -= contentsY();
 }
 
 void KHTMLView::revertTransforms(int &x, int &y, int &w, int &h) const
 {
     x += contentsX();
     y += contentsY();
     if (d->haveZoom()) {
         const int z = d->zoomLevel;
         x = x * 100 / z;
         y = y * 100 / z;
         w = w * 100 / z;
         h = h * 100 / z;
     }
 }
 
 void KHTMLView::revertTransforms(int &x, int &y) const
 {
     int dummy = 0;
     revertTransforms(x, y, dummy, dummy);
 }
 
 void KHTMLView::resizeEvent(QResizeEvent * /*e*/)
 {
     updateScrollBars();
 
     // If we didn't load anything, make white area as big as the view
     if (!m_part->xmlDocImpl()) {
         resizeContentsToViewport();
     }
 
     // Viewport-dependent media queries may cause us to need completely different style information.
     if (m_part->xmlDocImpl() && m_part->xmlDocImpl()->styleSelector()->affectedByViewportChange()) {
         m_part->xmlDocImpl()->updateStyleSelector();
     }
 
     if (d->layoutSchedulingEnabled) {
         layout();
     }
 
     QApplication::sendPostedEvents(viewport(), QEvent::Paint);
 
     if (m_part && m_part->xmlDocImpl()) {
         if (m_part->parentPart()) {
             // sub-frame : queue the resize event until our toplevel is done layouting
             khtml::ChildFrame *cf = m_part->parentPart()->frame(m_part);
             if (cf && !cf->m_partContainerElement.isNull()) {
                 cf->m_partContainerElement.data()->postResizeEvent();
             }
         } else {
             // toplevel : dispatch sub-frames'resize events before our own
             HTMLPartContainerElementImpl::sendPostedResizeEvents();
             m_part->xmlDocImpl()->dispatchWindowEvent(EventImpl::RESIZE_EVENT, false, false);
         }
     }
 }
 
 void KHTMLView::paintEvent(QPaintEvent *e)
 {
     QRect r = e->rect();
     QRect v(contentsX(), contentsY(), visibleWidth(), visibleHeight());
     QPoint off(contentsX(), contentsY());
     r.translate(off);
     r = r.intersected(v);
     if (!r.isValid() || r.isEmpty()) {
         return;
     }
 
     QPainter p(widget());
     p.translate(-off);
 
     if (d->haveZoom()) {
         p.scale(d->zoomLevel / 100., d->zoomLevel / 100.);
 
         r.setX(r.x() * 100 / d->zoomLevel);
         r.setY(r.y() * 100 / d->zoomLevel);
         r.setWidth(r.width() * 100 / d->zoomLevel);
         r.setHeight(r.height() * 100 / d->zoomLevel);
         r.adjust(-1, -1, 1, 1);
     }
     p.setClipRect(r);
 
     int ex = r.x();
     int ey = r.y();
     int ew = r.width();
     int eh = r.height();
 
     if (!m_part || !m_part->xmlDocImpl() || !m_part->xmlDocImpl()->renderer()) {
         p.fillRect(ex, ey, ew, eh, palette().brush(QPalette::Active, QPalette::Base));
         return;
     } else if (d->complete && static_cast<RenderCanvas *>(m_part->xmlDocImpl()->renderer())->needsLayout()) {
         // an external update request happens while we have a layout scheduled
         unscheduleRelayout();
         layout();
     } else if (m_part->xmlDocImpl()->tokenizer()) {
         m_part->xmlDocImpl()->tokenizer()->setNormalYieldDelay();
     }
 
     if (d->painting) {
         // qCDebug(KHTML_LOG) << "WARNING: paintEvent reentered! ";
         return;
     }
     d->painting = true;
 
     m_part->xmlDocImpl()->renderer()->layer()->paint(&p, r);
 
     if (d->hasFrameset) {
         NodeImpl *body = static_cast<HTMLDocumentImpl *>(m_part->xmlDocImpl())->body();
         if (body && body->renderer() && body->id() == ID_FRAMESET) {
             static_cast<RenderFrameSet *>(body->renderer())->paintFrameSetRules(&p, r);
         } else {
             d->hasFrameset = false;
         }
     }
 
     khtml::DrawContentsEvent event(&p, ex, ey, ew, eh);
     QApplication::sendEvent(m_part, &event);
 
     if (d->contentsMoving && !d->smoothScrolling && widget()->underMouse()) {
         QMouseEvent *tempEvent = new QMouseEvent(QEvent::MouseMove, widget()->mapFromGlobal(QCursor::pos()),
                 Qt::NoButton, Qt::NoButton, Qt::NoModifier);
         QApplication::postEvent(widget(), tempEvent);
     }
 #ifdef SPEED_DEBUG
     if (d->firstRepaintPending && !m_part->parentPart()) {
         qCDebug(KHTML_LOG) << "FIRST PAINT:" << m_part->d->m_parsetime.elapsed();
     }
     d->firstRepaintPending = false;
 #endif
     d->painting = false;
 }
 
 void KHTMLView::setMarginWidth(int w)
 {
     // make it update the rendering area when set
     _marginWidth = w;
 }
 
 void KHTMLView::setMarginHeight(int h)
 {
     // make it update the rendering area when set
     _marginHeight = h;
 }
 
 void KHTMLView::layout()
 {
     if (m_part && m_part->xmlDocImpl()) {
         DOM::DocumentImpl *document = m_part->xmlDocImpl();
 
         khtml::RenderCanvas *canvas = static_cast<khtml::RenderCanvas *>(document->renderer());
         if (!canvas) {
             return;
         }
 
         d->layoutSchedulingEnabled = false;
         d->dirtyLayout = true;
 
         // the reference object for the overflow property on canvas
         RenderObject *ref = nullptr;
         RenderObject *root = document->documentElement() ? document->documentElement()->renderer() : nullptr;
 
         if (document->isHTMLDocument()) {
             NodeImpl *body = static_cast<HTMLDocumentImpl *>(document)->body();
             if (body && body->renderer() && body->id() == ID_FRAMESET) {
                 QScrollArea::setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 QScrollArea::setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 body->renderer()->setNeedsLayout(true);
                 d->hasFrameset = true;
             } else if (root) { // only apply body's overflow to canvas if root has a visible overflow
                 ref = (!body || root->style()->hidesOverflow()) ? root : body->renderer();
             }
         } else {
             ref = root;
         }
         if (ref) {
             if (ref->style()->overflowX() == OHIDDEN) {
                 if (d->hpolicy == Qt::ScrollBarAsNeeded) {
                     QScrollArea::setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 }
             } else if (ref->style()->overflowX() == OSCROLL) {
                 if (d->hpolicy == Qt::ScrollBarAsNeeded) {
                     QScrollArea::setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
                 }
             } else if (horizontalScrollBarPolicy() != d->hpolicy) {
                 QScrollArea::setHorizontalScrollBarPolicy(d->hpolicy);
             }
             if (ref->style()->overflowY() == OHIDDEN) {
                 if (d->vpolicy == Qt::ScrollBarAsNeeded) {
                     QScrollArea::setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 }
             } else if (ref->style()->overflowY() == OSCROLL) {
                 if (d->vpolicy == Qt::ScrollBarAsNeeded) {
                     QScrollArea::setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
                 }
             } else if (verticalScrollBarPolicy() != d->vpolicy) {
                 QScrollArea::setVerticalScrollBarPolicy(d->vpolicy);
             }
         }
         d->needsFullRepaint = d->firstLayoutPending;
         if (_height !=  visibleHeight() || _width != visibleWidth()) {
             ;
             d->needsFullRepaint = true;
             _height = visibleHeight();
             _width = visibleWidth();
         }
 
         canvas->layout();
 
         emit finishedLayout();
         if (d->firstLayoutPending) {
             // make sure firstLayoutPending is set to false now in case this layout
             // wasn't scheduled
             d->firstLayoutPending = false;
             verticalScrollBar()->setEnabled(true);
             horizontalScrollBar()->setEnabled(true);
         }
         d->layoutCounter++;
 
         if (d->accessKeysEnabled && d->accessKeysActivated) {
             emit hideAccessKeys();
             displayAccessKeys();
         }
     } else {
         _width = visibleWidth();
     }
 
     if (d->layoutTimerId) {
         killTimer(d->layoutTimerId);
     }
     d->layoutTimerId = 0;
     d->layoutSchedulingEnabled = true;
 }
 
 void KHTMLView::closeChildDialogs()
 {
     QList<QDialog *> dlgs = findChildren<QDialog *>();
     foreach (QDialog *dlg, dlgs) {
         if (dlg->testAttribute(Qt::WA_ShowModal)) {
             // qCDebug(KHTML_LOG) << "closeChildDialogs: closing dialog " << dlg;
             // close() ends up calling QButton::animateClick, which isn't immediate
             // we need something the exits the event loop immediately (#49068)
             dlg->reject();
         }
     }
     d->m_dialogsAllowed = false;
 }
 
 bool KHTMLView::dialogsAllowed()
 {
     bool allowed = d->m_dialogsAllowed;
     KHTMLPart *p = m_part->parentPart();
     if (p && p->view()) {
         allowed &= p->view()->dialogsAllowed();
     }
     return allowed;
 }
 
 void KHTMLView::closeEvent(QCloseEvent *ev)
 {
     closeChildDialogs();
     QScrollArea::closeEvent(ev);
 }
 
 void KHTMLView::setZoomLevel(int percent)
 {
     percent = percent < 20 ? 20 : (percent > 800 ? 800 : percent);
     int oldpercent = d->zoomLevel;
     d->zoomLevel = percent;
     if (percent != oldpercent) {
         if (d->layoutSchedulingEnabled) {
             layout();
         }
         widget()->update();
     }
 }
 
 int KHTMLView::zoomLevel() const
 {
     return d->zoomLevel;
 }
 
 void KHTMLView::setSmoothScrollingMode(SmoothScrollingMode m)
 {
     d->smoothScrollMode = m;
     d->smoothScrollModeIsDefault = false;
     if (d->smoothScrolling && !m) {
         d->stopScrolling();
     }
 }
 
 void KHTMLView::setSmoothScrollingModeDefault(SmoothScrollingMode m)
 {
     // check for manual override
     if (!d->smoothScrollModeIsDefault) {
         return;
     }
     d->smoothScrollMode = m;
     if (d->smoothScrolling && !m) {
         d->stopScrolling();
     }
 }
 
 KHTMLView::SmoothScrollingMode KHTMLView::smoothScrollingMode() const
 {
     return d->smoothScrollMode;
 }
 
 //
 // Event Handling
 //
 /////////////////
 
 void KHTMLView::mousePressEvent(QMouseEvent *_mouse)
 {
     if (!m_part->xmlDocImpl()) {
         return;
     }
     if (d->possibleTripleClick && (_mouse->button() & Qt::MouseButtonMask) == Qt::LeftButton) {
         mouseDoubleClickEvent(_mouse);   // it handles triple clicks too
         return;
     }
 
     int xm = _mouse->x();
     int ym = _mouse->y();
     revertTransforms(xm, ym);
 
     // qCDebug(KHTML_LOG) << "mousePressEvent: viewport=("<<_mouse->x()-contentsX()<<"/"<<_mouse->y()-contentsY()<<"), contents=(" << xm << "/" << ym << ")\n";
 
     d->isDoubleClick = false;
 
     DOM::NodeImpl::MouseEvent mev(_mouse->buttons(), DOM::NodeImpl::MousePress);
     m_part->xmlDocImpl()->prepareMouseEvent(false, xm, ym, &mev);
 
     //qCDebug(KHTML_LOG) << "innerNode="<<mev.innerNode.nodeName().string();
 
     if ((_mouse->button() == Qt::MidButton) &&
             !m_part->d->m_bOpenMiddleClick && !d->m_mouseScrollTimer &&
             mev.url.isNull() && (mev.innerNode.elementId() != ID_INPUT)) {
         QPoint point = mapFromGlobal(_mouse->globalPos());
 
         d->m_mouseScroll_byX = 0;
         d->m_mouseScroll_byY = 0;
 
         d->m_mouseScrollTimer = new QTimer(this);
         connect(d->m_mouseScrollTimer, SIGNAL(timeout()), this, SLOT(slotMouseScrollTimer()));
 
         if (!d->m_mouseScrollIndicator) {
             QPixmap pixmap(48, 48), icon;
             pixmap.fill(QColor(qRgba(127, 127, 127, 127)));
 
             QPainter p(&pixmap);
             QStyleOption option;
 
             option.rect.setRect(16, 0, 16, 16);
             QApplication::style()->drawPrimitive(QStyle::PE_IndicatorArrowUp, &option, &p);
             option.rect.setRect(0, 16, 16, 16);
             QApplication::style()->drawPrimitive(QStyle::PE_IndicatorArrowLeft, &option, &p);
             option.rect.setRect(16, 32, 16, 16);
             QApplication::style()->drawPrimitive(QStyle::PE_IndicatorArrowDown, &option, &p);
             option.rect.setRect(32, 16, 16, 16);
             QApplication::style()->drawPrimitive(QStyle::PE_IndicatorArrowRight, &option, &p);
             p.drawEllipse(23, 23, 2, 2);
 
             d->m_mouseScrollIndicator = new QWidget(this);
             d->m_mouseScrollIndicator->setFixedSize(48, 48);
             QPalette palette;
             palette.setBrush(d->m_mouseScrollIndicator->backgroundRole(), QBrush(pixmap));
             d->m_mouseScrollIndicator->setPalette(palette);
         }
         d->m_mouseScrollIndicator->move(point.x() - 24, point.y() - 24);
 
         bool hasHorBar = visibleWidth() < contentsWidth();
         bool hasVerBar = visibleHeight() < contentsHeight();
 
         KConfigGroup cg(KSharedConfig::openConfig(), "HTML Settings");
         if (cg.readEntry("ShowMouseScrollIndicator", true)) {
             d->m_mouseScrollIndicator->show();
             d->m_mouseScrollIndicator->unsetCursor();
 
             QBitmap mask = d->m_mouseScrollIndicator->palette().brush(d->m_mouseScrollIndicator->backgroundRole()).texture().createHeuristicMask(true);
 
             if (hasHorBar && !hasVerBar) {
                 QBitmap bm(16, 16);
                 bm.clear();
                 QPainter painter(&mask);
                 painter.drawPixmap(QRectF(16, 0, bm.width(), bm.height()), bm, bm.rect());
                 painter.drawPixmap(QRectF(16, 32, bm.width(), bm.height()), bm, bm.rect());
                 d->m_mouseScrollIndicator->setCursor(Qt::SizeHorCursor);
             } else if (!hasHorBar && hasVerBar) {
                 QBitmap bm(16, 16);
                 bm.clear();
                 QPainter painter(&mask);
                 painter.drawPixmap(QRectF(0, 16, bm.width(), bm.height()), bm, bm.rect());
                 painter.drawPixmap(QRectF(32, 16, bm.width(), bm.height()), bm, bm.rect());
                 d->m_mouseScrollIndicator->setCursor(Qt::SizeVerCursor);
             } else {
                 d->m_mouseScrollIndicator->setCursor(Qt::SizeAllCursor);
             }
 
             d->m_mouseScrollIndicator->setMask(mask);
         } else {
             if (hasHorBar && !hasVerBar) {
                 viewport()->setCursor(Qt::SizeHorCursor);
             } else if (!hasHorBar && hasVerBar) {
                 viewport()->setCursor(Qt::SizeVerCursor);
             } else {
                 viewport()->setCursor(Qt::SizeAllCursor);
             }
         }
 
         return;
     } else if (d->m_mouseScrollTimer) {
         delete d->m_mouseScrollTimer;
         d->m_mouseScrollTimer = nullptr;
 
         if (d->m_mouseScrollIndicator) {
             d->m_mouseScrollIndicator->hide();
         }
     }
 
     if (d->clickCount > 0 &&
             QPoint(d->clickX - xm, d->clickY - ym).manhattanLength() <= QApplication::startDragDistance()) {
         d->clickCount++;
     } else {
         d->clickCount = 1;
         d->clickX = xm;
         d->clickY = ym;
     }
 
     bool swallowEvent = dispatchMouseEvent(EventImpl::MOUSEDOWN_EVENT, mev.innerNode.handle(), mev.innerNonSharedNode.handle(), true,
                                            d->clickCount, _mouse, true, DOM::NodeImpl::MousePress);
 
     if (!swallowEvent) {
         emit m_part->nodeActivated(mev.innerNode);
 
         khtml::MousePressEvent event(_mouse, xm, ym, mev.url, mev.target, mev.innerNode);
         QApplication::sendEvent(m_part, &event);
         // we might be deleted after this
     }
 }
 
 void KHTMLView::mouseDoubleClickEvent(QMouseEvent *_mouse)
 {
     if (!m_part->xmlDocImpl()) {
         return;
     }
 
     int xm = _mouse->x();
     int ym = _mouse->y();
     revertTransforms(xm, ym);
 
     // qCDebug(KHTML_LOG) << "mouseDblClickEvent: x=" << xm << ", y=" << ym;
 
     d->isDoubleClick = true;
 
     DOM::NodeImpl::MouseEvent mev(_mouse->buttons(), DOM::NodeImpl::MouseDblClick);
     m_part->xmlDocImpl()->prepareMouseEvent(false, xm, ym, &mev);
 
     // We do the same thing as mousePressEvent() here, since the DOM does not treat
     // single and double-click events as separate (only the detail, i.e. number of clicks differs)
     if (d->clickCount > 0 &&
             QPoint(d->clickX - xm, d->clickY - ym).manhattanLength() <= QApplication::startDragDistance()) {
         d->clickCount++;
     } else { // shouldn't happen, if Qt has the same criterias for double clicks.
         d->clickCount = 1;
         d->clickX = xm;
         d->clickY = ym;
     }
     bool swallowEvent = dispatchMouseEvent(EventImpl::MOUSEDOWN_EVENT, mev.innerNode.handle(), mev.innerNonSharedNode.handle(), true,
                                            d->clickCount, _mouse, true, DOM::NodeImpl::MouseDblClick);
 
     if (!swallowEvent) {
         khtml::MouseDoubleClickEvent event(_mouse, xm, ym, mev.url, mev.target, mev.innerNode, d->clickCount);
         QApplication::sendEvent(m_part, &event);
     }
 
     d->possibleTripleClick = true;
     QTimer::singleShot(QApplication::doubleClickInterval(), this, SLOT(tripleClickTimeout()));
 }
 
 void KHTMLView::tripleClickTimeout()
 {
     d->possibleTripleClick = false;
     d->clickCount = 0;
 }
 
 static bool targetOpensNewWindow(KHTMLPart *part, QString target)
 {
     if (!target.isEmpty() && (target.toLower() != "_top") &&
             (target.toLower() != "_self") && (target.toLower() != "_parent")) {
         if (target.toLower() == "_blank") {
             return true;
         } else {
             while (part->parentPart()) {
                 part = part->parentPart();
             }
             if (!part->frameExists(target)) {
                 return true;
             }
         }
     }
     return false;
 }
 
 void KHTMLView::mouseMoveEvent(QMouseEvent *_mouse)
 {
     if (d->m_mouseScrollTimer) {
         QPoint point = mapFromGlobal(_mouse->globalPos());
 
         int deltaX = point.x() - d->m_mouseScrollIndicator->x() - 24;
         int deltaY = point.y() - d->m_mouseScrollIndicator->y() - 24;
 
         (deltaX > 0) ? d->m_mouseScroll_byX = 1 : d->m_mouseScroll_byX = -1;
         (deltaY > 0) ? d->m_mouseScroll_byY = 1 : d->m_mouseScroll_byY = -1;
 
         double adX = qAbs(deltaX) / 30.0;
         double adY = qAbs(deltaY) / 30.0;
 
         d->m_mouseScroll_byX = qMax(qMin(d->m_mouseScroll_byX * int(adX * adX), SHRT_MAX), SHRT_MIN);
         d->m_mouseScroll_byY = qMax(qMin(d->m_mouseScroll_byY * int(adY * adY), SHRT_MAX), SHRT_MIN);
 
         if (d->m_mouseScroll_byX == 0 && d->m_mouseScroll_byY == 0) {
             d->m_mouseScrollTimer->stop();
         } else if (!d->m_mouseScrollTimer->isActive()) {
             d->m_mouseScrollTimer->start(20);
         }
     }
 
     if (!m_part->xmlDocImpl()) {
         return;
     }
 
     int xm = _mouse->x();
     int ym = _mouse->y();
     revertTransforms(xm, ym);
 
     DOM::NodeImpl::MouseEvent mev(_mouse->buttons(), DOM::NodeImpl::MouseMove);
     // Do not modify :hover/:active state while mouse is pressed.
     m_part->xmlDocImpl()->prepareMouseEvent(_mouse->buttons() /*readonly ?*/, xm, ym, &mev);
 
     // qCDebug(KHTML_LOG) << "mouse move: " << _mouse->pos()
     //        << " button " << _mouse->button()
     //        << " state " << _mouse->state();
 
     DOM::NodeImpl *target = mev.innerNode.handle();
     DOM::NodeImpl *fn = m_part->xmlDocImpl()->focusNode();
 
     // a widget may be the real target of this event (e.g. if a scrollbar's slider is being moved)
     if (d->m_mouseEventsTarget && fn && fn->renderer() && fn->renderer()->isWidget()) {
         target = fn;
     }
 
     bool swallowEvent = dispatchMouseEvent(EventImpl::MOUSEMOVE_EVENT, target, mev.innerNonSharedNode.handle(), false,
                                            0, _mouse, true, DOM::NodeImpl::MouseMove);
 
     if (d->clickCount > 0 &&
             QPoint(d->clickX - xm, d->clickY - ym).manhattanLength() > QApplication::startDragDistance()) {
         d->clickCount = 0;  // moving the mouse outside the threshold invalidates the click
     }
 
     khtml::RenderObject *r = target ? target->renderer() : nullptr;
     bool setCursor = true;
     bool forceDefault = false;
     if (r && r->isWidget()) {
         RenderWidget *rw = static_cast<RenderWidget *>(r);
         KHTMLWidget *kw = qobject_cast<KHTMLView *>(rw->widget()) ? dynamic_cast<KHTMLWidget *>(rw->widget()) : nullptr;
         if (kw && kw->m_kwp->isRedirected()) {
             setCursor = false;
         } else if (QLineEdit *le = qobject_cast<QLineEdit *>(rw->widget())) {
             QList<QWidget *> wl = le->findChildren<QWidget *>("KLineEditButton");
             // force arrow cursor above lineedit clear button
             foreach (QWidget *w, wl) {
                 if (w->underMouse()) {
                     forceDefault = true;
                     break;
                 }
             }
         } else if (QTextEdit *te = qobject_cast<QTextEdit *>(rw->widget())) {
             if (te->verticalScrollBar()->underMouse() || te->horizontalScrollBar()->underMouse()) {
                 forceDefault = true;
             }
         }
     }
     khtml::RenderStyle *style = (r && r->style()) ? r->style() : nullptr;
     QCursor c;
     LinkCursor linkCursor = LINK_NORMAL;
     switch (!forceDefault ? (style ? style->cursor() : CURSOR_AUTO) : CURSOR_DEFAULT) {
     case CURSOR_AUTO:
         if (r && r->isText() && ((m_part->d->m_bMousePressed && m_part->d->editor_context.m_beganSelectingText) ||
                                  !r->isPointInsideSelection(xm, ym, m_part->caret()))) {
             c = QCursor(Qt::IBeamCursor);
         }
         if (mev.url.length() && m_part->settings()->changeCursor()) {
             c = m_part->urlCursor();
             if (mev.url.string().startsWith("mailto:") && mev.url.string().indexOf('@') > 0) {
                 linkCursor = LINK_MAILTO;
             } else if (targetOpensNewWindow(m_part, mev.target.string())) {
                 linkCursor = LINK_NEWWINDOW;
             }
         }
 
         if (r && r->isFrameSet() && !static_cast<RenderFrameSet *>(r)->noResize()) {
             c = QCursor(static_cast<RenderFrameSet *>(r)->cursorShape());
         }
 
         break;
     case CURSOR_CROSS:
         c = QCursor(Qt::CrossCursor);
         break;
     case CURSOR_POINTER:
         c = m_part->urlCursor();
         if (mev.url.string().startsWith("mailto:") && mev.url.string().indexOf('@') > 0) {
             linkCursor = LINK_MAILTO;
         } else if (targetOpensNewWindow(m_part, mev.target.string())) {
             linkCursor = LINK_NEWWINDOW;
         }
         break;
     case CURSOR_PROGRESS:
         c = QCursor(Qt::BusyCursor); // working_cursor
         break;
     case CURSOR_MOVE:
     case CURSOR_ALL_SCROLL:
         c = QCursor(Qt::SizeAllCursor);
         break;
     case CURSOR_E_RESIZE:
     case CURSOR_W_RESIZE:
     case CURSOR_EW_RESIZE:
         c = QCursor(Qt::SizeHorCursor);
         break;
     case CURSOR_N_RESIZE:
     case CURSOR_S_RESIZE:
     case CURSOR_NS_RESIZE:
         c = QCursor(Qt::SizeVerCursor);
         break;
     case CURSOR_NE_RESIZE:
     case CURSOR_SW_RESIZE:
     case CURSOR_NESW_RESIZE:
         c = QCursor(Qt::SizeBDiagCursor);
         break;
     case CURSOR_NW_RESIZE:
     case CURSOR_SE_RESIZE:
     case CURSOR_NWSE_RESIZE:
         c = QCursor(Qt::SizeFDiagCursor);
         break;
     case CURSOR_TEXT:
         c = QCursor(Qt::IBeamCursor);
         break;
     case CURSOR_WAIT:
         c = QCursor(Qt::WaitCursor);
         break;
     case CURSOR_HELP:
         c = QCursor(Qt::WhatsThisCursor);
         break;
     case CURSOR_DEFAULT:
         break;
     case CURSOR_NONE:
     case CURSOR_NOT_ALLOWED:
         c = QCursor(Qt::ForbiddenCursor);
         break;
     case CURSOR_ROW_RESIZE:
         c = QCursor(Qt::SplitVCursor);
         break;
     case CURSOR_COL_RESIZE:
         c = QCursor(Qt::SplitHCursor);
         break;
     case CURSOR_VERTICAL_TEXT:
     case CURSOR_CONTEXT_MENU:
     case CURSOR_NO_DROP:
     case CURSOR_CELL:
     case CURSOR_COPY:
     case CURSOR_ALIAS:
         c = QCursor(Qt::ArrowCursor);
         break;
     }
 
     if (!setCursor && style && style->cursor() != CURSOR_AUTO) {
         setCursor = true;
     }
 
     QWidget *vp = viewport();
     for (KHTMLPart *p = m_part; p; p = p->parentPart())
         if (!p->parentPart()) {
             vp = p->view()->viewport();
         }
     if (setCursor && (vp->cursor().shape() != c.shape() || c.shape() == Qt::BitmapCursor)) {
         if (c.shape() == Qt::ArrowCursor) {
             for (KHTMLPart *p = m_part; p; p = p->parentPart()) {
                 p->view()->viewport()->unsetCursor();
             }
         } else {
             vp->setCursor(c);
         }
     }
 
     if (linkCursor != LINK_NORMAL && isVisible() && hasFocus()) {
 #if HAVE_X11
     // ensure we don't trigger this code paths if we run in a Wayland session
     if (KWindowSystem::isPlatformX11()) {
         if (!d->cursorIconWidget) {
 #if HAVE_X11
             d->cursorIconWidget = new QLabel(nullptr, Qt::X11BypassWindowManagerHint);
             XSetWindowAttributes attr;
             attr.save_under = True;
             XChangeWindowAttributes(QX11Info::display(), d->cursorIconWidget->winId(), CWSaveUnder, &attr);
 #else
             d->cursorIconWidget = new QLabel(NULL, NULL);
             //TODO
 #endif
         }
 
         // Update the pixmap if need be.
         if (linkCursor != d->cursorIconType) {
             d->cursorIconType = linkCursor;
             QString cursorIcon;
             switch (linkCursor) {
             case LINK_MAILTO:     cursorIcon = "mail-message-new"; break;
             case LINK_NEWWINDOW:  cursorIcon = "window-new";       break;
             default:              cursorIcon = "dialog-error";     break;
             }
 
             QPixmap icon_pixmap = KHTMLGlobal::iconLoader()->loadIcon(cursorIcon, KIconLoader::Small, 0, KIconLoader::DefaultState, QStringList(), nullptr, true);
 
             d->cursorIconWidget->resize(icon_pixmap.width(), icon_pixmap.height());
             d->cursorIconWidget->setMask(icon_pixmap.createMaskFromColor(Qt::transparent));
             d->cursorIconWidget->setPixmap(icon_pixmap);
             d->cursorIconWidget->update();
         }
 
         QPoint c_pos = QCursor::pos();
         d->cursorIconWidget->move(c_pos.x() + 15, c_pos.y() + 15);
 #if HAVE_X11
         XRaiseWindow(QX11Info::display(), d->cursorIconWidget->winId());
         QApplication::flush();
 #elif defined(Q_OS_WIN)
         SetWindowPos(d->cursorIconWidget->winId(), HWND_TOP, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
 #else
         //TODO?
 #endif
         d->cursorIconWidget->show();
       }
 #endif
     } else if (d->cursorIconWidget) {
         d->cursorIconWidget->hide();
     }
 
     if (r && r->isWidget()) {
         _mouse->ignore();
     }
 
     if (!swallowEvent) {
         khtml::MouseMoveEvent event(_mouse, xm, ym, mev.url, mev.target, mev.innerNode);
         QApplication::sendEvent(m_part, &event);
     }
 }
 
 void KHTMLView::mouseReleaseEvent(QMouseEvent *_mouse)
 {
     bool swallowEvent = false;
 
     int xm = _mouse->x();
     int ym = _mouse->y();
     revertTransforms(xm, ym);
 
     DOM::NodeImpl::MouseEvent mev(_mouse->buttons(), DOM::NodeImpl::MouseRelease);
 
     if (m_part->xmlDocImpl()) {
         m_part->xmlDocImpl()->prepareMouseEvent(false, xm, ym, &mev);
 
         DOM::NodeImpl *target = mev.innerNode.handle();
         DOM::NodeImpl *fn = m_part->xmlDocImpl()->focusNode();
 
         // a widget may be the real target of this event (e.g. if a scrollbar's slider is being moved)
         if (d->m_mouseEventsTarget && fn && fn->renderer() && fn->renderer()->isWidget()) {
             target = fn;
         }
 
         swallowEvent = dispatchMouseEvent(EventImpl::MOUSEUP_EVENT, target, mev.innerNonSharedNode.handle(), true,
                                           d->clickCount, _mouse, false, DOM::NodeImpl::MouseRelease);
 
         // clear our sticky event target on any mouseRelease event
         if (d->m_mouseEventsTarget) {
             d->m_mouseEventsTarget = nullptr;
         }
 
         if (d->clickCount > 0 &&
                 QPoint(d->clickX - xm, d->clickY - ym).manhattanLength() <= QApplication::startDragDistance()) {
             QMouseEvent me(d->isDoubleClick ? QEvent::MouseButtonDblClick : QEvent::MouseButtonRelease,
                            _mouse->pos(), _mouse->button(), _mouse->buttons(), _mouse->modifiers());
             dispatchMouseEvent(EventImpl::CLICK_EVENT, mev.innerNode.handle(), mev.innerNonSharedNode.handle(), true,
                                d->clickCount, &me, true, DOM::NodeImpl::MouseRelease);
         }
 
         khtml::RenderObject *r = target ? target->renderer() : nullptr;
         if (r && r->isWidget()) {
             _mouse->ignore();
         }
     }
 
     if (!swallowEvent) {
         khtml::MouseReleaseEvent event(_mouse, xm, ym, mev.url, mev.target, mev.innerNode);
         QApplication::sendEvent(m_part, &event);
     }
 }
 
 // returns true if event should be swallowed
 bool KHTMLView::dispatchKeyEvent(QKeyEvent *_ke)
 {
     if (!m_part->xmlDocImpl()) {
         return false;
     }
     // Pressing and releasing a key should generate keydown, keypress and keyup events
     // Holding it down should generated keydown, keypress (repeatedly) and keyup events
     // The problem here is that Qt generates two autorepeat events (keyrelease+keypress)
     // for autorepeating, while DOM wants only one autorepeat event (keypress), so one
     // of the Qt events shouldn't be passed to DOM, but it should be still filtered
     // out if DOM would filter the autorepeat event. Additional problem is that Qt keyrelease
     // events don't have text() set (Qt bug?), so DOM often would ignore the keypress event
     // if it was created using Qt keyrelease, but Qt autorepeat keyrelease comes
     // before Qt autorepeat keypress (i.e. problem whether to filter it out or not).
     // The solution is to filter out and postpone the Qt autorepeat keyrelease until
     // the following Qt keypress event comes. If DOM accepts the DOM keypress event,
     // the postponed event will be simply discarded. If not, it will be passed to keyPressEvent()
     // again, and here it will be ignored.
     //
     //  Qt:      Press      | Release(autorepeat) Press(autorepeat) etc. |   Release
     //  DOM:   Down + Press |      (nothing)           Press             |     Up
 
     // It's also possible to get only Releases. E.g. the release of alt-tab,
     // or when the keypresses get captured by an accel.
 
     if (_ke == d->postponed_autorepeat) { // replayed event
         return false;
     }
 
     if (_ke->type() == QEvent::KeyPress) {
         if (!_ke->isAutoRepeat()) {
             bool ret = dispatchKeyEventHelper(_ke, false);   // keydown
             // don't send keypress even if keydown was blocked, like IE (and unlike Mozilla)
             if (!ret && dispatchKeyEventHelper(_ke, true)) { // keypress
                 ret = true;
             }
             return ret;
         } else { // autorepeat
             bool ret = dispatchKeyEventHelper(_ke, true);   // keypress
             if (!ret && d->postponed_autorepeat) {
                 keyPressEvent(d->postponed_autorepeat);
             }
             delete d->postponed_autorepeat;
             d->postponed_autorepeat = nullptr;
             return ret;
         }
     } else { // QEvent::KeyRelease
         // Discard postponed "autorepeat key-release" events that didn't see
         // a keypress after them (e.g. due to QAccel)
         delete d->postponed_autorepeat;
         d->postponed_autorepeat = nullptr;
 
         if (!_ke->isAutoRepeat()) {
             return dispatchKeyEventHelper(_ke, false);   // keyup
         } else {
             d->postponed_autorepeat = new QKeyEvent(_ke->type(), _ke->key(), _ke->modifiers(),
                                                     _ke->text(), _ke->isAutoRepeat(), _ke->count());
             if (_ke->isAccepted()) {
                 d->postponed_autorepeat->accept();
             } else {
                 d->postponed_autorepeat->ignore();
             }
             return true;
         }
     }
 }
 
 // returns true if event should be swallowed
 bool KHTMLView::dispatchKeyEventHelper(QKeyEvent *_ke, bool keypress)
 {
     DOM::NodeImpl *keyNode = m_part->xmlDocImpl()->focusNode();
     if (keyNode) {
         return keyNode->dispatchKeyEvent(_ke, keypress);
     } else { // no focused node, send to document
         return m_part->xmlDocImpl()->dispatchKeyEvent(_ke, keypress);
     }
 }
 
 void KHTMLView::keyPressEvent(QKeyEvent *_ke)
 {
     // If CTRL was hit, be prepared for access keys
     if (d->accessKeysEnabled && _ke->key() == Qt::Key_Control && !(_ke->modifiers() & ~Qt::ControlModifier) && !d->accessKeysActivated) {
         d->accessKeysPreActivate = true;
         _ke->accept();
         return;
     }
 
     if (_ke->key() == Qt::Key_Shift && !(_ke->modifiers() & ~Qt::ShiftModifier)) {
         d->scrollSuspendPreActivate = true;
     }
 
     // accesskey handling needs to be done before dispatching, otherwise e.g. lineedits
     // may eat the event
 
     if (d->accessKeysEnabled && d->accessKeysActivated) {
         int state = (_ke->modifiers() & (Qt::ShiftModifier | Qt::ControlModifier | Qt::AltModifier | Qt::MetaModifier));
         if (state == 0 || state == Qt::ShiftModifier) {
             if (_ke->key() != Qt::Key_Shift) {
                 accessKeysTimeout();
             }
             handleAccessKey(_ke);
             _ke->accept();
             return;
         }
         accessKeysTimeout();
         _ke->accept();
         return;
     }
 
     if (dispatchKeyEvent(_ke)) {
         // If either keydown or keypress was accepted by a widget, or canceled by JS, stop here.
         _ke->accept();
         return;
     }
 
     int offs = (viewport()->height() < 30) ? viewport()->height() : 30; // ### ??
     if (_ke->modifiers() & Qt::ShiftModifier)
         switch (_ke->key()) {
         case Qt::Key_Space:
             verticalScrollBar()->setValue(verticalScrollBar()->value() - viewport()->height() + offs);
             if (d->scrollSuspended) {
                 d->newScrollTimer(this, 0);
             }
             break;
 
         case Qt::Key_Down:
         case Qt::Key_J:
             d->adjustScroller(this, KHTMLViewPrivate::ScrollDown, KHTMLViewPrivate::ScrollUp);
             break;
 
         case Qt::Key_Up:
         case Qt::Key_K:
             d->adjustScroller(this, KHTMLViewPrivate::ScrollUp, KHTMLViewPrivate::ScrollDown);
             break;
 
         case Qt::Key_Left:
         case Qt::Key_H:
             d->adjustScroller(this, KHTMLViewPrivate::ScrollLeft, KHTMLViewPrivate::ScrollRight);
             break;
 
         case Qt::Key_Right:
         case Qt::Key_L:
             d->adjustScroller(this, KHTMLViewPrivate::ScrollRight, KHTMLViewPrivate::ScrollLeft);
             break;
         }
     else
         switch (_ke->key()) {
         case Qt::Key_Down:
         case Qt::Key_J:
             if (!d->scrollTimerId || d->scrollSuspended) {
                 verticalScrollBar()->setValue(verticalScrollBar()->value() + 10);
             }
             if (d->scrollTimerId) {
                 d->newScrollTimer(this, 0);
             }
             break;
 
         case Qt::Key_Space:
         case Qt::Key_PageDown:
             d->shouldSmoothScroll = true;
             verticalScrollBar()->setValue(verticalScrollBar()->value() + viewport()->height() - offs);
             if (d->scrollSuspended) {
                 d->newScrollTimer(this, 0);
             }
             break;
 
         case Qt::Key_Up:
         case Qt::Key_K:
             if (!d->scrollTimerId || d->scrollSuspended) {
                 verticalScrollBar()->setValue(verticalScrollBar()->value() - 10);
             }
             if (d->scrollTimerId) {
                 d->newScrollTimer(this, 0);
             }
             break;
 
         case Qt::Key_PageUp:
             d->shouldSmoothScroll = true;
             verticalScrollBar()->setValue(verticalScrollBar()->value() - viewport()->height() + offs);
             if (d->scrollSuspended) {
                 d->newScrollTimer(this, 0);
             }
             break;
         case Qt::Key_Right:
         case Qt::Key_L:
             if (!d->scrollTimerId || d->scrollSuspended) {
                 horizontalScrollBar()->setValue(horizontalScrollBar()->value() + 10);
             }
             if (d->scrollTimerId) {
                 d->newScrollTimer(this, 0);
             }
             break;
 
         case Qt::Key_Left:
         case Qt::Key_H:
             if (!d->scrollTimerId || d->scrollSuspended) {
                 horizontalScrollBar()->setValue(horizontalScrollBar()->value() - 10);
             }
             if (d->scrollTimerId) {
                 d->newScrollTimer(this, 0);
             }
             break;
         case Qt::Key_Enter:
         case Qt::Key_Return:
             // ### FIXME:
             // or even better to HTMLAnchorElementImpl::event()
             if (m_part->xmlDocImpl()) {
                 NodeImpl *n = m_part->xmlDocImpl()->focusNode();
                 if (n) {
                     n->setActive();
                 }
             }
             break;
         case Qt::Key_Home:
             verticalScrollBar()->setValue(0);
             horizontalScrollBar()->setValue(0);
             if (d->scrollSuspended) {
                 d->newScrollTimer(this, 0);
             }
             break;
         case Qt::Key_End:
             verticalScrollBar()->setValue(contentsHeight() - visibleHeight());
             if (d->scrollSuspended) {
                 d->newScrollTimer(this, 0);
             }
             break;
         case Qt::Key_Shift:
             // what are you doing here?
             _ke->ignore();
             return;
         default:
             if (d->scrollTimerId) {
                 d->newScrollTimer(this, 0);
             }
             _ke->ignore();
             return;
         }
 
     _ke->accept();
 }
 
 void KHTMLView::keyReleaseEvent(QKeyEvent *_ke)
 {
     if (d->scrollSuspendPreActivate && _ke->key() != Qt::Key_Shift) {
         d->scrollSuspendPreActivate = false;
     }
     if (_ke->key() == Qt::Key_Shift && d->scrollSuspendPreActivate && !(_ke->modifiers() & Qt::ShiftModifier))
         if (d->scrollTimerId) {
             d->scrollSuspended = !d->scrollSuspended;
             if (d->scrollSuspended) {
                 d->stopScrolling();
             }
         }
 
     if (d->accessKeysEnabled) {
         if (d->accessKeysPreActivate && _ke->key() != Qt::Key_Control) {
             d->accessKeysPreActivate = false;
         }
         if (d->accessKeysPreActivate && !(_ke->modifiers() & Qt::ControlModifier)) {
             displayAccessKeys();
             m_part->setStatusBarText(i18n("Access Keys activated"), KHTMLPart::BarOverrideText);
             d->accessKeysActivated = true;
             d->accessKeysPreActivate = false;
             _ke->accept();
             return;
         } else if (d->accessKeysActivated) {
             accessKeysTimeout();
             _ke->accept();
             return;
         }
     }
 
     // Send keyup event
     if (dispatchKeyEvent(_ke)) {
         _ke->accept();
         return;
     }
 
     QScrollArea::keyReleaseEvent(_ke);
 }
 
 bool KHTMLView::focusNextPrevChild(bool next)
 {
     // Now try to find the next child
     if (m_part->xmlDocImpl() && focusNextPrevNode(next)) {
         //if (m_part->xmlDocImpl()->focusNode())
         // qCDebug(KHTML_LOG) << "focusNode.name: "
         //      << m_part->xmlDocImpl()->focusNode()->nodeName().string();
         return true; // focus node found
     }
 
     // If we get here, pass tabbing control up to the next/previous child in our parent
     d->pseudoFocusNode = KHTMLViewPrivate::PFNone;
     if (m_part->parentPart() && m_part->parentPart()->view()) {
         return m_part->parentPart()->view()->focusNextPrevChild(next);
     }
 
     return QWidget::focusNextPrevChild(next);
 }
 
 void KHTMLView::doAutoScroll()
 {
     QPoint pos = QCursor::pos();
     QPoint off;
     KHTMLView *v = m_kwp->isRedirected() ? m_kwp->rootViewPos(off) : this;
     pos = v->viewport()->mapFromGlobal(pos);
     pos -= off;
     int xm, ym;
     viewportToContents(pos.x(), pos.y(), xm, ym); // ###
 
     pos = QPoint(pos.x() - viewport()->x(), pos.y() - viewport()->y());
     if ((pos.y() < 0) || (pos.y() > visibleHeight()) ||
             (pos.x() < 0) || (pos.x() > visibleWidth())) {
         ensureVisible(xm, ym, 0, 5);
 
 #ifndef KHTML_NO_SELECTION
         // extend the selection while scrolling
         DOM::Node innerNode;
         if (m_part->isExtendingSelection()) {
             RenderObject::NodeInfo renderInfo(true/*readonly*/, false/*active*/);
             m_part->xmlDocImpl()->renderer()->layer()
             ->nodeAtPoint(renderInfo, xm, ym);
             innerNode = renderInfo.innerNode();
         }/*end if*/
 
         if (innerNode.handle() && innerNode.handle()->renderer()
                 && innerNode.handle()->renderer()->shouldSelect()) {
             m_part->extendSelectionTo(xm, ym, innerNode);
         }/*end if*/
 #endif // KHTML_NO_SELECTION
     }
 }
 
 // KHTML defines its own stacking order for any object and thus takes
 // control of widget painting whenever it can. This is called "redirection".
 //
 // Redirected widgets are placed off screen. When they are declared as a child of our view (ChildPolished event),
 // an event filter is installed, so as to catch any paint event and translate them as update() of the view's main widget.
 //
 // Painting also happens spontaneously within widgets. In this case, the widget would update() parts of itself.
 // While this ordinarily results in a paintEvent being schedduled, it is not the case with off screen widgets.
 // Thus update() is monitored by using the mechanism that deffers any update call happening during a paint event,
 // transforming it into a posted UpdateLater event. Hence the need to set Qt::WA_WState_InPaintEvent on redirected widgets.
 //
 // Once the UpdateLater event has been received, Qt::WA_WState_InPaintEvent is removed and the process continues
 // with the update of the corresponding rect on the view. That in turn will make our painting subsystem render()
 // the widget at the correct stacking position.
 //
 // For non-redirected (e.g. external) widgets, z-order is honoured through masking. cf.RenderLayer::updateWidgetMasks
 
 static void handleWidget(QWidget *w, KHTMLView *view, bool recurse = true)
 {
     if (w->isWindow()) {
         return;
     }
 
     if (!qobject_cast<QFrame *>(w)) {
         w->setAttribute(Qt::WA_NoSystemBackground);
     }
 
     w->setAttribute(Qt::WA_WState_InPaintEvent);
 
     if (!(w->objectName() == "KLineEditButton")) {
         w->setAttribute(Qt::WA_OpaquePaintEvent);
     }
 
     w->installEventFilter(view);
 
     if (!recurse) {
         return;
     }
     if (qobject_cast<KHTMLView *>(w)) {
         handleWidget(static_cast<KHTMLView *>(w)->widget(), view, false);
         handleWidget(static_cast<KHTMLView *>(w)->horizontalScrollBar(), view, false);
         handleWidget(static_cast<KHTMLView *>(w)->verticalScrollBar(), view, false);
         return;
     }
 
     QObjectList children = w->children();
     foreach (QObject *object, children) {
         QWidget *widget = qobject_cast<QWidget *>(object);
         if (widget) {
             handleWidget(widget, view);
         }
     }
 }
 
 class KHTMLBackingStoreHackWidget : public QWidget
 {
 public:
     void publicEvent(QEvent *e)
     {
         QWidget::event(e);
     }
 };
 
 bool  KHTMLView::viewportEvent(QEvent *e)
 {
     switch (e->type()) {
     // those must not be dispatched to the specialized handlers
     // as widgetEvent() already took care of that
     case QEvent::MouseButtonPress:
     case QEvent::MouseButtonRelease:
     case QEvent::MouseButtonDblClick:
     case QEvent::MouseMove:
 #ifndef QT_NO_WHEELEVENT
     case QEvent::Wheel:
 #endif
     case QEvent::ContextMenu:
     case QEvent::DragEnter:
     case QEvent::DragMove:
     case QEvent::DragLeave:
     case QEvent::Drop:
         return false;
     default:
         break;
     }
     return QScrollArea::viewportEvent(e);
 }
 
 static void setInPaintEventFlag(QWidget *w, bool b = true, bool recurse = true)
 {
     w->setAttribute(Qt::WA_WState_InPaintEvent, b);
 
     if (!recurse) {
         return;
     }
     if (qobject_cast<KHTMLView *>(w)) {
         setInPaintEventFlag(static_cast<KHTMLView *>(w)->widget(), b, false);
         setInPaintEventFlag(static_cast<KHTMLView *>(w)->horizontalScrollBar(), b, false);
         setInPaintEventFlag(static_cast<KHTMLView *>(w)->verticalScrollBar(), b, false);
         return;
     }
 
     foreach (QObject *cw, w->children()) {
         if (cw->isWidgetType() && ! static_cast<QWidget *>(cw)->isWindow()
                 && !(static_cast<QWidget *>(cw)->windowModality() & Qt::ApplicationModal)) {
             setInPaintEventFlag(static_cast<QWidget *>(cw), b);
         }
     }
 }
 
 bool KHTMLView::eventFilter(QObject *o, QEvent *e)
 {
     if (e->type() == QEvent::ShortcutOverride) {
         QKeyEvent *ke = (QKeyEvent *) e;
         if (m_part->isEditable() || m_part->isCaretMode()
                 || (m_part->xmlDocImpl() && m_part->xmlDocImpl()->focusNode()
                     && m_part->xmlDocImpl()->focusNode()->isContentEditable())) {
             if ((ke->modifiers() & Qt::ControlModifier) || (ke->modifiers() & Qt::ShiftModifier)) {
                 switch (ke->key()) {
                 case Qt::Key_Left:
                 case Qt::Key_Right:
                 case Qt::Key_Up:
                 case Qt::Key_Down:
                 case Qt::Key_Home:
                 case Qt::Key_End:
                     ke->accept();
                     return true;
                 default:
                     break;
                 }
             }
         }
     }
 
     if (e->type() == QEvent::Leave) {
         if (d->cursorIconWidget) {
             d->cursorIconWidget->hide();
         }
         m_part->resetHoverText();
     }
 
     QWidget *view = widget();
     if (o == view) {
         if (widgetEvent(e)) {
             return true;
         } else if (e->type() == QEvent::Resize) {
             updateScrollBars();
             return false;
         }
     } else if (o->isWidgetType()) {
         QWidget *v = static_cast<QWidget *>(o);
         QWidget *c = v;
         while (v && v != view) {
             c = v;
             v = v->parentWidget();
         }
         KHTMLWidget *k = dynamic_cast<KHTMLWidget *>(c);
         if (v && k && k->m_kwp->isRedirected()) {
             bool block = false;
             QWidget *w = static_cast<QWidget *>(o);
             switch (e->type()) {
             case QEvent::UpdateRequest: {
                 // implicitly call qt_syncBackingStore(w)
                 static_cast<KHTMLBackingStoreHackWidget *>(w)->publicEvent(e);
                 block = true;
                 break;
             }
             case QEvent::UpdateLater:
             // no break;
             case QEvent::Paint:
                 if (!allowWidgetPaintEvents) {
                     // eat the event. Like this we can control exactly when the widget
                     // gets repainted.
                     block = true;
                     int x = 0, y = 0;
                     QWidget *v = w;
                     while (v && v->parentWidget() != view) {
                         x += v->x();
                         y += v->y();
                         v = v->parentWidget();
                     }
 
                     QPoint ap = k->m_kwp->absolutePos();
                     x += ap.x();
                     y += ap.y();
                 }
                 break;
             case QEvent::MouseMove:
             case QEvent::MouseButtonPress:
             case QEvent::MouseButtonRelease:
             case QEvent::MouseButtonDblClick: {
 
                 if (0 && w->parentWidget() == view && !qobject_cast<QScrollBar *>(w) && !::qobject_cast<QScrollBar *>(w)) {
                     QMouseEvent *me = static_cast<QMouseEvent *>(e);
                     QPoint pt = w->mapTo(view, me->pos());
                     QMouseEvent me2(me->type(), pt, me->button(), me->buttons(), me->modifiers());
 
                     if (e->type() == QEvent::MouseMove) {
                         mouseMoveEvent(&me2);
                     } else if (e->type() == QEvent::MouseButtonPress) {
                         mousePressEvent(&me2);
                     } else if (e->type() == QEvent::MouseButtonRelease) {
                         mouseReleaseEvent(&me2);
                     } else {
                         mouseDoubleClickEvent(&me2);
                     }
                     block = true;
                 }
                 break;
             }
             case QEvent::KeyPress:
             case QEvent::KeyRelease:
                 if (w->parentWidget() == view && !qobject_cast<QScrollBar *>(w)) {
                     QKeyEvent *ke = static_cast<QKeyEvent *>(e);
                     if (e->type() == QEvent::KeyPress) {
                         keyPressEvent(ke);
                         ke->accept();
                     } else {
                         keyReleaseEvent(ke);
                         ke->accept();
                     }
                     block = true;
                 }
 
                 if (qobject_cast<KUrlRequester *>(w->parentWidget()) &&
                         e->type() == QEvent::KeyPress) {
                     // Since keypress events on the upload widget will
                     // be forwarded to the lineedit anyway,
                     // block the original copy at this level to prevent
                     // double-emissions of events it doesn't accept
                     e->ignore();
                     block = true;
                 }
 
                 break;
             case QEvent::FocusIn:
             case QEvent::FocusOut: {
                 QPoint dummy;
                 KHTMLView *root = m_kwp->rootViewPos(dummy);
                 if (!root) {
                     root = this;
                 }
                 block = static_cast<QFocusEvent *>(e)->reason() != Qt::MouseFocusReason ||  root->underMouse();
                 break;
             }
             default:
                 break;
             }
             if (block) {
                 //qDebug("eating event");
                 return true;
             }
         }
     }
 
 //    qCDebug(KHTML_LOG) <<"passing event on to sv event filter object=" << o->className() << " event=" << e->type();
     return QScrollArea::eventFilter(o, e);
 }
 
 bool KHTMLView::widgetEvent(QEvent *e)
 {
     switch (e->type()) {
     case QEvent::MouseButtonPress:
     case QEvent::MouseButtonRelease:
     case QEvent::MouseButtonDblClick:
     case QEvent::MouseMove:
     case QEvent::Paint:
 #ifndef QT_NO_WHEELEVENT
     case QEvent::Wheel:
 #endif
     case QEvent::ContextMenu:
     case QEvent::DragEnter:
     case QEvent::DragMove:
     case QEvent::DragLeave:
     case QEvent::Drop:
         return QFrame::event(e);
     case QEvent::ChildPolished: {
         // we need to install an event filter on all children of the widget() to
         // be able to get correct stacking of children within the document.
         QObject *c = static_cast<QChildEvent *>(e)->child();
         if (c->isWidgetType()) {
             QWidget *w = static_cast<QWidget *>(c);
             // don't install the event filter on toplevels
             if (!(w->windowFlags() & Qt::Window) && !(w->windowModality() & Qt::ApplicationModal)) {
                 KHTMLWidget *k = dynamic_cast<KHTMLWidget *>(w);
                 if (k && k->m_kwp->isRedirected()) {
                     w->unsetCursor();
                     handleWidget(w, this);
                 }
             }
         }
         break;
     }
     case QEvent::Move: {
         if (static_cast<QMoveEvent *>(e)->pos() != QPoint(0, 0)) {
             widget()->move(0, 0);
             updateScrollBars();
             return true;
         }
         break;
     }
     default:
         break;
     }
     return false;
 }
 
 bool KHTMLView::hasLayoutPending()
 {
     return d->layoutTimerId && !d->firstLayoutPending;
 }
 
 DOM::NodeImpl *KHTMLView::nodeUnderMouse() const
 {
     return d->underMouse;
 }
 
 DOM::NodeImpl *KHTMLView::nonSharedNodeUnderMouse() const
 {
     return d->underMouseNonShared;
 }
 
 bool KHTMLView::scrollTo(const QRect &bounds)
 {
     d->scrollingSelf = true; // so scroll events get ignored
 
     int x, y, xe, ye;
     x = bounds.left();
     y = bounds.top();
     xe = bounds.right();
     ye = bounds.bottom();
 
     //qCDebug(KHTML_LOG)<<"scrolling coords: x="<<x<<" y="<<y<<" width="<<xe-x<<" height="<<ye-y;
 
     int deltax;
     int deltay;
 
     int curHeight = visibleHeight();
     int curWidth = visibleWidth();
 
     if (ye - y > curHeight - d->borderY) {
         ye  = y + curHeight - d->borderY;
     }
 
     if (xe - x > curWidth - d->borderX) {
         xe = x + curWidth - d->borderX;
     }
 
     // is xpos of target left of the view's border?
     if (x < contentsX() + d->borderX) {
         deltax = x - contentsX() - d->borderX;
     }
     // is xpos of target right of the view's right border?
     else if (xe + d->borderX > contentsX() + curWidth) {
         deltax = xe + d->borderX - (contentsX() + curWidth);
     } else {
         deltax = 0;
     }
 
     // is ypos of target above upper border?
     if (y < contentsY() + d->borderY) {
         deltay = y - contentsY() - d->borderY;
     }
     // is ypos of target below lower border?
     else if (ye + d->borderY > contentsY() + curHeight) {
         deltay = ye + d->borderY - (contentsY() + curHeight);
     } else {
         deltay = 0;
     }
 
     int maxx = curWidth - d->borderX;
     int maxy = curHeight - d->borderY;
 
     int scrollX, scrollY;
 
     scrollX = deltax > 0 ? (deltax > maxx ? maxx : deltax) : deltax == 0 ? 0 : (deltax > -maxx ? deltax : -maxx);
     scrollY = deltay > 0 ? (deltay > maxy ? maxy : deltay) : deltay == 0 ? 0 : (deltay > -maxy ? deltay : -maxy);
 
     if (contentsX() + scrollX < 0) {
         scrollX = -contentsX();
     } else if (contentsWidth() - visibleWidth() - contentsX() < scrollX) {
         scrollX = contentsWidth() - visibleWidth() - contentsX();
     }
 
     if (contentsY() + scrollY < 0) {
         scrollY = -contentsY();
     } else if (contentsHeight() - visibleHeight() - contentsY() < scrollY) {
         scrollY = contentsHeight() - visibleHeight() - contentsY();
     }
 
     horizontalScrollBar()->setValue(horizontalScrollBar()->value() + scrollX);
     verticalScrollBar()->setValue(verticalScrollBar()->value() + scrollY);
 
     d->scrollingSelf = false;
 
     if ((abs(deltax) <= maxx) && (abs(deltay) <= maxy)) {
         return true;
     } else {
         return false;
     }
 
 }
 
 bool KHTMLView::focusNextPrevNode(bool next)
 {
     // Sets the focus node of the document to be the node after (or if
     // next is false, before) the current focus node.  Only nodes that
     // are selectable (i.e. for which isFocusable() returns true) are
     // taken into account, and the order used is that specified in the
     // HTML spec (see DocumentImpl::nextFocusNode() and
     // DocumentImpl::previousFocusNode() for details).
 
     DocumentImpl *doc = m_part->xmlDocImpl();
     NodeImpl *oldFocusNode = doc->focusNode();
 
     // See whether we're in the middle of a detach, or hiding of the
     // widget. In this case, we will just clear focus, being careful not to emit events
     // or update rendering. Doing this also prevents the code below from going bonkers with
     // oldFocusNode not actually being focusable, etc.
     if (oldFocusNode) {
         if ((oldFocusNode->renderer() && !oldFocusNode->renderer()->parent())
                 || !oldFocusNode->isTabFocusable()) {
             doc->quietResetFocus();
             return true;
         }
     }
 
 #if 1
     // If the user has scrolled the document, then instead of picking
     // the next focusable node in the document, use the first one that
     // is within the visible area (if possible).
     if (d->scrollBarMoved) {
         NodeImpl *toFocus;
         if (next) {
             toFocus = doc->nextFocusNode(oldFocusNode);
         } else {
             toFocus = doc->previousFocusNode(oldFocusNode);
         }
 
         if (!toFocus && oldFocusNode) {
             if (next) {
                 toFocus = doc->nextFocusNode(nullptr);
             } else {
                 toFocus = doc->previousFocusNode(nullptr);
             }
         }
 
         while (toFocus && toFocus != oldFocusNode) {
 
             QRect focusNodeRect = toFocus->getRect();
             if ((focusNodeRect.left() > contentsX()) && (focusNodeRect.right() < contentsX() + visibleWidth()) &&
                     (focusNodeRect.top() > contentsY()) && (focusNodeRect.bottom() < contentsY() + visibleHeight())) {
                 {
                     QRect r = toFocus->getRect();
                     ensureVisible(r.right(), r.bottom());
                     ensureVisible(r.left(), r.top());
                     d->scrollBarMoved = false;
                     d->tabMovePending = false;
                     d->lastTabbingDirection = next;
                     d->pseudoFocusNode = KHTMLViewPrivate::PFNone;
                     m_part->xmlDocImpl()->setFocusNode(toFocus);
                     Node guard(toFocus);
                     if (!toFocus->hasOneRef()) {
                         emit m_part->nodeActivated(Node(toFocus));
                     }
                     return true;
                 }
             }
             if (next) {
                 toFocus = doc->nextFocusNode(toFocus);
             } else {
                 toFocus = doc->previousFocusNode(toFocus);
             }
 
             if (!toFocus && oldFocusNode) {
                 if (next) {
                     toFocus = doc->nextFocusNode(nullptr);
                 } else {
                     toFocus = doc->previousFocusNode(nullptr);
                 }
             }
         }
 
         d->scrollBarMoved = false;
     }
 #endif
 
     if (!oldFocusNode && d->pseudoFocusNode == KHTMLViewPrivate::PFNone) {
         ensureVisible(contentsX(), next ? 0 : contentsHeight());
         d->scrollBarMoved = false;
         d->pseudoFocusNode = next ? KHTMLViewPrivate::PFTop : KHTMLViewPrivate::PFBottom;
         return true;
     }
 
     NodeImpl *newFocusNode = nullptr;
 
     if (d->tabMovePending && next != d->lastTabbingDirection) {
         //qCDebug(KHTML_LOG) << " tab move pending and tabbing direction changed!\n";
         newFocusNode = oldFocusNode;
     } else if (next) {
         if (oldFocusNode || d->pseudoFocusNode == KHTMLViewPrivate::PFTop) {
             newFocusNode = doc->nextFocusNode(oldFocusNode);
         }
     } else {
         if (oldFocusNode || d->pseudoFocusNode == KHTMLViewPrivate::PFBottom) {
             newFocusNode = doc->previousFocusNode(oldFocusNode);
         }
     }
 
     bool targetVisible = false;
     if (!newFocusNode) {
         if (next) {
             targetVisible = scrollTo(QRect(contentsX() + visibleWidth() / 2, contentsHeight() - d->borderY, 0, 0));
         } else {
             targetVisible = scrollTo(QRect(contentsX() + visibleWidth() / 2, d->borderY, 0, 0));
         }
     } else {
         // if it's an editable element, activate the caret
         if (!m_part->isCaretMode() && newFocusNode->isContentEditable()) {
             // qCDebug(KHTML_LOG) << "show caret! fn: " << newFocusNode->nodeName().string();
             m_part->clearCaretRectIfNeeded();
             m_part->d->editor_context.m_selection.moveTo(Position(newFocusNode, 0L));
             m_part->setCaretVisible(true);
         } else {
             m_part->setCaretVisible(false);
             // qCDebug(KHTML_LOG) << "hide caret! fn: " << newFocusNode->nodeName().string();
         }
         m_part->notifySelectionChanged();
 
         targetVisible = scrollTo(newFocusNode->getRect());
     }
 
     if (targetVisible) {
         //qCDebug(KHTML_LOG) << " target reached.\n";
         d->tabMovePending = false;
 
         m_part->xmlDocImpl()->setFocusNode(newFocusNode);
         if (newFocusNode) {
             Node guard(newFocusNode);
             if (!newFocusNode->hasOneRef()) {
                 emit m_part->nodeActivated(Node(newFocusNode));
             }
             return true;
         } else {
             d->pseudoFocusNode = next ? KHTMLViewPrivate::PFBottom : KHTMLViewPrivate::PFTop;
             return false;
         }
     } else {
         if (!d->tabMovePending) {
             d->lastTabbingDirection = next;
         }
         d->tabMovePending = true;
         return true;
     }
 }
 
 void KHTMLView::displayAccessKeys()
 {
     QVector< QChar > taken;
     displayAccessKeys(nullptr, this, taken, false);
     displayAccessKeys(nullptr, this, taken, true);
 }
 
 void KHTMLView::displayAccessKeys(KHTMLView *caller, KHTMLView *origview, QVector< QChar > &taken, bool use_fallbacks)
 {
     QMap< ElementImpl *, QChar > fallbacks;
     if (use_fallbacks) {
         fallbacks = buildFallbackAccessKeys();
     }
     for (NodeImpl *n = m_part->xmlDocImpl(); n != nullptr; n = n->traverseNextNode()) {
         if (n->isElementNode()) {
             ElementImpl *en = static_cast< ElementImpl * >(n);
             DOMString s = en->getAttribute(ATTR_ACCESSKEY);
             QString accesskey;
             if (s.length() == 1) {
                 QChar a = s.string()[ 0 ].toUpper();
                 if (qFind(taken.begin(), taken.end(), a) == taken.end()) { // !contains
                     accesskey = a;
                 }
             }
             if (accesskey.isNull() && fallbacks.contains(en)) {
                 QChar a = fallbacks[ en ].toUpper();
                 if (qFind(taken.begin(), taken.end(), a) == taken.end()) { // !contains
                     accesskey = QString("<qt><i>") + a + "</i></qt>";
                 }
             }
             if (!accesskey.isNull()) {
                 QRect rec = en->getRect();
                 QLabel *lab = new QLabel(accesskey, widget());
                 lab->setAttribute(Qt::WA_DeleteOnClose);
                 lab->setObjectName("KHTMLAccessKey");
                 connect(origview, SIGNAL(hideAccessKeys()), lab, SLOT(close()));
                 connect(this, SIGNAL(repaintAccessKeys()), lab, SLOT(repaint()));
                 lab->setPalette(QToolTip::palette());
                 lab->setLineWidth(2);
                 lab->setFrameStyle(QFrame::Box | QFrame::Plain);
                 lab->setContentsMargins(3, 3, 3, 3);
                 lab->adjustSize();
                 lab->setParent(widget());
                 lab->setAutoFillBackground(true);
                 lab->move(
                     qMin(rec.left() + rec.width() / 2 - contentsX(), contentsWidth() - lab->width()),
                     qMin(rec.top() + rec.height() / 2 - contentsY(), contentsHeight() - lab->height()));
                 lab->show();
                 taken.append(accesskey[ 0 ]);
             }
         }
     }
     if (use_fallbacks) {
         return;
     }
 
     QList<KParts::ReadOnlyPart *> frames = m_part->frames();
     foreach (KParts::ReadOnlyPart *cur, frames) {
         if (!qobject_cast<KHTMLPart *>(cur)) {
             continue;
         }
         KHTMLPart *part = static_cast< KHTMLPart * >(cur);
         if (part->view() && part->view() != caller) {
             part->view()->displayAccessKeys(this, origview, taken, use_fallbacks);
         }
     }
 
     // pass up to the parent
     if (m_part->parentPart() && m_part->parentPart()->view()
             && m_part->parentPart()->view() != caller) {
         m_part->parentPart()->view()->displayAccessKeys(this, origview, taken, use_fallbacks);
     }
 }
 
 bool KHTMLView::isScrollingFromMouseWheel() const
 {
     return d->scrollingFromWheel != QPoint(-1, -1);
 }
 
 void KHTMLView::accessKeysTimeout()
 {
     d->accessKeysActivated = false;
     d->accessKeysPreActivate = false;
     m_part->setStatusBarText(QString(), KHTMLPart::BarOverrideText);
     emit hideAccessKeys();
 }
 
 // Handling of the HTML accesskey attribute.
 bool KHTMLView::handleAccessKey(const QKeyEvent *ev)
 {
 // Qt interprets the keyevent also with the modifiers, and ev->text() matches that,
 // but this code must act as if the modifiers weren't pressed
     QChar c;
     if (ev->key() >= Qt::Key_A && ev->key() <= Qt::Key_Z) {
         c = 'A' + ev->key() - Qt::Key_A;
     } else if (ev->key() >= Qt::Key_0 && ev->key() <= Qt::Key_9) {
         c = '0' + ev->key() - Qt::Key_0;
     } else {
         // TODO fake XKeyEvent and XLookupString ?
         // This below seems to work e.g. for eacute though.
         if (ev->text().length() == 1) {
             c = ev->text()[ 0 ];
         }
     }
     if (c.isNull()) {
         return false;
     }
     return focusNodeWithAccessKey(c);
 }
 
 bool KHTMLView::focusNodeWithAccessKey(QChar c, KHTMLView *caller)
 {
     DocumentImpl *doc = m_part->xmlDocImpl();
     if (!doc) {
         return false;
     }
     ElementImpl *node = doc->findAccessKeyElement(c);
     if (!node) {
         QList<KParts::ReadOnlyPart *> frames = m_part->frames();
         foreach (KParts::ReadOnlyPart *cur, frames) {
             if (!qobject_cast<KHTMLPart *>(cur)) {
                 continue;
             }
             KHTMLPart *part = static_cast< KHTMLPart * >(cur);
             if (part->view() && part->view() != caller
                     && part->view()->focusNodeWithAccessKey(c, this)) {
                 return true;
             }
         }
         // pass up to the parent
         if (m_part->parentPart() && m_part->parentPart()->view()
                 && m_part->parentPart()->view() != caller
                 && m_part->parentPart()->view()->focusNodeWithAccessKey(c, this)) {
             return true;
         }
         if (caller == nullptr) {  // the active frame (where the accesskey was pressed)
             const QMap< ElementImpl *, QChar > fallbacks = buildFallbackAccessKeys();
             for (QMap< ElementImpl *, QChar >::ConstIterator it = fallbacks.begin();
                     it != fallbacks.end();
                     ++it)
                 if (*it == c) {
                     node = it.key();
                     break;
                 }
         }
         if (node == nullptr) {
             return false;
         }
     }
 
     // Scroll the view as necessary to ensure that the new focus node is visible
 
     QRect r = node->getRect();
     ensureVisible(r.right(), r.bottom());
     ensureVisible(r.left(), r.top());
 
     Node guard(node);
     if (node->isFocusable()) {
         if (node->id() == ID_LABEL) {
             // if Accesskey is a label, give focus to the label's referrer.
             node = static_cast<ElementImpl *>(static_cast< HTMLLabelElementImpl * >(node)->getFormElement());
             if (!node) {
                 return true;
             }
             guard = node;
         }
         // Set focus node on the document
         m_part->xmlDocImpl()->setFocusNode(node);
 
         if (node != nullptr && node->hasOneRef()) { // deleted, only held by guard
             return true;
         }
         emit m_part->nodeActivated(Node(node));
         if (node != nullptr && node->hasOneRef()) {
             return true;
         }
     }
 
     switch (node->id()) {
     case ID_A:
         static_cast< HTMLAnchorElementImpl * >(node)->click();
         break;
     case ID_INPUT:
         static_cast< HTMLInputElementImpl * >(node)->click();
         break;
     case ID_BUTTON:
         static_cast< HTMLButtonElementImpl * >(node)->click();
         break;
     case ID_AREA:
         static_cast< HTMLAreaElementImpl * >(node)->click();
         break;
     case ID_TEXTAREA:
         break; // just focusing it is enough
     case ID_LEGEND:
         // TODO
         break;
     }
     return true;
 }
 
 static QString getElementText(NodeImpl *start, bool after)
 {
     QString ret;             // nextSibling(), to go after e.g. </select>
     for (NodeImpl *n = after ? start->nextSibling() : start->traversePreviousNode();
             n != nullptr;
             n = after ? n->traverseNextNode() : n->traversePreviousNode()) {
         if (n->isTextNode()) {
             if (after) {
                 ret += static_cast< TextImpl * >(n)->toString().string();
             } else {
                 ret.prepend(static_cast< TextImpl * >(n)->toString().string());
             }
         } else {
             switch (n->id()) {
             case ID_A:
             case ID_FONT:
             case ID_TT:
             case ID_U:
             case ID_B:
             case ID_I:
             case ID_S:
             case ID_STRIKE:
             case ID_BIG:
             case ID_SMALL:
             case ID_EM:
             case ID_STRONG:
             case ID_DFN:
             case ID_CODE:
             case ID_SAMP:
             case ID_KBD:
             case ID_VAR:
             case ID_CITE:
             case ID_ABBR:
             case ID_ACRONYM:
             case ID_SUB:
             case ID_SUP:
             case ID_SPAN:
             case ID_NOBR:
             case ID_WBR:
                 break;
             case ID_TD:
                 if (ret.trimmed().isEmpty()) {
                     break;
                 }
             // fall through
             default:
                 return ret.simplified();
             }
         }
     }
     return ret.simplified();
 }
 
 static QMap< NodeImpl *, QString > buildLabels(NodeImpl *start)
 {
     QMap< NodeImpl *, QString > ret;
     for (NodeImpl *n = start;
             n != nullptr;
             n = n->traverseNextNode()) {
         if (n->id() == ID_LABEL) {
             HTMLLabelElementImpl *label = static_cast< HTMLLabelElementImpl * >(n);
             NodeImpl *labelfor = label->getFormElement();
             if (labelfor) {
                 ret[ labelfor ] = label->innerText().string().simplified();
             }
         }
     }
     return ret;
 }
 
 namespace khtml
 {
 struct AccessKeyData {
     ElementImpl *element;
     QString text;
     QString url;
     int priority; // 10(highest) - 0(lowest)
 };
 }
 
 QMap< ElementImpl *, QChar > KHTMLView::buildFallbackAccessKeys() const
 {
     // build a list of all possible candidate elements that could use an accesskey
     QLinkedList< AccessKeyData > data; // Note: this has to be a list type that keep iterators valid
     // when other entries are removed
     QMap< NodeImpl *, QString > labels = buildLabels(m_part->xmlDocImpl());
     QMap< QString, QChar > hrefs;
 
     for (NodeImpl *n = m_part->xmlDocImpl();
             n != nullptr;
             n = n->traverseNextNode()) {
         if (n->isElementNode()) {
             ElementImpl *element = static_cast< ElementImpl * >(n);
             if (element->renderer() == nullptr) {
                 continue;    // not visible
             }
             QString text;
             QString url;
             int priority = 0;
             bool ignore = false;
             bool text_after = false;
             bool text_before = false;
             switch (element->id()) {
             case ID_A:
                 url = element->getAttribute(ATTR_HREF).trimSpaces().string();
                 if (url.isEmpty()) { // doesn't have href, it's only an anchor
                     continue;
                 }
                 text = static_cast< HTMLElementImpl * >(element)->innerText().string().simplified();
                 priority = 2;
                 break;
             case ID_INPUT: {
                 HTMLInputElementImpl *in = static_cast< HTMLInputElementImpl * >(element);
                 switch (in->inputType()) {
                 case HTMLInputElementImpl::SUBMIT:
                     text = in->value().string();
                     if (text.isEmpty()) {
                         text = i18n("Submit");
                     }
                     priority = 7;
                     break;
                 case HTMLInputElementImpl::IMAGE:
                     text = in->altText().string();
                     priority = 7;
                     break;
                 case HTMLInputElementImpl::BUTTON:
                     text = in->value().string();
                     priority = 5;
                     break;
                 case HTMLInputElementImpl::RESET:
                     text = in->value().string();
                     if (text.isEmpty()) {
                         text = i18n("Reset");
                     }
                     priority = 5;
                     break;
                 case HTMLInputElementImpl::HIDDEN:
                     ignore = true;
                     break;
                 case HTMLInputElementImpl::CHECKBOX:
                 case HTMLInputElementImpl::RADIO:
                     text_after = true;
                     priority = 5;
                     break;
                 case HTMLInputElementImpl::TEXT:
                 case HTMLInputElementImpl::PASSWORD:
                 case HTMLInputElementImpl::FILE:
                     text_before = true;
                     priority = 5;
                     break;
                 default:
                     priority = 5;
                     break;
                 }
                 break;
             }
             case ID_BUTTON:
                 text = static_cast< HTMLElementImpl * >(element)->innerText().string().simplified();
                 switch (static_cast< HTMLButtonElementImpl * >(element)->buttonType()) {
                 case HTMLButtonElementImpl::SUBMIT:
                     if (text.isEmpty()) {
                         text = i18n("Submit");
                     }
                     priority = 7;
                     break;
                 case HTMLButtonElementImpl::RESET:
                     if (text.isEmpty()) {
                         text = i18n("Reset");
                     }
                     priority = 5;
                     break;
                 default:
                     priority = 5;
                     break;
                 }
                 break;
             case ID_SELECT: // these don't have accesskey attribute, but quick access may be handy
                 text_before = true;
                 text_after = true;
                 priority = 5;
                 break;
             case ID_FRAME:
                 ignore = true;
                 break;
             default:
                 ignore = !element->isFocusable();
                 priority = 2;
                 break;
             }
             if (ignore) {
                 continue;
             }
 
             // build map of manually assigned accesskeys and their targets
             DOMString akey = element->getAttribute(ATTR_ACCESSKEY);
             if (akey.length() == 1) {
                 hrefs[url] = akey.string()[ 0 ].toUpper();
                 continue; // has accesskey set, ignore
             }
             if (text.isNull() && labels.contains(element)) {
                 text = labels[ element ];
             }
             if (text.isNull() && text_before) {
                 text = getElementText(element, false);
             }
             if (text.isNull() && text_after) {
                 text = getElementText(element, true);
             }
             text = text.trimmed();
             // increase priority of items which have explicitly specified accesskeys in the config
             const QList< QPair< QString, QChar > > priorities
                 = m_part->settings()->fallbackAccessKeysAssignments();
             for (QList< QPair< QString, QChar > >::ConstIterator it = priorities.begin();
                     it != priorities.end();
                     ++it) {
                 if (text == (*it).first) {
                     priority = 10;
                 }
             }
             AccessKeyData tmp = { element, text, url, priority };
             data.append(tmp);
         }
     }
 
     QList< QChar > keys;
     for (char c = 'A'; c <= 'Z'; ++c) {
         keys << c;
     }
     for (char c = '0'; c <= '9'; ++c) {
         keys << c;
     }
     for (NodeImpl *n = m_part->xmlDocImpl();
             n != nullptr;
             n = n->traverseNextNode()) {
         if (n->isElementNode()) {
             ElementImpl *en = static_cast< ElementImpl * >(n);
             DOMString s = en->getAttribute(ATTR_ACCESSKEY);
             if (s.length() == 1) {
                 QChar c = s.string()[ 0 ].toUpper();
                 keys.removeAll(c);   // remove manually assigned accesskeys
             }
         }
     }
 
     QMap< ElementImpl *, QChar > ret;
     for (int priority = 10; priority >= 0; --priority) {
         for (QLinkedList< AccessKeyData >::Iterator it = data.begin();
                 it != data.end();
             ) {
             if ((*it).priority != priority) {
                 ++it;
                 continue;
             }
             if (keys.isEmpty()) {
                 break;
             }
             QString text = (*it).text;
             QChar key;
             const QString url = (*it).url;
             // an identical link already has an accesskey assigned
             if (hrefs.contains(url)) {
                 it = data.erase(it);
                 continue;
             }
             if (!text.isEmpty()) {
                 const QList< QPair< QString, QChar > > priorities
                     = m_part->settings()->fallbackAccessKeysAssignments();
                 for (QList< QPair< QString, QChar > >::ConstIterator it = priorities.begin();
                         it != priorities.end();
                         ++it)
                     if (text == (*it).first && keys.contains((*it).second)) {
                         key = (*it).second;
                         break;
                     }
             }
             // try first to select the first character as the accesskey,
             // then first character of the following words,
             // and then simply the first free character
             if (key.isNull() && !text.isEmpty()) {
                 const QStringList words = text.split(' ');
                 for (QStringList::ConstIterator it = words.begin();
                         it != words.end();
                         ++it) {
                     if (keys.contains((*it)[ 0 ].toUpper())) {
                         key = (*it)[ 0 ].toUpper();
                         break;
                     }
                 }
             }
             if (key.isNull() && !text.isEmpty()) {
                 for (int i = 0; i < text.length(); ++i) {
                     if (keys.contains(text[ i ].toUpper())) {
                         key = text[ i ].toUpper();
                         break;
                     }
                 }
             }
             if (key.isNull()) {
                 key = keys.front();
             }
             ret[(*it).element ] = key;
             keys.removeAll(key);
             it = data.erase(it);
             // assign the same accesskey also to other elements pointing to the same url
             if (!url.isEmpty() && !url.startsWith("javascript:", Qt::CaseInsensitive)) {
                 for (QLinkedList< AccessKeyData >::Iterator it2 = data.begin();
                         it2 != data.end();
                     ) {
                     if ((*it2).url == url) {
                         ret[(*it2).element ] = key;
                         if (it == it2) {
                             ++it;
                         }
                         it2 = data.erase(it2);
                     } else {
                         ++it2;
                     }
                 }
             }
         }
     }
     return ret;
 }
 
 void KHTMLView::setMediaType(const QString &medium)
 {
     m_medium = medium;
 }
 
 QString KHTMLView::mediaType() const
 {
     return m_medium;
 }
 
 bool KHTMLView::pagedMode() const
 {
     return d->paged;
 }
 
 void KHTMLView::setWidgetVisible(RenderWidget *w, bool vis)
 {
     if (vis) {
         d->visibleWidgets.insert(w, w->widget());
     } else {
         d->visibleWidgets.remove(w);
     }
 }
 
 bool KHTMLView::needsFullRepaint() const
 {
     return d->needsFullRepaint;
 }
 
 namespace
 {
 class QPointerDeleter
 {
 public:
     explicit QPointerDeleter(QObject *o) : obj(o) {}
     ~QPointerDeleter()
     {
         delete obj;
     }
 private:
     const QPointer<QObject> obj;
 };
 }
 
 void KHTMLView::print(bool quick)
 {
     QPrinter printer;
     print(&printer, quick);
 }
 
 void KHTMLView::print(QPrinter *_printer, bool quick)
 {
     if (!m_part->xmlDocImpl()) {
         return;
     }
     khtml::RenderCanvas *root = static_cast<khtml::RenderCanvas *>(m_part->xmlDocImpl()->renderer());
     if (!root) {
         return;
     }
 
     QPrinter &printer = *_printer;
     QPointer<QPrintDialog> dialog(new QPrintDialog(&printer, this));
     QPointer<KHTMLPrintSettings> printSettings(new KHTMLPrintSettings(dialog)); //XXX: doesn't save settings between prints like this
     dialog->setOptionTabs(QList<QWidget *>() << printSettings.data());
 
     const QPointerDeleter dialogDeleter(dialog);
 
     QString docname = m_part->xmlDocImpl()->URL().toDisplayString();
     if (!docname.isEmpty()) {
         docname = KStringHandler::csqueeze(docname, 80);
     }
 
     if (quick || (dialog->exec() && dialog)) { /*'this' and thus dialog might have been deleted while exec()!*/
         viewport()->setCursor(Qt::WaitCursor);   // only viewport(), no QApplication::, otherwise we get the busy cursor in kdeprint's dialogs
         // set up KPrinter
         printer.setFullPage(false);
         printer.setCreator(QString("KDE %1.%2.%3 HTML Library").arg(KHTML_VERSION_MAJOR).arg(KHTML_VERSION_MINOR).arg(KHTML_VERSION_PATCH));
         printer.setDocName(docname);
 
         QPainter *p = new QPainter;
         p->begin(&printer);
         khtml::setPrintPainter(p);
 
         m_part->xmlDocImpl()->setPaintDevice(&printer);
         QString oldMediaType = mediaType();
         setMediaType("print");
         // We ignore margin settings for html and body when printing
         // and use the default margins from the print-system
         // (In Qt 3.0.x the default margins are hardcoded in Qt)
         m_part->xmlDocImpl()->setPrintStyleSheet(printSettings->printFriendly() ?
                 "* { background-image: none !important;"
                 "    background-color: white !important;"
                 "    color: black !important; }"
                 "body { margin: 0px !important; }"
                 "html { margin: 0px !important; }" :
                 "body { margin: 0px !important; }"
                 "html { margin: 0px !important; }"
                                                 );
 
         // qCDebug(KHTML_LOG) << "printing: physical page width = " << printer.width()
         //              << " height = " << printer.height();
         root->setStaticMode(true);
         root->setPagedMode(true);
         root->setWidth(printer.width());
 //         root->setHeight(printer.height());
         root->setPageTop(0);
         root->setPageBottom(0);
         d->paged = true;
 
         m_part->xmlDocImpl()->styleSelector()->computeFontSizes(printer.logicalDpiY(), 100);
         m_part->xmlDocImpl()->updateStyleSelector();
         root->setPrintImages(printSettings->printImages());
         root->makePageBreakAvoidBlocks();
 
         root->setNeedsLayoutAndMinMaxRecalc();
         root->layout();
 
         // check sizes ask for action.. (scale or clip)
 
         bool printHeader = printSettings->printHeader();
 
         int headerHeight = 0;
         QFont headerFont("Sans Serif", 8);
 
         QString headerLeft = QDate::currentDate().toString(Qt::DefaultLocaleShortDate);
         QString headerMid = docname;
         QString headerRight;
 
         if (printHeader) {
             p->setFont(headerFont);
             headerHeight = (p->fontMetrics().lineSpacing() * 3) / 2;
         }
 
         // ok. now print the pages.
         // qCDebug(KHTML_LOG) << "printing: html page width = " << root->docWidth()
         //              << " height = " << root->docHeight();
         // qCDebug(KHTML_LOG) << "printing: margins left = " << printer.pageRect().left() - printer.paperRect().left()
         //              << " top = " << printer.pageRect().top() - printer.paperRect().top();
         // qCDebug(KHTML_LOG) << "printing: paper width = " << printer.width()
         //              << " height = " << printer.height();
         // if the width is too large to fit on the paper we just scale
         // the whole thing.
         int pageWidth = printer.width();
         int pageHeight = printer.height();
         p->setClipRect(0, 0, pageWidth, pageHeight);
 
         pageHeight -= headerHeight;
 
 #ifndef QT_NO_TRANSFORMATIONS
         bool scalePage = false;
         double scale = 0.0;
         if (root->docWidth() > printer.width()) {
             scalePage = true;
             scale = ((double) printer.width()) / ((double) root->docWidth());
             pageHeight = (int)(pageHeight / scale);
             pageWidth = (int)(pageWidth / scale);
             headerHeight = (int)(headerHeight / scale);
         }
 #endif
         // qCDebug(KHTML_LOG) << "printing: scaled html width = " << pageWidth
         //              << " height = " << pageHeight;
 
         root->setHeight(pageHeight);
         root->setPageBottom(pageHeight);
         root->setNeedsLayout(true);
         root->layoutIfNeeded();
 //         m_part->slotDebugRenderTree();
 
         // Squeeze header to make it it on the page.
         if (printHeader) {
             int available_width = printer.width() - 10 -
                                   2 * qMax(p->boundingRect(0, 0, printer.width(), p->fontMetrics().lineSpacing(), Qt::AlignLeft, headerLeft).width(),
                                            p->boundingRect(0, 0, printer.width(), p->fontMetrics().lineSpacing(), Qt::AlignLeft, headerRight).width());
             if (available_width < 150) {
                 available_width = 150;
             }
             int mid_width;
             int squeeze = 120;
             do {
                 headerMid = KStringHandler::csqueeze(docname, squeeze);
                 mid_width = p->boundingRect(0, 0, printer.width(), p->fontMetrics().lineSpacing(), Qt::AlignLeft, headerMid).width();
                 squeeze -= 10;
             } while (mid_width > available_width);
         }
 
         int top = 0;
         int bottom = 0;
         int page = 1;
         while (top < root->docHeight()) {
             if (top > 0) {
                 printer.newPage();
             }
 #ifndef QT_NO_TRANSFORMATIONS
             if (scalePage) {
                 p->scale(scale, scale);
             }
 #endif
             p->save();
             p->setClipRect(0, 0, pageWidth, headerHeight);
             if (printHeader) {
                 int dy = p->fontMetrics().lineSpacing();
                 p->setPen(Qt::black);
                 p->setFont(headerFont);
 
                 headerRight = QString("#%1").arg(page);
 
                 p->drawText(0, 0, printer.width(), dy, Qt::AlignLeft, headerLeft);
                 p->drawText(0, 0, printer.width(), dy, Qt::AlignHCenter, headerMid);
                 p->drawText(0, 0, printer.width(), dy, Qt::AlignRight, headerRight);
             }
 
             p->restore();
             p->translate(0, headerHeight - top);
 
             bottom = top + pageHeight;
 
             root->setPageTop(top);
             root->setPageBottom(bottom);
             root->setPageNumber(page);
 
             root->layer()->paint(p, QRect(0, top, pageWidth, pageHeight));
             // qCDebug(KHTML_LOG) << "printed: page " << page <<" bottom At = " << bottom;
 
             top = bottom;
             p->resetTransform();
             page++;
         }
 
         p->end();
         delete p;
 
         // and now reset the layout to the usual one...
         root->setPagedMode(false);
         root->setStaticMode(false);
         d->paged = false;
         khtml::setPrintPainter(nullptr);
         setMediaType(oldMediaType);
         m_part->xmlDocImpl()->setPaintDevice(this);
         m_part->xmlDocImpl()->styleSelector()->computeFontSizes(m_part->xmlDocImpl()->logicalDpiY(), m_part->fontScaleFactor());
         m_part->xmlDocImpl()->updateStyleSelector();
         viewport()->unsetCursor();
     }
 }
 
 void KHTMLView::slotPaletteChanged()
 {
     if (!m_part->xmlDocImpl()) {
         return;
     }
     DOM::DocumentImpl *document = m_part->xmlDocImpl();
     if (!document->isHTMLDocument()) {
         return;
     }
     khtml::RenderCanvas *root = static_cast<khtml::RenderCanvas *>(document->renderer());
     if (!root) {
         return;
     }
     root->style()->resetPalette();
     NodeImpl *body = static_cast<HTMLDocumentImpl *>(document)->body();
     if (!body) {
         return;
     }
     body->setChanged(true);
     body->recalcStyle(NodeImpl::Force);
 }
 
 void KHTMLView::paint(QPainter *p, const QRect &rc, int yOff, bool *more)
 {
     if (!m_part->xmlDocImpl()) {
         return;
     }
     khtml::RenderCanvas *root = static_cast<khtml::RenderCanvas *>(m_part->xmlDocImpl()->renderer());
     if (!root) {
         return;
     }
 #ifdef SPEED_DEBUG
     d->firstRepaintPending = false;
 #endif
 
     QPaintDevice *opd = m_part->xmlDocImpl()->paintDevice();
     m_part->xmlDocImpl()->setPaintDevice(p->device());
     root->setPagedMode(true);
     root->setStaticMode(true);
     root->setWidth(rc.width());
 
     // save()
     QRegion creg = p->clipRegion();
     QTransform t = p->worldTransform();
     QRect w = p->window();
     QRect v = p->viewport();
     bool vte = p->viewTransformEnabled();
     bool wme = p->worldMatrixEnabled();
 
     p->setClipRect(rc);
     p->translate(rc.left(), rc.top());
     double scale = ((double) rc.width() / (double) root->docWidth());
     int height = (int)((double) rc.height() / scale);
 #ifndef QT_NO_TRANSFORMATIONS
     p->scale(scale, scale);
 #endif
     root->setPageTop(yOff);
     root->setPageBottom(yOff + height);
 
     root->layer()->paint(p, QRect(0, yOff, root->docWidth(), height));
     if (more) {
         *more = yOff + height < root->docHeight();
     }
 
     // restore()
     p->setWorldTransform(t);
     p->setWindow(w);
     p->setViewport(v);
     p->setViewTransformEnabled(vte);
     p->setWorldMatrixEnabled(wme);
     if (!creg.isEmpty()) {
         p->setClipRegion(creg);
     } else {
         p->setClipRegion(QRegion(), Qt::NoClip);
     }
 
     root->setPagedMode(false);
     root->setStaticMode(false);
     m_part->xmlDocImpl()->setPaintDevice(opd);
 }
 
 void KHTMLView::render(QPainter *p, const QRect &r, const QPoint &off)
 {
 #ifdef SPEED_DEBUG
     d->firstRepaintPending = false;
 #endif
     QRect clip(off.x() + r.x(), off.y() + r.y(), r.width(), r.height());
     if (!m_part || !m_part->xmlDocImpl() || !m_part->xmlDocImpl()->renderer()) {
         p->fillRect(clip, palette().brush(QPalette::Active, QPalette::Base));
         return;
     }
     QPaintDevice *opd = m_part->xmlDocImpl()->paintDevice();
     m_part->xmlDocImpl()->setPaintDevice(p->device());
 
     // save()
     QRegion creg = p->clipRegion();
     QTransform t = p->worldTransform();
     QRect w = p->window();
     QRect v = p->viewport();
     bool vte = p->viewTransformEnabled();
     bool wme = p->worldMatrixEnabled();
 
     p->setClipRect(clip);
     QRect rect = r.translated(contentsX(), contentsY());
     p->translate(off.x() - contentsX(), off.y() - contentsY());
 
     m_part->xmlDocImpl()->renderer()->layer()->paint(p, rect);
 
     // restore()
     p->setWorldTransform(t);
     p->setWindow(w);
     p->setViewport(v);
     p->setViewTransformEnabled(vte);
     p->setWorldMatrixEnabled(wme);
     if (!creg.isEmpty()) {
         p->setClipRegion(creg);
     } else {
         p->setClipRegion(QRegion(), Qt::NoClip);
     }
 
     m_part->xmlDocImpl()->setPaintDevice(opd);
 }
 
 void KHTMLView::setHasStaticBackground(bool partial)
 {
     // full static iframe is irreversible for now
     if (d->staticWidget == KHTMLViewPrivate::SBFull && m_kwp->isRedirected()) {
         return;
     }
 
     d->staticWidget = partial ?
                       KHTMLViewPrivate::SBPartial : KHTMLViewPrivate::SBFull;
 }
 
 void KHTMLView::setHasNormalBackground()
 {
     // full static iframe is irreversible for now
     if (d->staticWidget == KHTMLViewPrivate::SBFull && m_kwp->isRedirected()) {
         return;
     }
 
     d->staticWidget = KHTMLViewPrivate::SBNone;
 }
 
 void KHTMLView::addStaticObject(bool fixed)
 {
     if (fixed) {
         d->fixedObjectsCount++;
     } else {
         d->staticObjectsCount++;
     }
 
     setHasStaticBackground(true /*partial*/);
 }
 
 void KHTMLView::removeStaticObject(bool fixed)
 {
     if (fixed) {
         d->fixedObjectsCount--;
     } else {
         d->staticObjectsCount--;
     }
 
     assert(d->fixedObjectsCount >= 0 && d->staticObjectsCount >= 0);
 
     if (!d->staticObjectsCount && !d->fixedObjectsCount) {
         setHasNormalBackground();
     } else {
         setHasStaticBackground(true /*partial*/);
     }
 }
 
 void KHTMLView::setVerticalScrollBarPolicy(Qt::ScrollBarPolicy policy)
 {
 #ifndef KHTML_NO_SCROLLBARS
     d->vpolicy = policy;
     QScrollArea::setVerticalScrollBarPolicy(policy);
 #else
     Q_UNUSED(policy);
 #endif
 }
 
 void KHTMLView::setHorizontalScrollBarPolicy(Qt::ScrollBarPolicy policy)
 {
 #ifndef KHTML_NO_SCROLLBARS
     d->hpolicy = policy;
     QScrollArea::setHorizontalScrollBarPolicy(policy);
 #else
     Q_UNUSED(policy);
 #endif
 }
 
 void KHTMLView::restoreScrollBar()
 {
     int ow = visibleWidth();
     QScrollArea::setVerticalScrollBarPolicy(d->vpolicy);
     if (visibleWidth() != ow) {
         layout();
     }
     d->prevScrollbarVisible = verticalScrollBar()->isVisible();
 }
 
 QStringList KHTMLView::formCompletionItems(const QString &name) const
 {
     if (!m_part->settings()->isFormCompletionEnabled()) {
         return QStringList();
     }
     if (!d->formCompletions) {
         d->formCompletions = new KConfig(QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1Char('/') + "khtml/formcompletions");
     }
     return d->formCompletions->group("").readEntry(name, QStringList());
 }
 
 void KHTMLView::clearCompletionHistory(const QString &name)
 {
     if (!d->formCompletions) {
         d->formCompletions = new KConfig(QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1Char('/') + "khtml/formcompletions");
     }
     d->formCompletions->group("").writeEntry(name, "");
     d->formCompletions->sync();
 }
 
 void KHTMLView::addFormCompletionItem(const QString &name, const QString &value)
 {
     if (!m_part->settings()->isFormCompletionEnabled()) {
         return;
     }
     // don't store values that are all numbers or just numbers with
     // dashes or spaces as those are likely credit card numbers or
     // something similar
     bool cc_number(true);
     for (int i = 0; i < value.length(); ++i) {
         QChar c(value[i]);
         if (!c.isNumber() && c != '-' && !c.isSpace()) {
             cc_number = false;
             break;
         }
     }
     if (cc_number) {
         return;
     }
     QStringList items = formCompletionItems(name);
     if (!items.contains(value)) {
         items.prepend(value);
     }
     while ((int)items.count() > m_part->settings()->maxFormCompletionItems()) {
         items.erase(items.isEmpty() ? items.end() : --items.end());
     }
     d->formCompletions->group("").writeEntry(name, items);
 }
 
 void KHTMLView::addNonPasswordStorableSite(const QString &host)
 {
     if (!d->formCompletions) {
         d->formCompletions = new KConfig(QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1Char('/') + "khtml/formcompletions");
     }
 
     KConfigGroup cg(d->formCompletions, "NonPasswordStorableSites");
     QStringList sites = cg.readEntry("Sites", QStringList());
     sites.append(host);
     cg.writeEntry("Sites", sites);
     cg.sync();
 }
 
 void KHTMLView::delNonPasswordStorableSite(const QString &host)
 {
     if (!d->formCompletions) {
         d->formCompletions = new KConfig(QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1Char('/') + "khtml/formcompletions");
     }
 
     KConfigGroup cg(d->formCompletions, "NonPasswordStorableSites");
     QStringList sites = cg.readEntry("Sites", QStringList());
     sites.removeOne(host);
     cg.writeEntry("Sites", sites);
     cg.sync();
 }
 
 bool KHTMLView::nonPasswordStorableSite(const QString &host) const
 {
     if (!d->formCompletions) {
         d->formCompletions = new KConfig(QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1Char('/') + "khtml/formcompletions");
     }
     QStringList sites =  d->formCompletions->group("NonPasswordStorableSites").readEntry("Sites", QStringList());
     return (sites.indexOf(host) != -1);
 }
 
 // returns true if event should be swallowed
 bool KHTMLView::dispatchMouseEvent(int eventId, DOM::NodeImpl *targetNode,
                                    DOM::NodeImpl *targetNodeNonShared, bool cancelable,
                                    int detail, QMouseEvent *_mouse, bool setUnder,
                                    int mouseEventType, int orient)
 {
     // if the target node is a text node, dispatch on the parent node - rdar://4196646 (and #76948)
     if (targetNode && targetNode->isTextNode()) {
         targetNode = targetNode->parentNode();
     }
 
     if (d->underMouse) {
         d->underMouse->deref();
     }
     d->underMouse = targetNode;
     if (d->underMouse) {
         d->underMouse->ref();
     }
 
     if (d->underMouseNonShared) {
         d->underMouseNonShared->deref();
     }
     d->underMouseNonShared = targetNodeNonShared;
     if (d->underMouseNonShared) {
         d->underMouseNonShared->ref();
     }
 
     bool isWheelEvent = (mouseEventType == DOM::NodeImpl::MouseWheel);
 
     int exceptioncode = 0;
     int pageX = _mouse->x();
     int pageY = _mouse->y();
     revertTransforms(pageX, pageY);
     int clientX = pageX - contentsX();
     int clientY = pageY - contentsY();
     int screenX = _mouse->globalX();
     int screenY = _mouse->globalY();
     int button = -1;
     switch (_mouse->button()) {
     case Qt::LeftButton:
         button = 0;
         break;
     case Qt::MidButton:
         button = 1;
         break;
     case Qt::RightButton:
         button = 2;
         break;
     default:
         break;
     }
     if (d->accessKeysEnabled && d->accessKeysPreActivate && button != -1) {
         d->accessKeysPreActivate = false;
     }
 
     bool ctrlKey = (_mouse->modifiers() & Qt::ControlModifier);
     bool altKey = (_mouse->modifiers() & Qt::AltModifier);
     bool shiftKey = (_mouse->modifiers() & Qt::ShiftModifier);
     bool metaKey = (_mouse->modifiers() & Qt::MetaModifier);
 
     // mouseout/mouseover
     if (setUnder && d->oldUnderMouse != targetNode) {
         if (d->oldUnderMouse && d->oldUnderMouse->document() != m_part->xmlDocImpl()) {
             d->oldUnderMouse->deref();
             d->oldUnderMouse = nullptr;
         }
         // send mouseout event to the old node
         if (d->oldUnderMouse) {
             // send mouseout event to the old node
             MouseEventImpl *me = new MouseEventImpl(EventImpl::MOUSEOUT_EVENT,
                                                     true, true, m_part->xmlDocImpl()->defaultView(),
                                                     0, screenX, screenY, clientX, clientY, pageX, pageY,
                                                     ctrlKey, altKey, shiftKey, metaKey,
                                                     button, targetNode);
             me->ref();
             d->oldUnderMouse->dispatchEvent(me, exceptioncode, true);
             me->deref();
         }
         // send mouseover event to the new node
         if (targetNode) {
             MouseEventImpl *me = new MouseEventImpl(EventImpl::MOUSEOVER_EVENT,
                                                     true, true, m_part->xmlDocImpl()->defaultView(),
                                                     0, screenX, screenY, clientX, clientY, pageX, pageY,
                                                     ctrlKey, altKey, shiftKey, metaKey,
                                                     button, d->oldUnderMouse);
 
             me->ref();
             targetNode->dispatchEvent(me, exceptioncode, true);
             me->deref();
         }
         if (d->oldUnderMouse) {
             d->oldUnderMouse->deref();
         }
         d->oldUnderMouse = targetNode;
         if (d->oldUnderMouse) {
             d->oldUnderMouse->ref();
         }
     }
 
     bool swallowEvent = false;
 
     if (targetNode) {
         // if the target node is a disabled widget, we don't want any full-blown mouse events
         if (targetNode->isGenericFormElement()
                 && static_cast<HTMLGenericFormElementImpl *>(targetNode)->disabled()) {
             return true;
         }
 
         // send the actual event
         bool dblclick = (eventId == EventImpl::CLICK_EVENT &&
                          _mouse->type() == QEvent::MouseButtonDblClick);
         MouseEventImpl *me = new MouseEventImpl(static_cast<EventImpl::EventId>(eventId),
                                                 true, cancelable, m_part->xmlDocImpl()->defaultView(),
                                                 detail, screenX, screenY, clientX, clientY, pageX, pageY,
                                                 ctrlKey, altKey, shiftKey, metaKey,
                                                 button, nullptr, isWheelEvent ? nullptr : _mouse, dblclick,
                                                 isWheelEvent ? static_cast<MouseEventImpl::Orientation>(orient) : MouseEventImpl::ONone);
         me->ref();
         if (!d->m_mouseEventsTarget && RenderLayer::gScrollBar && eventId == EventImpl::MOUSEDOWN_EVENT)
             // button is pressed inside a layer scrollbar, so make it the target for future mousemove events until released
         {
             d->m_mouseEventsTarget = RenderLayer::gScrollBar;
         }
         if (d->m_mouseEventsTarget && qobject_cast<QScrollBar *>(d->m_mouseEventsTarget) &&
                 dynamic_cast<KHTMLWidget *>(static_cast<QWidget *>(d->m_mouseEventsTarget))) {
             // we have a sticky mouse event target and it is a layer's scrollbar. Forward events manually.
             // ### should use the dom
             KHTMLWidget *w = dynamic_cast<KHTMLWidget *>(static_cast<QWidget *>(d->m_mouseEventsTarget));
             QPoint p = w->m_kwp->absolutePos();
             QMouseEvent fw(_mouse->type(), QPoint(pageX, pageY) - p, _mouse->button(), _mouse->buttons(), _mouse->modifiers());
             static_cast<RenderWidget::EventPropagator *>(static_cast<QWidget *>(d->m_mouseEventsTarget))->sendEvent(&fw);
             if (_mouse->type() == QMouseEvent::MouseButtonPress && _mouse->button() == Qt::RightButton) {
                 QContextMenuEvent cme(QContextMenuEvent::Mouse, p);
                 static_cast<RenderWidget::EventPropagator *>(static_cast<QWidget *>(d->m_mouseEventsTarget))->sendEvent(&cme);
                 d->m_mouseEventsTarget = nullptr;
             }
             swallowEvent = true;
         } else {
             targetNode->dispatchEvent(me, exceptioncode, true);
             bool defaultHandled = me->defaultHandled();
             if (defaultHandled || me->defaultPrevented()) {
                 swallowEvent = true;
             }
         }
         if (eventId == EventImpl::MOUSEDOWN_EVENT && !me->defaultPrevented()) {
             // Focus should be shifted on mouse down, not on a click.  -dwh
             // Blur current focus node when a link/button is clicked; this
             // is expected by some sites that rely on onChange handlers running
             // from form fields before the button click is processed.
             DOM::NodeImpl *nodeImpl = targetNode;
             for (; nodeImpl && !nodeImpl->isFocusable(); nodeImpl = nodeImpl->parentNode()) {
             }
             if (nodeImpl && nodeImpl->isMouseFocusable()) {
                 m_part->xmlDocImpl()->setFocusNode(nodeImpl);
             } else if (!nodeImpl || !nodeImpl->focused()) {
                 m_part->xmlDocImpl()->setFocusNode(nullptr);
             }
         }
         me->deref();
     }
 
     return swallowEvent;
 }
 
 void KHTMLView::setIgnoreWheelEvents(bool e)
 {
     d->ignoreWheelEvents = e;
 }
 
 #ifndef QT_NO_WHEELEVENT
 
 void KHTMLView::wheelEvent(QWheelEvent *e)
 {
     // check if we should reset the state of the indicator describing if
     // we are currently scrolling the view as a result of wheel events
     if (d->scrollingFromWheel != QPoint(-1, -1) && d->scrollingFromWheel != QCursor::pos()) {
         d->scrollingFromWheel = d->scrollingFromWheelTimerId ? QCursor::pos() : QPoint(-1, -1);
     }
 
     if (d->accessKeysEnabled && d->accessKeysPreActivate) {
         d->accessKeysPreActivate = false;
     }
 
     if ((e->modifiers() & Qt::ControlModifier) == Qt::ControlModifier) {
         emit zoomView(- e->delta());
         e->accept();
     } else if (d->firstLayoutPending) {
         e->accept();
     } else if (!m_kwp->isRedirected() &&
                ((e->orientation() == Qt::Vertical &&
                  ((d->ignoreWheelEvents && !verticalScrollBar()->isVisible())
                   || (e->delta() > 0 && contentsY() <= 0)
                   || (e->delta() < 0 && contentsY() >= contentsHeight() - visibleHeight())))
                 ||
                 (e->orientation() == Qt::Horizontal &&
                  ((d->ignoreWheelEvents && !horizontalScrollBar()->isVisible())
                   || (e->delta() > 0 && contentsX() <= 0)
                   || (e->delta() < 0 && contentsX() >= contentsWidth() - visibleWidth()))))
                && m_part->parentPart()) {
         if (m_part->parentPart()->view()) {
             m_part->parentPart()->view()->wheelEvent(e);
         }
         e->ignore();
     } else {
         int xm = e->x();
         int ym = e->y();
         revertTransforms(xm, ym);
 
         DOM::NodeImpl::MouseEvent mev(e->buttons(), DOM::NodeImpl::MouseWheel);
         m_part->xmlDocImpl()->prepareMouseEvent(false, xm, ym, &mev);
 
         MouseEventImpl::Orientation o = MouseEventImpl::OVertical;
         if (e->orientation() == Qt::Horizontal) {
             o = MouseEventImpl::OHorizontal;
         }
 
         QMouseEvent _mouse(QEvent::MouseMove, e->pos(), Qt::NoButton, e->buttons(), e->modifiers());
         bool swallow = dispatchMouseEvent(EventImpl::KHTML_MOUSEWHEEL_EVENT, mev.innerNode.handle(), mev.innerNonSharedNode.handle(),
                                           true, -e->delta() / 40, &_mouse, true, DOM::NodeImpl::MouseWheel, o);
 
         if (swallow) {
             return;
         }
 
         d->scrollBarMoved = true;
         d->scrollingFromWheel = QCursor::pos();
         if (d->smoothScrollMode != SSMDisabled) {
             d->shouldSmoothScroll = true;
         }
         if (d->scrollingFromWheelTimerId) {
             killTimer(d->scrollingFromWheelTimerId);
         }
         d->scrollingFromWheelTimerId = startTimer(400);
 
         if (m_part->parentPart()) {
             // don't propagate if we are a sub-frame and our scrollbars are already at end of range
             bool h = (static_cast<QWheelEvent *>(e)->orientation() == Qt::Horizontal);
             bool d = (static_cast<QWheelEvent *>(e)->delta() < 0);
             QScrollBar *hsb = horizontalScrollBar();
             QScrollBar *vsb = verticalScrollBar();
             if ((h && ((d && hsb->value() == hsb->maximum()) || (!d && hsb->value() == hsb->minimum()))) ||
                     (!h && ((d && vsb->value() == vsb->maximum()) || (!d && vsb->value() == vsb->minimum())))) {
                 e->accept();
                 return;
             }
         }
         QScrollArea::wheelEvent(e);
     }
 
 }
 #endif
 
 void KHTMLView::dragEnterEvent(QDragEnterEvent *ev)
 {
     // Still overridden for BC reasons only...
     QScrollArea::dragEnterEvent(ev);
 }
 
 void KHTMLView::dropEvent(QDropEvent *ev)
 {
     // Still overridden for BC reasons only...
     QScrollArea::dropEvent(ev);
 }
 
 void KHTMLView::focusInEvent(QFocusEvent *e)
 {
     DOM::NodeImpl *fn = m_part->xmlDocImpl() ? m_part->xmlDocImpl()->focusNode() : nullptr;
     if (fn && fn->renderer() && fn->renderer()->isWidget() &&
             (e->reason() != Qt::MouseFocusReason) &&
             static_cast<khtml::RenderWidget *>(fn->renderer())->widget()) {
         static_cast<khtml::RenderWidget *>(fn->renderer())->widget()->setFocus();
     }
     m_part->setSelectionVisible();
     QScrollArea::focusInEvent(e);
 }
 
 void KHTMLView::focusOutEvent(QFocusEvent *e)
 {
     if (m_part) {
         m_part->stopAutoScroll();
         m_part->setSelectionVisible(false);
     }
 
     if (d->cursorIconWidget) {
         d->cursorIconWidget->hide();
     }
 
     QScrollArea::focusOutEvent(e);
 }
 
 void KHTMLView::scrollContentsBy(int dx, int dy)
 {
     if (!dx && !dy) {
         return;
     }
 
     if (!d->firstLayoutPending && !d->complete && m_part->xmlDocImpl() &&
             d->layoutSchedulingEnabled) {
         // contents scroll while we are not complete: we need to check our layout *now*
         khtml::RenderCanvas *root = static_cast<khtml::RenderCanvas *>(m_part->xmlDocImpl()->renderer());
         if (root && root->needsLayout()) {
             unscheduleRelayout();
             layout();
         }
     }
 
     if (d->shouldSmoothScroll && d->smoothScrollMode != SSMDisabled && m_part->xmlDocImpl() &&
             m_part->xmlDocImpl()->renderer() && (d->smoothScrollMode != SSMWhenEfficient || d->smoothScrollMissedDeadlines != sWayTooMany)) {
 
         bool doSmoothScroll = (!d->staticWidget || d->smoothScrollMode == SSMEnabled);
 
         int numStaticPixels = 0;
         QRegion r = static_cast<RenderCanvas *>(m_part->xmlDocImpl()->renderer())->staticRegion();
 
         // only do smooth scrolling if static region is relatively small
         if (!doSmoothScroll && d->staticWidget == KHTMLViewPrivate::SBPartial && r.rects().size() <= 10) {
             foreach (const QRect &rr, r.rects()) {
                 numStaticPixels += rr.width() * rr.height();
             }
             if ((numStaticPixels < sSmoothScrollMinStaticPixels) || (numStaticPixels * 8 < visibleWidth()*visibleHeight())) {
                 doSmoothScroll = true;
             }
         }
         if (doSmoothScroll) {
             setupSmoothScrolling(dx, dy);
             return;
         }
     }
 
     if (underMouse() && QToolTip::isVisible()) {
         QToolTip::hideText();
     }
 
     if (!d->scrollingSelf) {
         d->scrollBarMoved = true;
         d->contentsMoving = true;
         // ensure quick reset of contentsMoving flag
         scheduleRepaint(0, 0, 0, 0);
     }
 
     if (m_part->xmlDocImpl() && m_part->xmlDocImpl()->documentElement()) {
         m_part->xmlDocImpl()->documentElement()->dispatchHTMLEvent(EventImpl::SCROLL_EVENT, true, false);
     }
 
     if (QApplication::isRightToLeft()) {
         dx = -dx;
     }
 
     if (!d->smoothScrolling) {
         d->updateContentsXY();
     } else {
         d->contentsX -= dx;
         d->contentsY -= dy;
     }
     if (widget()->pos() != QPoint(0, 0)) {
         // qCDebug(KHTML_LOG) << "Static widget wasn't positioned at (0,0). This should NOT happen. Please report this event to developers.";
         widget()->move(0, 0);
     }
 
     QWidget *w = widget();
     QPoint off;
     if (m_kwp->isRedirected()) {
         // This is a redirected sub frame. Translate to root view context
         KHTMLView *v = m_kwp->rootViewPos(off);
         if (v) {
             w = v->widget();
         }
         off = viewport()->mapTo(this, off);
     }
 
     if (d->staticWidget) {
 
         // now remove from view the external widgets that must have completely
         // disappeared after dx/dy scroll delta is effective
         if (!d->visibleWidgets.isEmpty()) {
             checkExternalWidgetsPosition();
         }
 
         if (d->staticWidget == KHTMLViewPrivate::SBPartial
                 && m_part->xmlDocImpl() && m_part->xmlDocImpl()->renderer()) {
             // static objects might be selectively repainted, like stones in flowing water
             QRegion r = static_cast<RenderCanvas *>(m_part->xmlDocImpl()->renderer())->staticRegion();
             r.translate(-contentsX(), -contentsY());
             QVector<QRect> ar = r.rects();
 
             for (int i = 0; i < ar.size(); ++i) {
                 widget()->update(ar[i]);
             }
             r = QRegion(QRect(0, 0, visibleWidth(), visibleHeight())) - r;
             ar = r.rects();
             for (int i = 0; i < ar.size(); ++i) {
                 w->scroll(dx, dy, ar[i].translated(off));
             }
             d->scrollExternalWidgets(dx, dy);
         } else {
             // we can't avoid a full update
             widget()->update();
         }
         if (d->accessKeysActivated) {
             d->scrollAccessKeys(dx, dy);
         }
 
         return;
     }
 
     if (m_kwp->isRedirected()) {
         const QRect rect(off.x(), off.y(), visibleWidth() * d->zoomLevel / 100, visibleHeight() * d->zoomLevel / 100);
         w->scroll(dx, dy, rect);
         if (d->zoomLevel != 100) {
             w->update(rect); // without this update we are getting bad rendering when an iframe is zoomed in
         }
     }  else {
         widget()->scroll(dx, dy, widget()->rect() & viewport()->rect());
     }
 
     d->scrollExternalWidgets(dx, dy);
     if (d->accessKeysActivated) {
         d->scrollAccessKeys(dx, dy);
     }
 }
 
 void KHTMLView::setupSmoothScrolling(int dx, int dy)
 {
     // old or minimum speed
     int ddx = qMax(d->steps ? abs(d->dx) / d->steps : 0, 3);
     int ddy = qMax(d->steps ? abs(d->dy) / d->steps : 0, 3);
 
     // full scroll is remaining scroll plus new scroll
     d->dx = d->dx + dx;
     d->dy = d->dy + dy;
 
     if (d->dx == 0 && d->dy == 0) {
         d->stopScrolling();
         return;
     }
 
     d->steps = (sSmoothScrollTime - 1) / sSmoothScrollTick + 1;
 
     if (qMax(abs(d->dx), abs(d->dy)) / d->steps < qMax(ddx, ddy)) {
         // Don't move slower than average 4px/step in minimum one direction
         // This means fewer than normal steps
         d->steps = qMax((abs(d->dx) + ddx - 1) / ddx, (abs(d->dy) + ddy - 1) / ddy);
         if (d->steps < 1) {
             d->steps = 1;
         }
     }
 
     d->smoothScrollStopwatch.start();
     if (!d->smoothScrolling) {
         d->startScrolling();
         scrollTick();
     }
 }
 
 void KHTMLView::scrollTick()
 {
     if (d->dx == 0 && d->dy == 0) {
         d->stopScrolling();
         return;
     }
 
     if (d->steps < 1) {
         d->steps = 1;
     }
     int takesteps = d->smoothScrollStopwatch.restart() / sSmoothScrollTick;
     int scroll_x = 0;
     int scroll_y = 0;
     if (takesteps < 1) {
         takesteps = 1;
     }
     if (takesteps > d->steps) {
         takesteps = d->steps;
     }
     for (int i = 0; i < takesteps; i++) {
         int ddx = (d->dx / (d->steps + 1)) * 2;
         int ddy = (d->dy / (d->steps + 1)) * 2;
 
         // limit step to requested scrolling distance
         if (abs(ddx) > abs(d->dx)) {
             ddx = d->dx;
         }
         if (abs(ddy) > abs(d->dy)) {
             ddy = d->dy;
         }
 
         // update remaining scroll
         d->dx -= ddx;
         d->dy -= ddy;
         scroll_x += ddx;
         scroll_y += ddy;
         d->steps--;
     }
 
     d->shouldSmoothScroll = false;
     scrollContentsBy(scroll_x, scroll_y);
 
     if (takesteps < 2) {
         d->smoothScrollMissedDeadlines = 0;
     } else {
         if (d->smoothScrollMissedDeadlines != sWayTooMany &&
                 (!m_part->xmlDocImpl() || !m_part->xmlDocImpl()->parsing())) {
             d->smoothScrollMissedDeadlines++;
             if (d->smoothScrollMissedDeadlines >= sMaxMissedDeadlines) {
                 // we missed many deadlines in a row!
                 // time to signal we had enough..
                 d->smoothScrollMissedDeadlines = sWayTooMany;
             }
         }
     }
 }
 
 void KHTMLView::addChild(QWidget *child, int x, int y)
 {
     if (!child) {
         return;
     }
 
     if (child->parent() != widget()) {
         child->setParent(widget());
     }
 
     // ### handle pseudo-zooming of non-redirected widgets (e.g. just resize'em)
 
     child->move(x - contentsX(), y - contentsY());
 }
 
 void KHTMLView::timerEvent(QTimerEvent *e)
 {
 //    qCDebug(KHTML_LOG) << "timer event " << e->timerId();
     if (e->timerId() == d->scrollTimerId) {
         if (d->scrollSuspended) {
             return;
         }
         switch (d->scrollDirection) {
         case KHTMLViewPrivate::ScrollDown:
             if (contentsY() + visibleHeight() >= contentsHeight()) {
                 d->newScrollTimer(this, 0);
             } else {
                 verticalScrollBar()->setValue(verticalScrollBar()->value() + d->scrollBy);
             }
             break;
         case KHTMLViewPrivate::ScrollUp:
             if (contentsY() <= 0) {
                 d->newScrollTimer(this, 0);
             } else {
                 verticalScrollBar()->setValue(verticalScrollBar()->value() - d->scrollBy);
             }
             break;
         case KHTMLViewPrivate::ScrollRight:
             if (contentsX() + visibleWidth() >= contentsWidth()) {
                 d->newScrollTimer(this, 0);
             } else {
                 horizontalScrollBar()->setValue(horizontalScrollBar()->value() + d->scrollBy);
             }
             break;
         case KHTMLViewPrivate::ScrollLeft:
             if (contentsX() <= 0) {
                 d->newScrollTimer(this, 0);
             } else {
                 horizontalScrollBar()->setValue(horizontalScrollBar()->value() - d->scrollBy);
             }
             break;
         }
         return;
     } else if (e->timerId() == d->scrollingFromWheelTimerId) {
         killTimer(d->scrollingFromWheelTimerId);
         d->scrollingFromWheelTimerId = 0;
     } else if (e->timerId() == d->layoutTimerId) {
         if (d->firstLayoutPending && d->layoutAttemptCounter < 4
                 && (!m_part->xmlDocImpl() || !m_part->xmlDocImpl()->readyForLayout())) {
             d->layoutAttemptCounter++;
             killTimer(d->layoutTimerId);
             d->layoutTimerId = 0;
             scheduleRelayout();
             return;
         }
         layout();
         d->scheduledLayoutCounter++;
         if (d->firstLayoutPending) {
             d->firstLayoutPending = false;
             verticalScrollBar()->setEnabled(true);
             horizontalScrollBar()->setEnabled(true);
         }
     }
 
     d->contentsMoving = false;
     if (m_part->xmlDocImpl()) {
         DOM::DocumentImpl *document = m_part->xmlDocImpl();
         khtml::RenderCanvas *root = static_cast<khtml::RenderCanvas *>(document->renderer());
 
         if (root && root->needsLayout()) {
             if (d->repaintTimerId) {
                 killTimer(d->repaintTimerId);
             }
             d->repaintTimerId = 0;
             scheduleRelayout();
             return;
         }
     }
 
     if (d->repaintTimerId) {
         killTimer(d->repaintTimerId);
     }
     d->repaintTimerId = 0;
 
     QRect updateRegion;
     const QVector<QRect> rects = d->updateRegion.rects();
 
     d->updateRegion = QRegion();
 
     if (rects.size()) {
         updateRegion = rects[0];
     }
 
     for (int i = 1; i < rects.size(); ++i) {
         QRect newRegion = updateRegion.united(rects[i]);
         if (2 * newRegion.height() > 3 * updateRegion.height()) {
             repaintContents(updateRegion);
             updateRegion = rects[i];
         } else {
             updateRegion = newRegion;
         }
     }
 
     if (!updateRegion.isNull()) {
         repaintContents(updateRegion);
     }
 
     // As widgets can only be accurately positioned during painting, every layout might
     // dissociate a widget from its RenderWidget. E.g: if a RenderWidget was visible before layout, but the layout
     // pushed it out of the viewport, it will not be repainted, and consequently it's associated widget won't be repositioned.
     // Thus we need to check each supposedly 'visible' widget at the end of layout, and remove it in case it's no more in sight.
 
     if (d->dirtyLayout && !d->visibleWidgets.isEmpty()) {
         checkExternalWidgetsPosition();
     }
 
     d->dirtyLayout = false;
 
     emit repaintAccessKeys();
     if (d->emitCompletedAfterRepaint) {
         bool full = d->emitCompletedAfterRepaint == KHTMLViewPrivate::CSFull;
         d->emitCompletedAfterRepaint = KHTMLViewPrivate::CSNone;
         if (full) {
             emit m_part->completed();
         } else {
             emit m_part->completed(true);
         }
     }
 }
 
 void KHTMLView::checkExternalWidgetsPosition()
 {
     QWidget *w;
     QRect visibleRect(contentsX(), contentsY(), visibleWidth(), visibleHeight());
     QList<RenderWidget *> toRemove;
     QHashIterator<void *, QWidget *> it(d->visibleWidgets);
     while (it.hasNext()) {
         int xp = 0, yp = 0;
         it.next();
         RenderWidget *rw = static_cast<RenderWidget *>(it.key());
         if (!rw->absolutePosition(xp, yp) ||
                 !visibleRect.intersects(QRect(xp, yp, it.value()->width(), it.value()->height()))) {
             toRemove.append(rw);
         }
     }
     foreach (RenderWidget *r, toRemove)
         if ((w = d->visibleWidgets.take(r))) {
             w->move(0, -500000);
         }
 }
 
 void KHTMLView::scheduleRelayout(khtml::RenderObject * /*clippedObj*/)
 {
     if (!d->layoutSchedulingEnabled || d->layoutTimerId) {
         return;
     }
 
     int time = 0;
     if (d->firstLayoutPending) {
         // Any repaint happening while we have no content blanks the viewport ("white flash").
         // Hence the need to delay the first layout as much as we can.
         // Only if the document gets stuck for too long in incomplete state will we allow the blanking.
         time = d->layoutAttemptCounter ?
                sLayoutAttemptDelay + sLayoutAttemptIncrement * d->layoutAttemptCounter : sFirstLayoutDelay;
     } else if (m_part->xmlDocImpl() && m_part->xmlDocImpl()->parsing()) {
         // Delay between successive layouts in parsing mode.
         // Increment reflects the decaying importance of visual feedback over time.
         time = qMin(2000, sParsingLayoutsInterval + d->scheduledLayoutCounter * sParsingLayoutsIncrement);
     }
     d->layoutTimerId = startTimer(time);
 }
 
 void KHTMLView::unscheduleRelayout()
 {
     if (!d->layoutTimerId) {
         return;
     }
 
     killTimer(d->layoutTimerId);
     d->layoutTimerId = 0;
 }
 
 void KHTMLView::unscheduleRepaint()
 {
     if (!d->repaintTimerId) {
         return;
     }
 
     killTimer(d->repaintTimerId);
     d->repaintTimerId = 0;
 }
 
 void KHTMLView::scheduleRepaint(int x, int y, int w, int h, bool asap)
 {
     bool parsing = !m_part->xmlDocImpl() || m_part->xmlDocImpl()->parsing();
 
 //     qCDebug(KHTML_LOG) << "parsing " << parsing;
 //     qCDebug(KHTML_LOG) << "complete " << d->complete;
 
     int time = parsing && !d->firstLayoutPending ? 150 : (!asap ? (!d->complete ? 80 : 20) : 0);
 
 #ifdef DEBUG_FLICKER
     QPainter p;
     p.begin(viewport());
 
     int vx, vy;
     contentsToViewport(x, y, vx, vy);
     p.fillRect(vx, vy, w, h, Qt::red);
     p.end();
 #endif
 
     d->updateRegion = d->updateRegion.united(QRect(x, y, w, h));
 
     if (asap && !parsing) {
         unscheduleRepaint();
     }
 
     if (!d->repaintTimerId) {
         d->repaintTimerId = startTimer(time);
     }
 
 //     qCDebug(KHTML_LOG) << "starting timer " << time;
 }
 
 void KHTMLView::complete(bool pendingAction)
 {
 //     qCDebug(KHTML_LOG) << "KHTMLView::complete()";
 
     d->complete = true;
 
     // is there a relayout pending?
     if (d->layoutTimerId) {
 //         qCDebug(KHTML_LOG) << "requesting relayout now";
         // do it now
         killTimer(d->layoutTimerId);
         d->layoutTimerId = startTimer(0);
         d->emitCompletedAfterRepaint = pendingAction ?
                                        KHTMLViewPrivate::CSActionPending : KHTMLViewPrivate::CSFull;
     }
 
     // is there a repaint pending?
     if (d->repaintTimerId) {
 //         qCDebug(KHTML_LOG) << "requesting repaint now";
         // do it now
         killTimer(d->repaintTimerId);
         d->repaintTimerId = startTimer(0);
         d->emitCompletedAfterRepaint = pendingAction ?
                                        KHTMLViewPrivate::CSActionPending : KHTMLViewPrivate::CSFull;
     }
 
     if (!d->emitCompletedAfterRepaint) {
         if (!pendingAction) {
             emit m_part->completed();
         } else {
             emit m_part->completed(true);
         }
     }
 
 }
 
 void KHTMLView::updateScrollBars()
 {
     const QWidget *view = widget();
     if (!view) {
         return;
     }
 
     QSize p = viewport()->size();
     QSize m = maximumViewportSize();
 
     if (m.expandedTo(view->size()) == m) {
         p = m;    // no scroll bars needed
     }
 
     QSize v = view->size();
     horizontalScrollBar()->setRange(0, v.width() - p.width());
     horizontalScrollBar()->setPageStep(p.width());
     verticalScrollBar()->setRange(0, v.height() - p.height());
     verticalScrollBar()->setPageStep(p.height());
     if (!d->smoothScrolling) {
         d->updateContentsXY();
     }
 }
 
 void KHTMLView::slotMouseScrollTimer()
 {
     horizontalScrollBar()->setValue(horizontalScrollBar()->value() + d->m_mouseScroll_byX);
     verticalScrollBar()->setValue(verticalScrollBar()->value() + d->m_mouseScroll_byY);
 }
 
 static DOM::Position positionOfLineBoundary(const DOM::Position &pos, bool toEnd)
 {
     Selection sel = pos;
     sel.expandUsingGranularity(Selection::LINE);
     return toEnd ? sel.end() : sel.start();
 }
 
 inline static DOM::Position positionOfLineBegin(const DOM::Position &pos)
 {
     return positionOfLineBoundary(pos, false);
 }
 
 inline static DOM::Position positionOfLineEnd(const DOM::Position &pos)
 {
     return positionOfLineBoundary(pos, true);
 }
 
 bool KHTMLView::caretKeyPressEvent(QKeyEvent *_ke)
 {
     EditorContext *ec = &m_part->d->editor_context;
     Selection &caret = ec->m_selection;
     Position old_pos = caret.caretPos();
     Position pos = old_pos;
     bool recalcXPos = true;
     bool handled = true;
 
     bool ctrl = _ke->modifiers() & Qt::ControlModifier;
     bool shift = _ke->modifiers() & Qt::ShiftModifier;
 
     switch (_ke->key()) {
 
     // -- Navigational keys
     case Qt::Key_Down:
         pos = old_pos.nextLinePosition(caret.xPosForVerticalArrowNavigation(Selection::EXTENT));
         recalcXPos = false;
         break;
 
     case Qt::Key_Up:
         pos = old_pos.previousLinePosition(caret.xPosForVerticalArrowNavigation(Selection::EXTENT));
         recalcXPos = false;
         break;
 
     case Qt::Key_Left:
         pos = ctrl ? old_pos.previousWordPosition() : old_pos.previousCharacterPosition();
         break;
 
     case Qt::Key_Right:
         pos = ctrl ? old_pos.nextWordPosition() : old_pos.nextCharacterPosition();
         break;
 
     case Qt::Key_PageDown:
 //       moveCaretNextPage(); ###
         break;
 
     case Qt::Key_PageUp:
 //       moveCaretPrevPage(); ###
         break;
 
     case Qt::Key_Home:
         if (ctrl)
             /*moveCaretToDocumentBoundary(false)*/; // ###
         else {
             pos = positionOfLineBegin(old_pos);
         }
         break;
 
     case Qt::Key_End:
         if (ctrl)
             /*moveCaretToDocumentBoundary(true)*/; // ###
         else {
             pos = positionOfLineEnd(old_pos);
         }
         break;
 
     default:
         handled = false;
 
     }/*end switch*/
 
     if (pos != old_pos) {
         m_part->clearCaretRectIfNeeded();
 
         caret.moveTo(shift ? caret.nonCaretPos() : pos, pos);
         int old_x = caret.xPosForVerticalArrowNavigation(Selection::CARETPOS);
 
         m_part->selectionLayoutChanged();
 
         // restore old x-position to prevent recalculation
         if (!recalcXPos) {
             m_part->d->editor_context.m_xPosForVerticalArrowNavigation = old_x;
         }
 
         m_part->emitCaretPositionChanged(pos);
         // ### check when to emit it
         m_part->notifySelectionChanged();
 
     }
 
     if (handled) {
         _ke->accept();
     }
     return handled;
 }
 
 #undef DEBUG_CARETMODE