summaryrefslogtreecommitdiffstats
path: root/khtml/khtmlview.h
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commitce4a32fe52ef09d8f5ff1dd22c001110902b60a2 (patch)
tree5ac38a06f3dde268dc7927dc155896926aaf7012 /khtml/khtmlview.h
downloadtdelibs-ce4a32fe52ef09d8f5ff1dd22c001110902b60a2.tar.gz
tdelibs-ce4a32fe52ef09d8f5ff1dd22c001110902b60a2.zip
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdelibs@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'khtml/khtmlview.h')
-rw-r--r--khtml/khtmlview.h604
1 files changed, 604 insertions, 0 deletions
diff --git a/khtml/khtmlview.h b/khtml/khtmlview.h
new file mode 100644
index 000000000..c44dba28a
--- /dev/null
+++ b/khtml/khtmlview.h
@@ -0,0 +1,604 @@
+/* This file is part of the KDE project
+
+ Copyright (C) 1997 Martin Jones (mjones@kde.org)
+ (C) 1998 Waldo Bastian (bastian@kde.org)
+ (C) 1998, 1999 Torben Weis (weis@kde.org)
+ (C) 1999 Lars Knoll (knoll@kde.org)
+ (C) 1999 Antti Koivisto (koivisto@kde.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.
+*/
+
+#ifndef KHTMLVIEW_H
+#define KHTMLVIEW_H
+
+// qt includes and classes
+#include <qscrollview.h>
+
+#include <kdelibs_export.h>
+
+class QPainter;
+class QRect;
+template< typename T > class QValueVector;
+
+namespace DOM {
+ class HTMLDocumentImpl;
+ class DocumentImpl;
+ class ElementImpl;
+ class HTMLElementImpl;
+ class HTMLTitleElementImpl;
+ class HTMLGenericFormElementImpl;
+ class HTMLFormElementImpl;
+ class HTMLAnchorElementImpl;
+ class HTMLInputElementImpl;
+ class Range;
+ class NodeImpl;
+ class CSSProperty;
+}
+
+namespace KJS {
+ class WindowFunc;
+ class ExternalFunc;
+}
+
+namespace khtml {
+ class RenderObject;
+ class RenderCanvas;
+ class RenderStyle;
+ class RenderLineEdit;
+ class RenderPartObject;
+ class RenderWidget;
+ class CSSStyleSelector;
+ class LineEditWidget;
+ class CaretBox;
+ void applyRule(DOM::CSSProperty *prop);
+}
+
+class KHTMLPart;
+class KHTMLViewPrivate;
+
+/**
+ * Renders and displays HTML in a QScrollView.
+ *
+ * Suitable for use as an application's main view.
+ **/
+class KHTML_EXPORT KHTMLView : public QScrollView
+{
+ Q_OBJECT
+
+ friend class DOM::HTMLDocumentImpl;
+ friend class DOM::HTMLTitleElementImpl;
+ friend class DOM::HTMLGenericFormElementImpl;
+ friend class DOM::HTMLFormElementImpl;
+ friend class DOM::HTMLAnchorElementImpl;
+ friend class DOM::HTMLInputElementImpl;
+ friend class DOM::DocumentImpl;
+ friend class KHTMLPart;
+ friend class khtml::RenderCanvas;
+ friend class khtml::RenderObject;
+ friend class khtml::RenderLineEdit;
+ friend class khtml::RenderPartObject;
+ friend class khtml::RenderWidget;
+ friend class khtml::CSSStyleSelector;
+ friend class khtml::LineEditWidget;
+ friend class KJS::WindowFunc;
+ friend class KJS::ExternalFunc;
+ friend void khtml::applyRule(DOM::CSSProperty *prop);
+
+
+public:
+ /**
+ * Constructs a KHTMLView.
+ */
+ KHTMLView( KHTMLPart *part, QWidget *parent, const char *name=0 );
+ virtual ~KHTMLView();
+
+ /**
+ * Returns a pointer to the KHTMLPart that is
+ * rendering the page.
+ **/
+ KHTMLPart *part() const { return m_part; }
+
+ int frameWidth() const { return _width; }
+
+ /**
+ * Sets a margin in x direction.
+ */
+ void setMarginWidth(int x);
+
+ /**
+ * Returns the margin width.
+ *
+ * A return value of -1 means the default value will be used.
+ */
+ int marginWidth() const { return _marginWidth; }
+
+ /*
+ * Sets a margin in y direction.
+ */
+ void setMarginHeight(int y);
+
+ /**
+ * Returns the margin height.
+ *
+ * A return value of -1 means the default value will be used.
+ */
+ int marginHeight() { return _marginHeight; }
+
+ /**
+ * Sets verticals scrollbar mode. Reimplemented for internal reasons.
+ */
+ virtual void setVScrollBarMode ( ScrollBarMode mode );
+
+ /**
+ * Sets horizontal scrollbar mode. Reimplemented for internal reasons.
+ */
+ virtual void setHScrollBarMode ( ScrollBarMode mode );
+
+ /**
+ * Prints the HTML document.
+ */
+ void print();
+
+ /**
+ * Prints the HTML document.
+ * @param quick if true, fully automated printing, without print dialog
+ */
+ void print( bool quick ); // KDE 4.0: merge with above
+
+ /**
+ * ensure the display is up to date
+ */
+ void layout(); // KDE 4.0: make private
+ /**
+ * Display all accesskeys in small tooltips
+ */
+ void displayAccessKeys();
+
+
+
+signals:
+ /**
+ * This signal is used for internal layouting. Don't use it to check if rendering finished.
+ * Use @ref KHTMLPart completed() signal instead.
+ */
+ void finishedLayout();
+ void cleared();
+ void zoomView( int );
+ void hideAccessKeys();
+ void repaintAccessKeys();
+ void findAheadActive( bool );
+
+protected:
+ void clear();
+
+ virtual void resizeEvent ( QResizeEvent * event );
+ virtual void showEvent ( QShowEvent * );
+ virtual void hideEvent ( QHideEvent *);
+ virtual bool focusNextPrevChild( bool next );
+ virtual void drawContents ( QPainter * p, int clipx, int clipy, int clipw, int cliph );
+ virtual void drawContents( QPainter* );
+ virtual void viewportMousePressEvent( QMouseEvent * );
+ virtual void focusInEvent( QFocusEvent * );
+ virtual void focusOutEvent( QFocusEvent * );
+ virtual void viewportMouseDoubleClickEvent( QMouseEvent * );
+ virtual void viewportMouseMoveEvent(QMouseEvent *);
+ virtual void viewportMouseReleaseEvent(QMouseEvent *);
+ virtual void viewportResizeEvent(QResizeEvent*);
+#ifndef QT_NO_WHEELEVENT
+ virtual void viewportWheelEvent(QWheelEvent*);
+#endif
+ virtual void dragEnterEvent( QDragEnterEvent* );
+ virtual void dropEvent( QDropEvent* );
+ virtual void closeEvent ( QCloseEvent * );
+ virtual bool eventFilter(QObject *, QEvent *);
+
+ void keyPressEvent( QKeyEvent *_ke );
+ void keyReleaseEvent ( QKeyEvent *_ke );
+ void contentsContextMenuEvent ( QContextMenuEvent *_ce );
+ void doAutoScroll();
+ void timerEvent ( QTimerEvent * );
+protected slots:
+ void slotPaletteChanged();
+ void slotScrollBarMoved();
+
+private slots:
+ void tripleClickTimeout();
+ void findTimeout();
+ void accessKeysTimeout();
+
+ /**
+ * @internal
+ * @since 3.4
+ * used for autoscrolling with MMB
+ */
+ void slotMouseScrollTimer();
+
+private:
+
+ void scheduleRelayout(khtml::RenderObject* clippedObj=0);
+ void unscheduleRelayout();
+
+ void scheduleRepaint(int x, int y, int w, int h, bool asap=false);
+ void unscheduleRepaint();
+
+ bool needsFullRepaint() const;
+
+ void closeChildDialogs();
+ bool dialogsAllowed();
+
+ /**
+ * Paints the HTML document to a QPainter.
+ * The document will be scaled to match the width of
+ * rc and clipped to fit in the height.
+ * yOff determines the vertical offset in the document to start with.
+ * more, if nonzero will be set to true if the documents extends
+ * beyond the rc or false if everything below yOff was painted.
+ **/
+ void paint(QPainter *p, const QRect &rc, int yOff = 0, bool *more = 0);
+
+#if 0
+ /**
+ * Paints the HTML document to a QPainter.
+ * The document will be scaled to match the width.
+ **/
+ void paint(QPainter *p, int width);
+#endif
+
+ /**
+ * Get/set the CSS Media Type.
+ *
+ * Media type is set to "screen" for on-screen rendering and "print"
+ * during printing. Other media types lack the proper support in the
+ * renderer and are not activated. The DOM tree and the parser itself,
+ * however, properly handle other media types. To make them actually work
+ * you only need to enable the media type in the view and if necessary
+ * add the media type dependent changes to the renderer.
+ */
+ void setMediaType( const QString &medium );
+ QString mediaType() const;
+
+ bool pagedMode() const;
+
+ bool scrollTo(const QRect &);
+
+ bool focusNextPrevNode(bool next);
+ bool handleAccessKey(const QKeyEvent* ev);
+ bool focusNodeWithAccessKey(QChar c, KHTMLView* caller = NULL);
+ QMap< DOM::ElementImpl*, QChar > buildFallbackAccessKeys() const;
+ void displayAccessKeys( KHTMLView* caller, KHTMLView* origview, QValueVector< QChar >& taken, bool use_fallbacks );
+
+ void useSlowRepaints();
+
+ void setIgnoreWheelEvents(bool e);
+
+ void init();
+
+ DOM::NodeImpl *nodeUnderMouse() const;
+ DOM::NodeImpl *nonSharedNodeUnderMouse() const;
+
+ void restoreScrollBar();
+
+ QStringList formCompletionItems(const QString &name) const;
+ void clearCompletionHistory(const QString& name);
+ void addFormCompletionItem(const QString &name, const QString &value);
+
+ void addNonPasswordStorableSite( const QString& host );
+ bool nonPasswordStorableSite( const QString& host ) const;
+
+ bool dispatchMouseEvent(int eventId, DOM::NodeImpl *targetNode,
+ DOM::NodeImpl *targetNodeNonShared, bool cancelable,
+ int detail,QMouseEvent *_mouse, bool setUnder,
+ int mouseEventType);
+ bool dispatchKeyEvent( QKeyEvent *_ke );
+ bool dispatchKeyEventHelper( QKeyEvent *_ke, bool generate_keypress );
+
+ void complete( bool pendingAction );
+
+#ifndef KHTML_NO_TYPE_AHEAD_FIND
+ void findAhead(bool increase);
+ void updateFindAheadTimeout();
+ void startFindAhead( bool linksOnly );
+#endif // KHTML_NO_TYPE_AHEAD_FIND
+
+#ifndef KHTML_NO_CARET
+ // -- caret-related member functions (for caretMode as well as designMode)
+
+ /** initializes the caret if it hasn't been initialized yet.
+ *
+ * This method determines a suitable starting position, initializes
+ * the internal structures, and calculates the caret's coordinates ready
+ * for display.
+ *
+ * To "deinitialize" the caret, call caretOff
+ * @param keepSelection @p true to keep any active selection. It may have
+ * been extended if the caret position is changed.
+ */
+ void initCaret(bool keepSelection = false);
+ /** returns whether the text under the caret will be overridden.
+ */
+ bool caretOverrides() const;
+ /** ensures that the given element is properly focused.
+ *
+ * If not in caret mode or design mode, keyboard events are only regarded for
+ * focused nodes. Therefore, the function ensured that the focus will be
+ * properly set on unfocused nodes (or on a suitable ancestor).
+ * @param node node to focus
+ */
+ void ensureNodeHasFocus(DOM::NodeImpl *node);
+ /** inquires the current caret position and stores it in the caret view
+ * context. Also resets the blink frequency timer. It will not display
+ * the caret on the canvas.
+ * @param hintBox caret box whose coordinates will be used if the
+ * caret position could not be determined otherwise.
+ */
+ void recalcAndStoreCaretPos(khtml::CaretBox *hintBox = 0);
+ /** displays the caret and reinitializes the blink frequency timer.
+ *
+ * The caret will only be displayed on screen if the view has focus, or
+ * the caret display policy allows it. The same holds true for the blink
+ * frequency timer.
+ */
+ void caretOn();
+ /** hides the caret and kills the blink frequency timer.
+ *
+ * These operations are executed unconditionally, regardless of the
+ * focus, and the caret display policy.
+ */
+ void caretOff();
+ /** makes the caret visible, but does not influence the frequency timer.
+ * That means it probably won't get visible immediately.
+ *
+ * These operations are executed unconditionally, regardless of the
+ * focus, and the caret display policy.
+ * @param forceRepaint @p true to force an immediate repaint, otherwise
+ * do a scheduled repaint
+ */
+ void showCaret(bool forceRepaint = false);
+ /** makes the caret invisible, but does not influence the frequency timer.
+ * The caret is immediately hidden.
+ *
+ * These operations are executed unconditionally, regardless of the
+ * focus, and the caret display policy.
+ */
+ void hideCaret();
+ /** shifts the viewport to ensure that the caret is visible.
+ *
+ * Note: this will also work if the caret is hidden.
+ */
+ void ensureCaretVisible();
+
+ /** folds the selection to the current caret position.
+ *
+ * Whatever selection has existed before will be removed by the invocation
+ * of this method. Updates are only done if an actual selection has
+ * been folded. After the call of this method, no selection will exist
+ * any more.
+ *
+ * No validity checking is done on the parameters. Note that the parameters
+ * refer to the old selection, the current caret may be way off.
+ * @param startNode starting node of selection
+ * @param startOffset offset within the start node.
+ * @param endNode ending node of selection
+ * @param endOffset offset within the end node.
+ * @return @p true if there had been a selection, and it was folded.
+ */
+ bool foldSelectionToCaret(DOM::NodeImpl *startNode, long startOffset,
+ DOM::NodeImpl *endNode, long endOffset);
+
+ /** places the caret on the current position.
+ *
+ * The caret is switched off, the position recalculated with respect to
+ * the new position. The caret will only be redisplayed if it is on an
+ * editable node, in design mode, or in caret mode.
+ * @param hintBox caret box whose coordinates will be used if the
+ * caret position could not be determined otherwise.
+ * @return @p true if the caret has been displayed.
+ */
+ bool placeCaret(khtml::CaretBox *hintBox = 0);
+
+ /** extends the selection up to the current caret position.
+ *
+ * When a selection exists, the function adds/removes pieces from the
+ * beginning/end of the selection up to the current caret position.
+ *
+ * The selection values are *not* normalized, i. e. the resulting end
+ * position may actually precede the starting position.
+ *
+ * No validity checking is done on the parameters. Note that the parameters
+ * refer to the old selection, the current caret may be way off.
+ * @param startNode starting node of selection
+ * @param startOffset offset within the start node.
+ * @param endNode ending node of selection
+ * @param endOffset offset within the end node.
+ * @return @p true when the current selection has been changed
+ */
+ bool extendSelection(DOM::NodeImpl *startNode, long startOffset,
+ DOM::NodeImpl *endNode, long endOffset);
+
+ /** updates the selection from the last to the current caret position.
+ *
+ * No validity checking is done on the parameters. Note that the parameters
+ * refer to the old selection, the current caret may be way off.
+ * @param startNode starting node of selection
+ * @param startOffset offset within the start node.
+ * @param endNode ending node of selection
+ * @param endOffset offset within the end node.
+ */
+ void updateSelection(DOM::NodeImpl *startNode, long startOffset,
+ DOM::NodeImpl *endNode, long endOffset);
+
+ /**
+ * Returns the current caret policy when the view is not focused.
+ * @return a KHTMLPart::CaretDisplay value
+ */
+ int caretDisplayPolicyNonFocused() const;
+
+ /**
+ * Sets the caret display policy when the view is not focused.
+ * @param policy new display policy as
+ * defined by KHTMLPart::CaretDisplayPolicy
+ * @since 3.2
+ */
+ void setCaretDisplayPolicyNonFocused(int policy);
+
+ // -- caret event handler
+
+ /**
+ * Evaluates key presses on editable nodes.
+ */
+ void caretKeyPressEvent(QKeyEvent *);
+
+ // -- caret navigation member functions
+
+ /** moves the caret to the given position and displays it.
+ *
+ * If the node resembles an invalid position, the function sets the caret to a
+ * nearby node that is valid.
+ *
+ * @param node node to be set to
+ * @param offset zero-based offset within this node
+ * @param clearSelection @p true if any selection should be cleared
+ * as well.
+ * @return @p true if a previously existing selection has been changed.
+ */
+ bool moveCaretTo(DOM::NodeImpl *node, long offset, bool clearSelection);
+
+ /**
+ * Movement enumeration
+ * @li CaretByCharacter move caret character-wise
+ * @li CaretByWord move caret word-wise
+ */
+ enum CaretMovement { CaretByCharacter, CaretByWord };
+
+ /** moves the caret.
+ *
+ * @param next @p true, move towards the following content, @p false,
+ * move towards the previous
+ * @param cmv CaretMovement operation
+ * @param n count the CaretMovement has to be carried out.
+ * For latin documents, a positive number means moving the caret
+ * these many characters to the right/downwards, a negative number
+ * to the left/upwards. For RTL documents, the opposite applies.
+ */
+ void moveCaretBy(bool next, CaretMovement cmv, int n);
+
+ /** moves the caret by line.
+ */
+ void moveCaretByLine(bool next, int n);
+
+ /** moves the caret to the given line boundary.
+ * @param end @p true if the caret is to be moved to the end of the line,
+ * otherwise to the beginning.
+ */
+ void moveCaretToLineBoundary(bool end);
+
+ /** moves the caret to the given document boundary.
+ * @param end @p true if the caret is to be moved to the end of the
+ * document, otherwise to the beginning.
+ */
+ void moveCaretToDocumentBoundary(bool end);
+
+ /** does the actual caret placement so that it becomes visible at
+ * the new position.
+ *
+ * This method is only suitable if the new caret position has already been
+ * determined.
+ * @param hintBox caret box whose coordinates will be used if the
+ * caret position could not be determined otherwise.
+ */
+ void placeCaretOnChar(khtml::CaretBox *hintBox);
+
+ /** does the actual caret placement so that it becomes visible at
+ * the new position.
+ *
+ * Additionally, it calculates the new caret position from the given
+ * box and coordinates.
+ *
+ * @param caretBox caret box serving as a measurement point for offset.
+ * @param x x-coordinate relative to containing block. The offset will
+ * be approximated as closely as possible to this coordinate,
+ * but never less than caretBox->xPos() and greater than
+ * caretBox->xPos() + caretBox->width()
+ * @param absx absolute x-coordinate of containing block, needed for
+ * calculation of final caret position
+ * @param absy absolute y-coordinate of containing block, needed for
+ * calculation of final caret position
+ */
+ void placeCaretOnLine(khtml::CaretBox *caretBox, int x, int absx, int absy);
+
+ /** moves the caret by a page length.
+ * @param next @p true, move down, @p false, move up.
+ */
+ void moveCaretByPage(bool next);
+
+ /** moves the caret to the beginning of the previous word.
+ */
+ void moveCaretPrevWord();
+
+ /** moves the caret to the beginning of the next word.
+ */
+ void moveCaretNextWord();
+
+ /** moves the caret to the previous line.
+ *
+ * @param n number of lines to move caret
+ */
+ void moveCaretPrevLine(int n = 1);
+
+ /** moves the caret to the following line.
+ *
+ * @param n number of lines to move caret
+ */
+ void moveCaretNextLine(int n = 1);
+
+ /** moves the caret to the previous page
+ */
+ void moveCaretPrevPage();
+
+ /** moves the caret to the next page
+ */
+ void moveCaretNextPage();
+
+ /** moves the caret to the beginning of the current line.
+ */
+ void moveCaretToLineBegin();
+
+ /** moves the caret to the end of the current line.
+ */
+ void moveCaretToLineEnd();
+
+#endif // KHTML_NO_CARET
+
+ // ------------------------------------- member variables ------------------------------------
+ private:
+
+ void setWidgetVisible(::khtml::RenderWidget*, bool visible);
+
+ int _width;
+ int _height;
+
+ int _marginWidth;
+ int _marginHeight;
+
+ KHTMLPart *m_part;
+ KHTMLViewPrivate *d;
+
+ QString m_medium; // media type
+};
+
+#endif
+