khtml/khtmlview.h

   1 /* This file is part of the KDE project
   2
   3    Copyright (C) 1997 Martin Jones (mjones@kde.org)
   4              (C) 1998 Waldo Bastian (bastian@kde.org)
   5              (C) 1998, 1999 Torben Weis (weis@kde.org)
   6              (C) 1999 Lars Knoll (knoll@kde.org)
   7              (C) 1999 Antti Koivisto (koivisto@kde.org)
   8              (C) 2006 Germain Garand (germain@ebooksfrance.org)
   9
  10    This library is free software; you can redistribute it and/or
  11    modify it under the terms of the GNU Library General Public
  12    License as published by the Free Software Foundation; either
  13    version 2 of the License, or (at your option) any later version.
  14
  15    This library is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18    Library General Public License for more details.
  19
  20    You should have received a copy of the GNU Library General Public License
  21    along with this library; see the file COPYING.LIB.  If not, write to
  22    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  23    Boston, MA 02110-1301, USA.
  24 */
  25
  26 #ifndef KHTMLVIEW_H
  27 #define KHTMLVIEW_H
  28
  29 #include <khtml_export.h>
  30
  31 // qt includes and classes
  32 #include <QtGui/QScrollArea>
  33
  34 class QPainter;
  35 class QRect;
  36 template< typename T > class QVector;
  37 template <class T> class QStack;
  38
  39 namespace DOM {
  40     class HTMLDocumentImpl;
  41     class DocumentImpl;
  42     class ElementImpl;
  43     class HTMLTitleElementImpl;
  44     class HTMLGenericFormElementImpl;
  45     class HTMLFormElementImpl;
  46     class HTMLAnchorElementImpl;
  47     class HTMLInputElementImpl;
  48     class NodeImpl;
  49     class CSSProperty;
  50 }
  51
  52 namespace KJS {
  53     class WindowFunc;
  54     class ExternalFunc;
  55 }
  56
  57 namespace khtml {
  58     class RenderObject;
  59     class RenderCanvas;
  60         class RenderLineEdit;
  61     class RenderPartObject;
  62     class RenderWidget;
  63     class RenderLayer;
  64     class RenderBox;
  65     class CSSStyleSelector;
  66     class LineEditWidget;
  67     class CaretBox;
  68     class KHTMLWidgetPrivate;
  69     class KHTMLWidget
  70     {
  71     public:
  72         KHTMLWidget();
  73         ~KHTMLWidget();
  74         KHTMLWidgetPrivate* m_kwp;
  75     };
  76     void applyRule(DOM::CSSProperty *prop);
  77 }
  78
  79 class KHTMLPart;
  80 class KHTMLViewPrivate;
  81
  82 namespace khtml {
  83
  84 }
  85
  86 /**
  87  * Renders and displays HTML in a QScrollArea.
  88  *
  89  * Suitable for use as an application's main view.
  90  **/
  91 class KHTML_EXPORT KHTMLView : public QScrollArea, public khtml::KHTMLWidget
  92 {
  93     Q_OBJECT
  94
  95     friend class DOM::HTMLDocumentImpl;
  96     friend class DOM::HTMLTitleElementImpl;
  97     friend class DOM::HTMLGenericFormElementImpl;
  98     friend class DOM::HTMLFormElementImpl;
  99     friend class DOM::HTMLAnchorElementImpl;
 100     friend class DOM::HTMLInputElementImpl;
 101     friend class DOM::NodeImpl;
 102     friend class DOM::ElementImpl;
 103     friend class DOM::DocumentImpl;
 104     friend class KHTMLPart;
 105     friend class KHTMLFind;
 106     friend class khtml::RenderCanvas;
 107     friend class khtml::RenderObject;
 108     friend class khtml::RenderLineEdit;
 109     friend class khtml::RenderPartObject;
 110     friend class khtml::RenderWidget;
 111     friend class khtml::KHTMLWidgetPrivate;
 112     friend class khtml::RenderLayer;
 113     friend class khtml::RenderBox;
 114     friend class khtml::CSSStyleSelector;
 115     friend class khtml::LineEditWidget;
 116     friend class KJS::WindowFunc;
 117     friend class KJS::ExternalFunc;
 118     friend void khtml::applyRule(DOM::CSSProperty *prop);
 119
 120
 121 public:
 122     /**
 123      * Constructs a KHTMLView.
 124      */
 125     KHTMLView( KHTMLPart *part, QWidget *parent );
 126     virtual ~KHTMLView();
 127
 128     /**
 129      * Returns a pointer to the KHTMLPart that is
 130      * rendering the page.
 131      **/
 132     KHTMLPart *part() const { return m_part; }
 133
 134     int frameWidth() const { return _width; }
 135
 136     /**
 137      * Sets a margin in x direction.
 138      */
 139     void setMarginWidth(int x);
 140
 141     /**
 142      * Returns the margin width.
 143      *
 144      * A return value of -1 means the default value will be used.
 145      */
 146     int marginWidth() const { return _marginWidth; }
 147
 148     /*
 149      * Sets a margin in y direction.
 150      */
 151     void setMarginHeight(int y);
 152
 153     /**
 154      * Returns the margin height.
 155      *
 156      * A return value of -1 means the default value will be used.
 157      */
 158     int marginHeight() { return _marginHeight; }
 159
 160     /**
 161      * Sets vertical scrollbar mode.
 162      *
 163      * WARNING: do not call this method on a base class pointer unless you
 164      *          specifically want QAbstractScrollArea's variant (not recommended).
 165      *          QAbstractScrollArea::setVerticalScrollBarPolicy is *not* virtual.
 166      */
 167     virtual void setVerticalScrollBarPolicy( Qt::ScrollBarPolicy policy );
 168
 169     /**
 170      * Sets horizontal scrollbar mode.
 171      *
 172      * WARNING: do not call this method on a base class pointer unless you
 173      *          specifically want QAbstractScrollArea's variant (not recommended).
 174      *          QAbstractScrollArea::setHorizontalScrollBarPolicy is *not* virtual.
 175      */
 176     virtual void setHorizontalScrollBarPolicy( Qt::ScrollBarPolicy policy );
 177
 178     /**
 179      * Prints the HTML document.
 180      * @param quick if true, fully automated printing, without print dialog
 181      */
 182     void print( bool quick = false );
 183
 184     /**
 185      * Display all accesskeys in small tooltips
 186      */
 187     void displayAccessKeys();
 188
 189     /**
 190      * Returns the contents area's width
 191      */
 192     int contentsWidth() const;
 193
 194     /**
 195      * Returns the contents area's height
 196      */
 197     int contentsHeight() const;
 198
 199     /**
 200      * Returns the x coordinate of the contents area point
 201      * that is currently located at the top left in the viewport
 202      */
 203     int contentsX() const;
 204
 205     /**
 206      * Returns the y coordinate of the contents area point
 207      * that is currently located at the top left in the viewport
 208      */
 209     int contentsY() const;
 210
 211     /**
 212      * Returns the width of the viewport
 213      */
 214     int visibleWidth() const;
 215
 216     /**
 217      * Returns the height of the viewport
 218      */
 219     int visibleHeight() const;
 220
 221     /**
 222      *  Place the contents area point x/y
 223      *  at the top left of the viewport
 224      */
 225     void setContentsPos(int x, int y);
 226
 227     /**
 228      * Returns a point translated to viewport coordinates
 229      * @param p the contents area point to translate
 230      *
 231      */
 232     QPoint contentsToViewport(const QPoint& p) const;
 233
 234     /**
 235      * Returns a point translated to contents area coordinates
 236      * @param p the viewport point to translate
 237      *
 238      */
 239     QPoint viewportToContents(const QPoint& p) const;
 240
 241     /**
 242      * Returns a point translated to contents area coordinates
 243      * @param x x coordinate of viewport point to translate
 244      * @param y y coordinate of viewport point to translate
 245      * @param cx resulting x coordinate
 246      * @param cy resulting y coordinate
 247      *
 248      */
 249     void viewportToContents(int x, int y, int& cx, int& cy) const;
 250
 251     /**
 252      * Returns a point translated to viewport coordinates
 253      * @param x x coordinate of contents area point to translate
 254      * @param y y coordinate of contents area point to translate
 255      * @param cx resulting x coordinate
 256      * @param cy resulting y coordinate
 257      *
 258      */
 259     void contentsToViewport(int x, int y, int& cx, int& cy) const;
 260
 261     /**
 262      * Scrolls the content area by a given amount
 263      * @param x x offset
 264      * @param y y offset
 265      */
 266     void scrollBy(int x, int y);
 267
 268     /**
 269      * Requests an update of the content area
 270      * @param r the content area rectangle to update
 271      */
 272     void updateContents( const QRect& r );
 273     void updateContents(int x, int y, int w, int h);
 274
 275     void addChild(QWidget *child, int dx, int dy);
 276
 277     /**
 278      * Requests an immediate repaint of the content area
 279      * @param r the content area rectangle to repaint
 280      */
 281     void repaintContents( const QRect& r );
 282     void repaintContents(int x, int y, int w, int h);
 283
 284     /**
 285      * Apply a zoom level to the content area
 286      * @param percent a zoom level expressed as a percentage
 287      */
 288     void setZoomLevel( int percent );
 289
 290     /**
 291      * Retrieve the current zoom level
 292      *
 293      */
 294     int zoomLevel() const;
 295
 296     /**
 297      * Smooth Scrolling Mode enumeration
 298      * @li SSMDisabled smooth scrolling is disabled
 299      * @li SSMWhenEfficient only use smooth scrolling on pages that do not require a full repaint of the content area when scrolling
 300      * @li SSMAlways smooth scrolling is performed unconditionally
 301      */
 302     enum SmoothScrollingMode { SSMDisabled = 0, SSMWhenEfficient, SSMEnabled };
 303
 304     /**
 305      * Set the smooth scrolling mode.
 306      *
 307      * Smooth scrolling mode is normally controlled by the configuration file's SmoothScrolling key.
 308      * Using this setter will override the configuration file's settings.
 309      *
 310      * @since 4.1
 311      */
 312     void setSmoothScrollingMode( SmoothScrollingMode m );
 313
 314     /**
 315      * Retrieve the current smooth scrolling mode
 316      *
 317      * @since 4.1
 318      */
 319     SmoothScrollingMode smoothScrollingMode() const;
 320
 321 public Q_SLOTS:
 322     /**
 323      * Resize the contents area
 324      * @param w the new width
 325      * @param h the new height
 326      */
 327     virtual void resizeContents(int w, int h);
 328
 329     /**
 330      * ensure the display is up to date
 331      */
 332     void layout();
 333
 334
 335 Q_SIGNALS:
 336     /**
 337      * This signal is used for internal layouting. Don't use it to check if rendering finished.
 338      * Use @ref KHTMLPart completed() signal instead.
 339      */
 340     void finishedLayout();
 341     void cleared();
 342     void zoomView( int );
 343     void hideAccessKeys();
 344     void repaintAccessKeys();
 345     void findAheadActive( bool );
 346
 347 protected:
 348     void clear();
 349
 350     virtual bool event ( QEvent * event );
 351     virtual void paintEvent( QPaintEvent * );
 352     virtual void resizeEvent ( QResizeEvent * event );
 353     virtual void showEvent ( QShowEvent * );
 354     virtual void hideEvent ( QHideEvent *);
 355     virtual bool focusNextPrevChild( bool next );
 356     virtual void mousePressEvent( QMouseEvent * );
 357     virtual void focusInEvent( QFocusEvent * );
 358     virtual void focusOutEvent( QFocusEvent * );
 359     virtual void mouseDoubleClickEvent( QMouseEvent * );
 360     virtual void mouseMoveEvent(QMouseEvent *);
 361     virtual void mouseReleaseEvent(QMouseEvent *);
 362 #ifndef QT_NO_WHEELEVENT
 363     virtual void wheelEvent(QWheelEvent*);
 364 #endif
 365     virtual void dragEnterEvent( QDragEnterEvent* );
 366     virtual void dropEvent( QDropEvent* );
 367     virtual void closeEvent ( QCloseEvent * );
 368     virtual bool widgetEvent( QEvent * );
 369     virtual bool viewportEvent( QEvent * e );
 370     virtual bool eventFilter(QObject *, QEvent *);
 371     virtual void scrollContentsBy( int dx, int dy );
 372
 373     void keyPressEvent( QKeyEvent *_ke );
 374     void keyReleaseEvent ( QKeyEvent *_ke );
 375     void doAutoScroll();
 376     void timerEvent ( QTimerEvent * );
 377
 378     void setSmoothScrollingModeDefault( SmoothScrollingMode m );
 379
 380 protected Q_SLOTS:
 381     void slotPaletteChanged();
 382
 383 private Q_SLOTS:
 384     void tripleClickTimeout();
 385     void findTimeout();
 386     void accessKeysTimeout();
 387     void scrollTick();
 388
 389     /**
 390     * @internal
 391     * used for autoscrolling with MMB
 392     */
 393     void slotMouseScrollTimer();
 394
 395 private:
 396     void resizeContentsToViewport();
 397
 398     void scheduleRelayout(khtml::RenderObject* clippedObj=0);
 399     void unscheduleRelayout();
 400
 401     void scheduleRepaint(int x, int y, int w, int h, bool asap=false);
 402     void unscheduleRepaint();
 403
 404     bool needsFullRepaint() const;
 405
 406     void closeChildDialogs();
 407     bool dialogsAllowed();
 408
 409     void setMouseEventsTarget( QWidget* w );
 410     QWidget* mouseEventsTarget() const;
 411
 412     QStack<QRegion>* clipHolder() const;
 413     void setClipHolder( QStack<QRegion>* ch );
 414
 415     void setPart(KHTMLPart *part);
 416
 417     /**
 418      * Paints the HTML document to a QPainter.
 419      * The document will be scaled to match the width of
 420      * rc and clipped to fit in the height.
 421      * yOff determines the vertical offset in the document to start with.
 422      * more, if nonzero will be set to true if the documents extends
 423      * beyond the rc or false if everything below yOff was painted.
 424      **/
 425     void paint(QPainter *p, const QRect &rc, int yOff = 0, bool *more = 0);
 426
 427     void render(QPainter *p, const QRect& r, const QPoint& off);
 428
 429     /**
 430      * Get/set the CSS Media Type.
 431      *
 432      * Media type is set to "screen" for on-screen rendering and "print"
 433      * during printing. Other media types lack the proper support in the
 434      * renderer and are not activated. The DOM tree and the parser itself,
 435      * however, properly handle other media types. To make them actually work
 436      * you only need to enable the media type in the view and if necessary
 437      * add the media type dependent changes to the renderer.
 438      */
 439     void setMediaType( const QString &medium );
 440     QString mediaType() const;
 441
 442     bool pagedMode() const;
 443
 444     bool scrollTo(const QRect &);
 445
 446     bool focusNextPrevNode(bool next);
 447     bool handleAccessKey(const QKeyEvent* ev);
 448     bool focusNodeWithAccessKey(QChar c, KHTMLView* caller = NULL);
 449     QMap< DOM::ElementImpl*, QChar > buildFallbackAccessKeys() const;
 450     void displayAccessKeys( KHTMLView* caller, KHTMLView* origview, QVector< QChar >& taken, bool use_fallbacks );
 451     bool isScrollingFromMouseWheel() const;
 452     void setHasStaticBackground(bool partial=false);
 453     void setHasNormalBackground();
 454     void addStaticObject(bool fixed);
 455     void removeStaticObject(bool fixed);
 456     void applyTransforms( int& x, int& y, int& w, int& h) const;
 457     void revertTransforms( int& x, int& y, int& w, int& h) const;
 458     void revertTransforms( int& x, int& y ) const;
 459     void checkExternalWidgetsPosition();
 460
 461     void setIgnoreWheelEvents(bool e);
 462
 463     void init();
 464
 465     DOM::NodeImpl *nodeUnderMouse() const;
 466     DOM::NodeImpl *nonSharedNodeUnderMouse() const;
 467
 468     void restoreScrollBar();
 469
 470     QStringList formCompletionItems(const QString &name) const;
 471     void clearCompletionHistory(const QString& name);
 472     void addFormCompletionItem(const QString &name, const QString &value);
 473
 474     void addNonPasswordStorableSite( const QString& host );
 475     bool nonPasswordStorableSite( const QString& host ) const;
 476
 477     bool dispatchMouseEvent(int eventId, DOM::NodeImpl *targetNode,
 478                             DOM::NodeImpl *targetNodeNonShared, bool cancelable,
 479                             int detail,QMouseEvent *_mouse, bool setUnder,
 480                             int mouseEventType, int orientation=0);
 481     bool dispatchKeyEvent( QKeyEvent *_ke );
 482     bool dispatchKeyEventHelper( QKeyEvent *_ke, bool generate_keypress );
 483
 484     void complete( bool pendingAction );
 485
 486     void updateScrollBars();
 487     void setupSmoothScrolling(int dx, int dy);
 488
 489 #ifndef KHTML_NO_TYPE_AHEAD_FIND
 490     void findAhead(bool increase);
 491     void updateFindAheadTimeout();
 492     void startFindAhead( bool linksOnly );
 493 #endif // KHTML_NO_TYPE_AHEAD_FIND
 494
 495     /**
 496      * Returns the current caret policy when the view is not focused.
 497      * @return a KHTMLPart::CaretDisplay value
 498      */
 499     int caretDisplayPolicyNonFocused() const;
 500
 501     /**
 502      * Sets the caret display policy when the view is not focused.
 503      * @param policy new display policy as
 504      *          defined by KHTMLPart::CaretDisplayPolicy
 505      */
 506     void setCaretDisplayPolicyNonFocused(int policy);
 507
 508     // -- caret event handler
 509
 510     /**
 511      * Evaluates key presses for caret navigation on editable nodes.
 512      * @return true if event has been handled
 513      */
 514     bool caretKeyPressEvent(QKeyEvent *);
 515
 516     // ------------------------------------- member variables ------------------------------------
 517  private:
 518     friend class KHTMLViewPrivate;
 519     enum LinkCursor { LINK_NORMAL, LINK_MAILTO, LINK_NEWWINDOW };
 520
 521     void setWidgetVisible(::khtml::RenderWidget*, bool visible);
 522
 523
 524     int _width;
 525     int _height;
 526
 527     int _marginWidth;
 528     int _marginHeight;
 529
 530     KHTMLPart *m_part;
 531     KHTMLViewPrivate* const d;
 532
 533     QString m_medium;   // media type
 534 };
 535
 536 #endif
 537