Katana_mirror/kdelibs
1
0
Fork 0
mirror of https://bitbucket.org/smil3y/kdelibs.git synced 2025-02-24 10:52:49 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
kdelibs/khtml/khtml_part.h
Ivailo Monev e8c09de3c1 khtml: cleanup Java leftovers 
Signed-off-by: Ivailo Monev <xakepa10@gmail.com>
2016-03-03 04:46:49 +02:00

1922 lines
54 KiB
C++
Raw Blame History

// -*- c-basic-offset: 2 -*-
/* This file is part of the KDE project
*
* Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
* 1999-2001 Lars Knoll <knoll@kde.org>
* 1999-2001 Antti Koivisto <koivisto@kde.org>
* 2000-2001 Simon Hausmann <hausmann@kde.org>
* 2000-2001 Dirk Mueller <mueller@kde.org>
* 2000 Stefan Schimanski <1Stein@gmx.de>
*
* 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 __khtml_part_h__
#define __khtml_part_h__
#include "dom/dom_doc.h"
#include "dom/dom2_range.h"
#include <kparts/part.h>
#include <kparts/browserextension.h>
#include <kdemacros.h>
#include <kfind.h>
#include <kfinddialog.h>
#include <klocalizedstring.h>
#include <kencodingdetector.h>
#include <QtCore/QRegExp>
class KHTMLPartPrivate;
class KHTMLPartBrowserExtension;
class KJSProxy;
class KHTMLView;
class KHTMLViewBar;
class KHTMLFindBar;
class KHTMLSettings;
class KJavaAppletContext;
class KJSErrorDlg;
namespace DOM
{
class HTMLDocument;
class HTMLDocumentImpl;
class DocumentImpl;
class Document;
class XMLDocumentImpl;
class HTMLTitleElementImpl;
class HTMLFrameElementImpl;
class HTMLIFrameElementImpl;
class HTMLObjectElementImpl;
class HTMLFormElementImpl;
class HTMLAnchorElementImpl;
class HTMLMetaElementImpl;
class NodeImpl;
class ElementImpl;
class Node;
class HTMLEventListener;
class EventListener;
class HTMLPartContainerElementImpl;
class HTMLObjectBaseElementImpl;
class Position;
class Selection;
class Range;
class Editor;
}
namespace WebCore
{
class SVGDocumentExtensions;
}
namespace KJS
{
class Interpreter;
class HTMLElement;
}
namespace khtml
{
class DocLoader;
class RenderPart;
class ChildFrame;
class MousePressEvent;
class MouseDoubleClickEvent;
class MouseMoveEvent;
class MouseReleaseEvent;
class DrawContentsEvent;
class CachedObject;
class RenderWidget;
class RenderBlock;
class CSSStyleSelector;
class HTMLTokenizer;
class XMLTokenizer;
struct EditorContext;
class EditCommandImpl;
class KHTMLPartAccessor;
}
namespace KJS {
class Window;
class WindowFunc;
class ExternalFunc;
class JSEventListener;
class JSLazyEventListener;
class JSNodeFilter;
class DOMDocument;
class SourceFile;
class ScheduledAction;
class DOMSelection;
class DOMSelectionProtoFunc;
class KHTMLPartScriptable;
}
namespace KParts
{
class PartManager;
class ScriptableExtension;
}
namespace KWallet
{
class Wallet;
}
/**
* This class is khtml's main class. It features an almost complete
* web browser, and html renderer.
*
* The easiest way to use this class (if you just want to display an HTML
* page at some URL) is the following:
*
* \code
* KUrl url = "http://www.kde.org";
* KHTMLPart *w = new KHTMLPart();
* w->openUrl(url);
* w->view()->resize(500, 400);
* w->show();
* \endcode
*
* Java and JavaScript are enabled by default depending on the user's
* settings. If you do not need them, and especially if you display
* unfiltered data from untrusted sources, it is strongly recommended to
* turn them off. In that case, you should also turn off the automatic
* redirect and plugins:
*
* \code
* w->setJScriptEnabled(false);
* w->setMetaRefreshEnabled(false);
* w->setPluginsEnabled(false);
* \endcode
*
* You may also wish to disable external references. This will prevent KHTML
* from loading images, frames, etc, or redirecting to external sites.
*
* \code
* w->setOnlyLocalReferences(true);
* \endcode
*
* Some apps want to write their HTML code directly into the widget instead of
* opening an url. You can do this in the following way:
*
* \code
* QString myHTMLCode = ...;
* KHTMLPart *w = new KHTMLPart();
* w->begin();
* w->write(myHTMLCode);
* ...
* w->end();
* \endcode
*
* You can do as many calls to write() as you wish. There are two
* write() methods, one accepting a QString and one accepting a
* @p char @p * argument. You should use one or the other
* (but not both) since the method using
* the @p char @p * argument does an additional decoding step to convert the
* written data to Unicode.
*
* It is also possible to write content to the HTML part using the
* standard streaming API from KParts::ReadOnlyPart. The usage of
* the API is similar to that of the begin(), write(), end() process
* described above as the following example shows:
*
* \code
* KHTMLPart *doc = new KHTMLPart();
* doc->openStream( "text/html", KUrl() );
* doc->writeStream( QCString( "<html><body><p>KHTML Rocks!</p></body></html>" ) );
* doc->closeStream();
* \endcode
*
* @short HTML Browser Widget
* @author Lars Knoll (knoll@kde.org)
*
*/
class KHTML_EXPORT KHTMLPart : public KParts::ReadOnlyPart
{
Q_OBJECT
friend class KHTMLView;
friend class DOM::HTMLTitleElementImpl;
friend class DOM::HTMLFrameElementImpl;
friend class DOM::HTMLIFrameElementImpl;
friend class DOM::HTMLObjectBaseElementImpl;
friend class DOM::HTMLObjectElementImpl;
friend class DOM::HTMLAnchorElementImpl;
friend class DOM::HTMLMetaElementImpl;
friend class DOM::NodeImpl;
friend class DOM::ElementImpl;
friend class KHTMLRun;
friend class DOM::HTMLFormElementImpl;
friend class KJS::Window;
friend class KJS::ScheduledAction;
friend class KJS::JSNodeFilter;
friend class KJS::WindowFunc;
friend class KJS::ExternalFunc;
friend class KJS::JSEventListener;
friend class KJS::JSLazyEventListener;
friend class KJS::DOMDocument;
friend class KJS::HTMLElement;
friend class KJS::SourceFile;
friend class KJS::DOMSelection;
friend class KJS::DOMSelectionProtoFunc;
friend class KJS::KHTMLPartScriptable;
friend class KJSProxy;
friend class KHTMLPartBrowserExtension;
friend class DOM::DocumentImpl;
friend class DOM::HTMLDocumentImpl;
friend class DOM::Selection;
friend class DOM::Editor;
friend class KHTMLPartBrowserHostExtension;
friend class khtml::HTMLTokenizer;
friend class khtml::XMLTokenizer;
friend class khtml::RenderWidget;
friend class khtml::RenderBlock;
friend class khtml::CSSStyleSelector;
friend class khtml::EditCommandImpl;
friend class khtml::KHTMLPartAccessor;
friend class KHTMLPartIface;
friend class KHTMLPartFunction;
friend class KHTMLPopupGUIClient;
friend class KHTMLFind;
friend class StorePass;
friend class WebCore::SVGDocumentExtensions;
Q_PROPERTY( bool javaScriptEnabled READ jScriptEnabled WRITE setJScriptEnabled )
Q_PROPERTY( bool dndEnabled READ dndEnabled WRITE setDNDEnabled )
Q_PROPERTY( bool pluginsEnabled READ pluginsEnabled WRITE setPluginsEnabled )
Q_PROPERTY( DNSPrefetch dnsPrefetch READ dnsPrefetch WRITE setDNSPrefetch )
/*
*
* Don't add setOnlyLocalReferences here. It shouldn't be accessible via DBus.
*
**/
Q_PROPERTY( bool modified READ isModified )
Q_PROPERTY( QString encoding READ encoding WRITE setEncoding )
Q_PROPERTY( QString lastModified READ lastModified )
Q_PROPERTY( bool metaRefreshEnabled READ metaRefreshEnabled WRITE setMetaRefreshEnabled )
public:
enum GUIProfile { DefaultGUI, BrowserViewGUI /* ... */ };
/**
* DNS Prefetching Mode enumeration
* @li DNSPrefetchDisabled do not prefetch hostnames
* @li DNSPrefetchEnabled always prefetch hostnames
* @li DNSPrefetchOnlyWWWAndSLD only do DNS prefetching for bare SLD and www sub-domain
*/
enum DNSPrefetch {
DNSPrefetchDisabled=0,
DNSPrefetchEnabled,
DNSPrefetchOnlyWWWAndSLD
};
/**
* Constructs a new KHTMLPart.
*
* KHTML basically consists of two objects: The KHTMLPart itself,
* holding the document data (DOM document), and the KHTMLView,
* derived from QScrollArea, in which the document content is
* rendered in. You can specify two different parent objects for a
* KHTMLPart, one parent for the KHTMLPart document and one parent
* for the KHTMLView. If the second @p parent argument is 0L, then
* @p parentWidget is used as parent for both objects, the part and
* the view.
*/
KHTMLPart( QWidget *parentWidget = 0,
QObject *parent = 0, GUIProfile prof = DefaultGUI );
/**
* Constructs a new KHTMLPart.
*
* This constructor is useful if you wish to subclass KHTMLView.
* If the @p view passed as first argument to the constructor was built with a
* null KHTMLPart pointer, then the newly created KHTMLPart will be assigned as the view's part.
*
* Therefore, you might either initialize the view as part of the initialization list of
* your derived KHTMLPart class constructor:
* \code
* MyKHTMLPart() : KHTMLPart( new MyKHTMLView( this ), ...
* \endcode
* Or separately build the KHTMLView beforehand:
* \code
* KHTMLView * v = KHTMLView( 0L, parentWidget());
* KHTMLPart * p = KHTMLPart( v ); // p will be assigned to v, so that v->part() == p
* \endcode
*/
KHTMLPart( KHTMLView *view, QObject *parent = 0, GUIProfile prof = DefaultGUI );
/**
* Destructor.
*/
virtual ~KHTMLPart();
/**
* Opens the specified URL @p url.
*
* Reimplemented from KParts::ReadOnlyPart::openUrl .
*/
virtual bool openUrl( const KUrl &url );
/**
* Stops loading the document and kills all data requests (for images, etc.)
*/
virtual bool closeUrl();
/**
* Called when a certain error situation (i.e. connection timed out) occurred.
* The default implementation either shows a KIO error dialog or loads a more
* verbose error description a as page, depending on the users configuration.
* @p job is the job that signaled the error situation
*/
virtual void showError( KJob* job );
/**
* Returns a reference to the DOM HTML document (for non-HTML documents, returns null)
*/
DOM::HTMLDocument htmlDocument() const;
/**
* Returns a reference to the DOM document.
*/
DOM::Document document() const;
/**
* Returns the content of the source document.
*/
QString documentSource() const;
/**
* Returns the node that has the keyboard focus.
*/
DOM::Node activeNode() const;
/**
* Returns a pointer to the KParts::BrowserExtension.
*/
KParts::BrowserExtension *browserExtension() const;
KParts::BrowserHostExtension *browserHostExtension() const;
/**
* Returns a pointer to the HTML document's view.
*/
KHTMLView *view() const;
/**
* Enable/disable Javascript support. Note that this will
* in either case permanently override the default usersetting.
* If you want to have the default UserSettings, don't call this
* method.
*/
void setJScriptEnabled( bool enable );
/**
* Returns @p true if Javascript support is enabled or @p false
* otherwise.
*/
bool jScriptEnabled() const;
/**
* Returns the JavaScript interpreter the part is using. This method is
* mainly intended for applications which embed and extend the part and
* provides a mechanism for adding additional native objects to the
* interpreter (or removing the built-ins).
*
* One thing people using this method to add things to the interpreter must
* consider, is that when you start writing new content to the part, the
* interpreter is cleared. This includes both use of the
* begin( const KUrl &, int, int ) method, and the openUrl( const KUrl & )
* method. If you want your objects to have a longer lifespan, then you must
* retain a KJS::Object yourself to ensure that the reference count of your
* custom objects never reaches 0. You will also need to re-add your
* bindings every time this happens - one way to detect the need for this is
* to connect to the docCreated() signal, another is to reimplement the
* begin() method.
*/
KJS::Interpreter *jScriptInterpreter();
/**
* Enable/disable statusbar messages.
* When this class wants to set the statusbar text, it emits
* setStatusBarText(const QString & text)
* If you want to catch this for your own statusbar, note that it returns
* back a rich text string, starting with "<qt>". This you need to
* either pass this into your own QLabel or to strip out the tags
* before passing it to QStatusBar::message(const QString & message)
*
* @see KParts::Part::setStatusBarText( const QString & text )
*/
void setStatusMessagesEnabled( bool enable );
/**
* Returns @p true if status messages are enabled.
*/
bool statusMessagesEnabled() const;
/**
* Enable/disable automatic forwarding by &lt;meta http-equiv="refresh" ....&gt;
*/
void setMetaRefreshEnabled( bool enable );
/**
* Returns @p true if automatic forwarding is enabled.
*/
bool metaRefreshEnabled() const;
/**
* Same as executeScript( const QString & ) except with the Node parameter
* specifying the 'this' value.
*/
QVariant executeScript( const DOM::Node &n, const QString &script );
/**
* Enables or disables Drag'n'Drop support. A drag operation is started if
* the users drags a link.
*/
void setDNDEnabled( bool b );
/**
* Returns whether Dragn'n'Drop support is enabled or not.
*/
bool dndEnabled() const;
/**
* Enables or disables plugins, default is enabled
*/
void setPluginsEnabled( bool enable );
/**
* Returns @p true if plugins are enabled, @p false if disabled.
*/
bool pluginsEnabled() const;
/**
* Specifies whether images contained in the document should be loaded
* automatically or not.
*
* @note Request will be ignored if called before begin().
*/
void setAutoloadImages( bool enable );
/**
* Returns whether images contained in the document are loaded automatically
* or not.
* @note that the returned information is unrelieable as long as no begin()
* was called.
*/
bool autoloadImages() const;
/**
* Security option.
*
* Specify whether only file:/ or data:/ urls are allowed to be loaded without
* user confirmation by KHTML.
* ( for example referenced by stylesheets, images, scripts, subdocuments, embedded elements ).
*
* This option is mainly intended for enabling the "mail reader mode", where you load untrusted
* content with a file:/ url.
*
* Please note that enabling this option currently automatically disables Javascript,
* Java and Plugins support. This might change in the future if the security model
* is becoming more sophisticated, so don't rely on this behaviour.
*
* ( default @p false - everything is loaded unless forbidden by KApplication::authorizeURLAction).
*/
void setOnlyLocalReferences( bool enable );
/**
* Security option. If this is set to true, content loaded from external URLs
* will be permitted to access images on disk regardless of of the Kiosk policy.
* You should be careful in enabling this, as it may make it easier to fake
* any HTML-based chrome or to perform other such user-confusion attack.
* @p false by default.
*
* @since 4.6
*/
void setForcePermitLocalImages( bool enable );
/**
* Sets whether DNS Names found in loaded documents'anchors should be pre-fetched (pre-resolved).
* Note that calling this function will permanently override the User settings about
* DNS prefetch support.
* Not calling this function is the only way to let the default settings apply.
*
* @note This setting has no effect if @ref setOnlyLocalReferences() mode is enabled.
*
* @param pmode the mode to set. See @ref DNSPrefetch enum for explanation of values.
*
* @since 4.2
*/
void setDNSPrefetch( DNSPrefetch pmode );
/**
* Returns currently set DNS prefetching mode.
* See @p DNSPrefetch enum for explanation of values.
*
* @note Always returns @p DNSPrefetchDisabled if @ref setOnlyLocalReferences() mode is enabled.
*
* @since 4.2
*/
DNSPrefetch dnsPrefetch() const;
/**
* Returns whether only file:/ or data:/ references are allowed
* to be loaded ( default @p false ). See setOnlyLocalReferences.
**/
bool onlyLocalReferences() const;
/**
* If true, local image files will be loaded even when forbidden by the
* Kiosk/KAuthorized policies ( default @p false ). See @ref setForcePermitLocalImages.
*
* @since 4.6
**/
bool forcePermitLocalImages() const;
/** Returns whether caret mode is on/off.
*/
bool isCaretMode() const;
/**
* Returns @p true if the document is editable, @p false otherwise.
*/
bool isEditable() const;
/**
* Sets the caret to the given position.
*
* If the given location is invalid, it will snap to the nearest valid
* location. Immediately afterwards a @p caretPositionChanged signal
* containing the effective position is emitted
* @param node node to set to
* @param offset zero-based offset within the node
* @param extendSelection If @p true, a selection will be spanned from the
* last caret position to the given one. Otherwise, any existing selection
* will be deselected.
*/
void setCaretPosition(DOM::Node node, long offset, bool extendSelection = false);
/**
* Enumeration for displaying the caret.
*/
enum CaretDisplayPolicy {
CaretVisible, /**< caret is displayed */
CaretInvisible, /**< caret is not displayed */
CaretBlink /**< caret toggles between visible and invisible */
};
/**
* Returns the current caret policy when the view is not focused.
*/
CaretDisplayPolicy caretDisplayPolicyNonFocused() const;
/**
* Sets the caret display policy when the view is not focused.
*
* Whenever the caret is in use, this property determines how the
* caret should be displayed when the document view is not focused.
*
* The default policy is CaretInvisible.
* @param policy new display policy
*/
void setCaretDisplayPolicyNonFocused(CaretDisplayPolicy policy);
#ifndef KDE_NO_COMPAT
KUrl baseURL() const;
#endif
/**
* Returns the URL for the background Image (used by save background)
*/
KUrl backgroundURL() const;
/**
* Schedules a redirection after @p delay seconds.
*/
void scheduleRedirection( int delay, const QString &url, bool lockHistory = true );
/**
* Clears the widget and prepares it for new content.
*
* If you want url() to return
* for example "file:/tmp/test.html", you can use the following code:
* \code
* view->begin( KUrl("file:/tmp/test.html" ) );
* \endcode
*
* @param url is the url of the document to be displayed. Even if you
* are generating the HTML on the fly, it may be useful to specify
* a directory so that any pixmaps are found.
*
* @param xOffset is the initial horizontal scrollbar value. Usually
* you don't want to use this.
*
* @param yOffset is the initial vertical scrollbar value. Usually
* you don't want to use this.
*
* All child frames and the old document are removed if you call
* this method.
*/
virtual void begin( const KUrl &url = KUrl(), int xOffset = 0, int yOffset = 0 );
/**
* Writes another part of the HTML code to the widget.
*
* You may call
* this function many times in sequence. But remember: The fewer calls
* you make, the faster the widget will be.
*
* The HTML code is send through a decoder which decodes the stream to
* Unicode.
*
* The @p len parameter is needed for streams encoded in utf-16,
* since these can have \\0 chars in them. In case the encoding
* you're using isn't utf-16, you can safely leave out the length
* parameter.
*
* Attention: Don't mix calls to write( const char *) with calls
* to write( const QString & ).
*
* The result might not be what you want.
*/
virtual void write( const char *str, int len = -1 );
/**
* Writes another part of the HTML code to the widget.
*
* You may call
* this function many times in sequence. But remember: The fewer calls
* you make, the faster the widget will be.
*
* For historic and backward compatibility reasons, this method will force
* the use of strict mode for the document, unless setAlwaysHonourDoctype()
* has been called previously.
*/
// FIXME KDE5: always honour doctype, remove setAlwaysHonourDoctype()
virtual void write( const QString &str );
/**
* Call this after your last call to write().
*/
virtual void end();
/*
* Prints the current HTML page laid out for the printer.
*
* (not implemented at the moment)
*/
// void print(QPainter *, int pageHeight, int pageWidth);
/**
* Paints the HTML page to a QPainter. See KHTMLView::paint for details
*/
void paint( QPainter *, const QRect &, int = 0, bool * = 0 );
/**
* Sets the encoding the page uses.
*
* This can be different from the charset. The widget will try to reload the current page in the new
* encoding, if url() is not empty.
*/
bool setEncoding( const QString &name, bool override = false );
/**
* Returns the encoding the page currently uses.
*
* Note that the encoding might be different from the charset.
*/
QString encoding() const;
/**
* Sets a user defined style sheet to be used on top of the HTML 4
* default style sheet.
*
* This gives a wide range of possibilities to
* change the layout of the page.
*
* To have an effect this function has to be called after calling begin().
*/
void setUserStyleSheet( const KUrl &url );
/**
* Sets a user defined style sheet to be used on top of the HTML 4
* default style sheet.
*
* This gives a wide range of possibilities to
* change the layout of the page.
*
* To have an effect this function has to be called after calling begin().
*/
void setUserStyleSheet( const QString &styleSheet );
public:
/**
* Sets the standard font style.
*
* @param name The font name to use for standard text.
*/
void setStandardFont( const QString &name );
/**
* Sets the fixed font style.
*
* @param name The font name to use for fixed text, e.g.
* the <tt>&lt;pre&gt;</tt> tag.
*/
void setFixedFont( const QString &name );
/**
* Finds the anchor named @p name.
*
* If the anchor is found, the widget
* scrolls to the closest position. Returns @p if the anchor has
* been found.
*/
bool gotoAnchor( const QString &name );
/**
* Go to the next anchor
*
* This is useful to navigate from outside the navigator
*/
bool nextAnchor();
/**
* Go to previous anchor
*/
bool prevAnchor();
/**
* Sets the cursor to use when the cursor is on a link.
*/
void setURLCursor( const QCursor &c );
/**
* Returns the cursor which is used when the cursor is on a link.
*/
QCursor urlCursor() const;
/**
* Extra Find options that can be used when calling the extended findText().
*/
enum FindOptions
{
FindLinksOnly = 1 * KFind::MinimumUserOption,
FindNoPopups = 2 * KFind::MinimumUserOption
//FindIncremental = 4 * KFind::MinimumUserOption
};
/**
* Starts a new search by popping up a dialog asking the user what he wants to
* search for.
*/
void findText();
/**
* Starts a new search, but bypasses the user dialog.
* @param str The string to search for.
* @param options Find options.
* @param parent Parent used for centering popups like "string not found".
* @param findDialog Optionally, you can supply your own dialog.
*/
void findText( const QString &str, long options, QWidget *parent = 0,
KFindDialog *findDialog = 0 );
/**
* Initiates a text search.
*/
void findTextBegin();
/**
* Finds the next occurrence of a string set by @ref findText()
* @param reverse if @p true, revert seach direction (only if no find dialog is used)
* @return @p true if a new match was found.
*/
bool findTextNext( bool reverse = false );
/**
* Sets the Zoom factor. The value is given in percent, larger values mean a
* generally larger font and larger page contents.
*
* The given value should be in the range of 20..300, values outside that
* range are not guaranteed to work. A value of 100 will disable all zooming
* and show the page with the sizes determined via the given lengths in the
* stylesheets.
*/
void setZoomFactor(int percent);
/**
* Returns the current zoom factor.
*/
int zoomFactor() const;
/**
* Sets the scale factor to be applied to fonts. The value is given in percent,
* larger values mean generally larger fonts.
*
* The given value should be in the range of 20..300, values outside that
* range are not guaranteed to work. A value of 100 will disable all scaling of font sizes
* and show the page with the sizes determined via the given lengths in the
* stylesheets.
*/
void setFontScaleFactor(int percent);
/**
* Returns the current font scale factor.
*/
int fontScaleFactor() const;
/**
* Returns the text the user has marked.
*/
virtual QString selectedText() const;
/**
* Return the text the user has marked. This is guaranteed to be valid xml,
* and to contain the \<html> and \<body> tags.
*
* FIXME probably should make virtual for 4.0 ?
*/
QString selectedTextAsHTML() const;
/**
* Returns the selected part of the HTML.
*/
DOM::Range selection() const;
/**
* Returns the selected part of the HTML by returning the starting and end
* position.
*
* If there is no selection, both nodes and offsets are equal.
* @param startNode returns node selection starts in
* @param startOffset returns offset within starting node
* @param endNode returns node selection ends in
* @param endOffset returns offset within end node.
*/
void selection(DOM::Node &startNode, long &startOffset,
DOM::Node &endNode, long &endOffset) const;
/**
* Sets the current selection.
*/
void setSelection( const DOM::Range & );
/**
* Has the user selected anything?
*
* Call selectedText() to
* retrieve the selected text.
*
* @return @p true if there is text selected.
*/
bool hasSelection() const;
/**
* Returns the instance of the attached html editor interface.
*
*/
DOM::Editor *editor() const;
/**
* Marks all text in the document as selected.
*/
void selectAll();
/**
* Convenience method to show the document's view.
*
* Equivalent to widget()->show() or view()->show() .
*/
void show();
/**
* Convenience method to hide the document's view.
*
* Equivalent to widget()->hide() or view()->hide().
*/
void hide();
/**
* Returns a reference to the partmanager instance which
* manages html frame objects.
*/
KParts::PartManager *partManager();
/**
* Saves the KHTMLPart's complete state (including child frame
* objects) to the provided QDataStream.
*
* This is called from the saveState() method of the
* browserExtension().
*/
virtual void saveState( QDataStream &stream );
/**
* Restores the KHTMLPart's previously saved state (including
* child frame objects) from the provided QDataStream.
*
* @see saveState()
*
* This is called from the restoreState() method of the
* browserExtension() .
**/
virtual void restoreState( QDataStream &stream );
/**
* Returns the @p Node currently under the mouse.
*
* The returned node may be a shared node (e. g. an \<area> node if the
* mouse is hovering over an image map).
*/
DOM::Node nodeUnderMouse() const;
/**
* Returns the @p Node currently under the mouse that is not shared.
*
* The returned node is always the node that is physically under the mouse
* pointer (irrespective of logically overlying elements like, e. g.,
* \<area> on image maps).
*/
DOM::Node nonSharedNodeUnderMouse() const;
/**
* @internal
*/
const KHTMLSettings *settings() const;
/**
* Returns a pointer to the parent KHTMLPart if the part is a frame
* in an HTML frameset.
*
* Returns 0L otherwise.
*/
// ### KDE5 make const
KHTMLPart *parentPart();
/**
* Returns a list of names of all frame (including iframe) objects of
* the current document. Note that this method is not working recursively
* for sub-frames.
*/
QStringList frameNames() const;
QList<KParts::ReadOnlyPart*> frames() const;
/**
* Finds a frame by name. Returns 0L if frame can't be found.
*/
KHTMLPart *findFrame( const QString &f );
/**
* Recursively finds the part containing the frame with name @p f
* and checks if it is accessible by @p callingPart
* Returns 0L if no suitable frame can't be found.
* Returns parent part if a suitable frame was found and
* frame info in @p *childFrame
*/
KHTMLPart *findFrameParent( KParts::ReadOnlyPart *callingPart, const QString &f, khtml::ChildFrame **childFrame=0 );
/**
* Return the current frame (the one that has focus)
* Not necessarily a direct child of ours, framesets can be nested.
* Returns "this" if this part isn't a frameset.
*/
KParts::ReadOnlyPart *currentFrame() const;
/**
* Returns whether a frame with the specified name is exists or not.
* In contrast to the findFrame method this one also returns @p true
* if the frame is defined but no displaying component has been
* found/loaded, yet.
*/
bool frameExists( const QString &frameName );
/**
* Returns child frame framePart its script interpreter
*/
KJSProxy *framejScript(KParts::ReadOnlyPart *framePart);
/**
* Finds a frame by name. Returns 0L if frame can't be found.
*/
KParts::ReadOnlyPart *findFramePart( const QString &f );
/**
* Called by KJS.
* Sets the StatusBarText assigned
* via window.status
*/
void setJSStatusBarText( const QString &text );
/**
* Called by KJS.
* Sets the DefaultStatusBarText assigned
* via window.defaultStatus
*/
void setJSDefaultStatusBarText( const QString &text );
/**
* Called by KJS.
* Returns the StatusBarText assigned
* via window.status
*/
QString jsStatusBarText() const;
/**
* Called by KJS.
* Returns the DefaultStatusBarText assigned
* via window.defaultStatus
*/
QString jsDefaultStatusBarText() const;
/**
* Referrer used for links in this page.
*/
QString referrer() const;
/**
* Referrer used to obtain this page.
*/
QString pageReferrer() const;
/**
* Last-modified date (in raw string format), if received in the [HTTP] headers.
*/
QString lastModified() const;
/**
* Loads a style sheet into the stylesheet cache.
*/
void preloadStyleSheet( const QString &url, const QString &stylesheet );
/**
* Loads a script into the script cache.
*/
void preloadScript( const QString &url, const QString &script );
/**
* Returns whether the given point is inside the current selection.
*
* The coordinates are content-coordinates.
*/
bool isPointInsideSelection(int x, int y);
/**
* @internal
*/
bool restored() const;
/**
* Sets whether the document's Doctype should always be used
* to determine the parsing mode for the document.
*
* Without this, parsing will be forced to
* strict mode when using the write( const QString &str )
* method for backward compatibility reasons.
*
*/
// ### KDE5 remove - fix write( const QString &str ) instead
void setAlwaysHonourDoctype( bool b = true );
// ### KDE5 remove me
enum FormNotification { NoNotification = 0, Before, Only, Unused=255 };
/**
* Determine if signal should be emitted before, instead or never when a
* submitForm() happens.
* ### KDE5 remove me
*/
void setFormNotification(FormNotification fn);
/**
* Determine if signal should be emitted before, instead or never when a
* submitForm() happens.
* ### KDE5 remove me
*/
FormNotification formNotification() const;
/**
* Returns the toplevel (origin) URL of this document, even if this
* part is a frame or an iframe.
*
* @return the actual original url.
*/
KUrl toplevelURL();
/**
* Checks whether the page contains unsubmitted form changes.
*
* @return @p true if form changes exist
*/
bool isModified() const;
/**
* Shows or hides the suppressed popup indicator
*/
void setSuppressedPopupIndicator( bool enable, KHTMLPart *originPart = 0 );
/**
* @internal
*/
bool inProgress() const;
Q_SIGNALS:
/**
* Emitted if the cursor is moved over an URL.
*/
void onURL( const QString &url );
/**
* Emitted when the user clicks the right mouse button on the document.
* See KParts::BrowserExtension for two more popupMenu signals emitted by khtml,
* with much more information in the signal.
*/
void popupMenu( const QString &url, const QPoint &point );
/**
* This signal is emitted when the selection changes.
*/
void selectionChanged();
/**
* This signal is emitted when an element retrieves the
* keyboard focus. Note that the signal argument can be
* a null node if no element is active, meaning a node
* has explicitly been deactivated without a new one
* becoming active.
*/
void nodeActivated( const DOM::Node & );
/**
* @internal */
void docCreated();
/**
* This signal is emitted whenever the caret position has been changed.
*
* The signal transmits the position the DOM::Range way, the node and
* the zero-based offset within this node.
* @param node node which the caret is in. This can be null if the caret
* has been deactivated.
* @param offset offset within the node. If the node is null, the offset
* is meaningless.
*/
void caretPositionChanged(const DOM::Node &node, long offset);
/**
* If form notification is on, this will be emitted either for a form
* submit or before the form submit according to the setting.
* ### KDE4 remove me
*/
void formSubmitNotification(const char *action, const QString& url,
const QByteArray& formData, const QString& target,
const QString& contentType, const QString& boundary);
/**
* Emitted whenever the configuration has changed
*/
void configurationChanged();
protected:
/**
* returns a KUrl object for the given url. Use when
* you know what you're doing.
*/
KUrl completeURL( const QString &url );
/**
* presents a detailed error message to the user.
* @p errorCode kio error code, eg KIO::ERR_SERVER_TIMEOUT.
* @p text kio additional information text.
* @p url the url that triggered the error.
*/
void htmlError( int errorCode, const QString& text, const KUrl& reqUrl );
virtual void customEvent( QEvent *event );
/**
* Eventhandler of the khtml::MousePressEvent.
*/
virtual void khtmlMousePressEvent( khtml::MousePressEvent *event );
/**
* Eventhandler for the khtml::MouseDoubleClickEvent.
*/
virtual void khtmlMouseDoubleClickEvent( khtml::MouseDoubleClickEvent * );
/**
* Eventhandler for the khtml::MouseMouseMoveEvent.
*/
virtual void khtmlMouseMoveEvent( khtml::MouseMoveEvent *event );
/**
* Eventhandler for the khtml::MouseMouseReleaseEvent.
*/
virtual void khtmlMouseReleaseEvent( khtml::MouseReleaseEvent *event );
/**
* Eventhandler for the khtml::DrawContentsEvent.
*/
virtual void khtmlDrawContentsEvent( khtml::DrawContentsEvent * );
/**
* Internal reimplementation of KParts::Part::guiActivateEvent .
*/
virtual void guiActivateEvent( KParts::GUIActivateEvent *event );
/**
* Internal empty reimplementation of KParts::ReadOnlyPart::openFile .
*/
virtual bool openFile();
virtual bool urlSelected( const QString &url, int button, int state,
const QString &_target,
const KParts::OpenUrlArguments& args = KParts::OpenUrlArguments(),
const KParts::BrowserArguments& browserArgs = KParts::BrowserArguments() );
/**
* This method is called when a new embedded object (include html frames) is to be created.
* Reimplement it if you want to add support for certain embeddable objects without registering
* them in the KDE wide registry system (KSyCoCa) . Another reason for re-implementing this
* method could be if you want to derive from KTHMLPart and also want all html frame objects
* to be a object of your derived type, in which case you should return a new instance for
* the mimetype 'text/html' .
*/
virtual KParts::ReadOnlyPart *createPart( QWidget *parentWidget,
QObject *parent,
const QString &mimetype, QString &serviceName,
QStringList &serviceTypes, const QStringList &params);
// This is for RenderPartObject. We want to ask the 'download plugin?'
// question only once per mimetype
bool pluginPageQuestionAsked( const QString& mimetype ) const;
void setPluginPageQuestionAsked( const QString& mimetype );
enum PageSecurity { NotCrypted, Encrypted, Mixed };
void setPageSecurity( PageSecurity sec );
/**
* Implements the streaming API of KParts::ReadOnlyPart.
*/
virtual bool doOpenStream( const QString& mimeType );
/**
* Implements the streaming API of KParts::ReadOnlyPart.
*/
virtual bool doWriteStream( const QByteArray& data );
/**
* Implements the streaming API of KParts::ReadOnlyPart.
*/
virtual bool doCloseStream();
/**
* @internal
*/
virtual void timerEvent(QTimerEvent *);
/**
* Will pre-resolve @p name according to dnsPrefetch current settings
* Returns @p true if the name will be pre-resolved.
* Otherwise returns false.
*/
bool mayPrefetchHostname( const QString& name );
/**
* @internal
*/
void updateZoomFactor();
public Q_SLOTS:
/**
* Sets the focused node of the document to the specified node. If the node is a form control, the control will
* receive focus in the same way that it would if the user had clicked on it or tabbed to it with the keyboard. For
* most other types of elements, there is no visual indication of whether or not they are focused.
*
* See activeNode
*
* @param node The node to focus
*/
void setActiveNode( const DOM::Node &node );
/**
* Stops all animated images on the current and child pages
*/
void stopAnimations();
/**
* Execute the specified snippet of JavaScript code.
*
* Returns @p true if JavaScript was enabled, no error occurred
* and the code returned @p true itself or @p false otherwise.
* @deprecated, use executeString( DOM::Node(), script)
*/
QVariant executeScript( const QString &script );
/**
* Enables/disables caret mode.
*
* Enabling caret mode displays a caret which can be used to navigate
* the document using the keyboard only. Caret mode is switched off by
* default.
*
* @param enable @p true to enable, @p false to disable caret mode.
*/
void setCaretMode(bool enable);
/**
* Makes the document editable.
*
* Setting this property to @p true makes the document, and its
* subdocuments (such as frames, iframes, objects) editable as a whole.
* FIXME: insert more information about navigation, features etc. as seen fit
*
* @param enable @p true to set document editable, @p false to set it
* read-only.
*/
void setEditable(bool enable);
/**
* Sets the visibility of the caret.
*
* This methods displays or hides the caret regardless of the current
* caret display policy (see setCaretDisplayNonFocused), and regardless
* of focus.
*
* The caret will be shown/hidden only under at least one of
* the following conditions:
* @li the document is editable
* @li the document is in caret mode
* @li the document's currently focused element is editable
*
* @param show @p true to make visible, @p false to hide.
*/
void setCaretVisible(bool show);
// ### KDE4 FIXME:
// Remove this and make the one below protected+virtual slot.
// Warning: this is effectively "internal". Be careful.
void submitFormProxy( const char *action, const QString &url,
const QByteArray &formData,
const QString &target,
const QString& contentType = QString(),
const QString& boundary = QString() );
protected Q_SLOTS:
/**
* Called when the job downloading the page is finished.
* Can be reimplemented, for instance to get metadata out of the job,
* but make sure to call KHTMLPart::slotFinished() too.
*/
virtual void slotFinished( KJob* );
protected:
/**
* Hook for adding code before a job is started.
* This can be used to add metadata, like job->addMetaData("PropagateHttpHeader", "true")
* to get the HTTP headers.
*/
virtual void startingJob( KIO::Job * ) {}
private Q_SLOTS:
/**
* @internal
*/
void reparseConfiguration();
/**
* @internal
*/
void slotData( KIO::Job*, const QByteArray &data );
/**
* @internal
*/
void slotInfoMessage( KJob*, const QString& msg );
/**
* @internal
*/
void slotFinishedParsing();
/**
* @internal
*/
void slotRedirect();
/**
* @internal
*/
void slotRedirection( KIO::Job*, const KUrl& );
/**
* @internal
*/
void slotDebugScript();
/**
* @internal
*/
void slotDebugDOMTree();
/**
* @internal
*/
void slotDebugRenderTree();
void slotDebugFrameTree();
/**
* @internal
*/
void slotStopAnimations();
/**
* @internal
*/
virtual void slotViewDocumentSource();
/**
* @internal
*/
virtual void slotViewFrameSource();
/**
* @internal
*/
void slotViewPageInfo();
/**
* @internal
*/
virtual void slotSaveBackground();
/**
* @internal
*/
virtual void slotSaveDocument();
/**
* @internal
*/
virtual void slotSaveFrame();
/**
* @internal
*/
virtual void slotSecurity();
/**
* @internal
*/
virtual void slotSetEncoding(const QString &);
/**
* @internal
*/
virtual void slotUseStylesheet();
virtual void slotFind();
virtual void slotFindDone(); // ### remove me
virtual void slotFindDialogDestroyed(); // ### remove me
void slotFindNext();
void slotFindPrev();
void slotFindAheadText();
void slotFindAheadLink();
void slotIncZoom();
void slotDecZoom();
void slotIncZoomFast();
void slotDecZoomFast();
void slotIncFontSize();
void slotDecFontSize();
void slotIncFontSizeFast();
void slotDecFontSizeFast();
void slotLoadImages();
void slotWalletClosed();
void launchWalletManager();
void walletMenu();
void delNonPasswordStorableSite();
void removeStoredPasswordForm(QAction* action);
void addWalletFormKey(const QString& walletFormKey);
/**
* @internal
*/
void submitFormAgain();
/**
* @internal
*/
void updateActions();
/**
* @internal
*/
void slotPartRemoved( KParts::Part *part );
/**
* @internal
*/
void slotActiveFrameChanged( KParts::Part *part );
/**
* @internal
*/
void slotChildStarted( KIO::Job *job );
/**
* @internal
*/
void slotChildCompleted();
/**
* @internal
*/
void slotChildCompleted( bool );
/**
* @internal
*/
void slotParentCompleted();
/**
* @internal
*/
void slotChildURLRequest( const KUrl &url, const KParts::OpenUrlArguments&, const KParts::BrowserArguments &args );
/**
* @internal
*/
void slotChildDocCreated();
/**
* @internal
*/
void slotRequestFocus( KParts::ReadOnlyPart * );
void slotLoaderRequestStarted( khtml::DocLoader*, khtml::CachedObject* obj);
void slotLoaderRequestDone( khtml::DocLoader*, khtml::CachedObject *obj );
void checkCompleted();
/**
* @internal
*/
void slotAutoScroll();
void slotPrintFrame();
void slotSelectAll();
/**
* @internal
*/
void slotProgressUpdate();
/*
* @internal
*/
void slotJobPercent( KJob*, unsigned long );
/*
* @internal
*/
void slotJobDone( KJob* );
/*
* @internal
*/
void slotUserSheetStatDone( KJob* );
/*
* @internal
*/
void slotJobSpeed( KJob*, unsigned long );
/**
* @internal
*/
void slotClearSelection();
/**
* @internal
*/
void slotZoomView( int );
/**
* @internal
*/
void slotAutomaticDetectionLanguage(KEncodingDetector::AutoDetectScript scri);
/**
* @internal
*/
void slotToggleCaretMode();
/**
* @internal
*/
void suppressedPopupMenu();
/**
* @internal
*/
void togglePopupPassivePopup();
/**
* @internal
*/
void showSuppressedPopups();
/**
* @internal
*/
void launchJSConfigDialog();
/**
* @internal
*/
void launchJSErrorDialog();
/**
* @internal
*/
void removeJSErrorExtension();
/**
* @internal
*/
void disableJSErrorExtension();
/**
* @internal
*/
void jsErrorDialogContextMenu();
/**
* @internal
* used to restore or reset the view's scroll position (including positioning on anchors)
* once a sufficient portion of the document as been laid out.
*/
void restoreScrollPosition();
void walletOpened(KWallet::Wallet*);
private:
KJSErrorDlg *jsErrorExtension();
enum StatusBarPriority { BarDefaultText, BarHoverText, BarOverrideText };
void setStatusBarText( const QString& text, StatusBarPriority p);
bool restoreURL( const KUrl &url );
void clearCaretRectIfNeeded();
void setFocusNodeIfNeeded(const DOM::Selection &);
void selectionLayoutChanged();
void notifySelectionChanged(bool closeTyping=true);
void resetFromScript();
void emitSelectionChanged();
void onFirstData();
// Returns whether callingHtmlPart may access this part
bool checkFrameAccess(KHTMLPart *callingHtmlPart);
bool openUrlInFrame(const KUrl &url, const KParts::OpenUrlArguments& arguments, const KParts::BrowserArguments &browserArguments);
void startAutoScroll();
void stopAutoScroll();
void overURL( const QString &url, const QString &target, bool shiftPressed = false );
void resetHoverText(); // Undo overURL and reset HoverText
KParts::ScriptableExtension *scriptableExtension( const DOM::NodeImpl *);
KWallet::Wallet* wallet();
void openWallet(DOM::HTMLFormElementImpl*);
void saveToWallet(const QString& key, const QMap<QString,QString>& data);
void dequeueWallet(DOM::HTMLFormElementImpl*);
void saveLoginInformation(const QString& host, const QString& key, const QMap<QString, QString>& walletMap);
void enableFindAheadActions(bool);
/**
* Returns a pointer to the top view bar.
*/
KHTMLViewBar *pTopViewBar() const;
/**
* Returns a pointer to the bottom view bar.
*/
KHTMLViewBar *pBottomViewBar() const;
/**
* @internal
*/
bool pFindTextNextInThisFrame( bool reverse );
/**
* @internal
*/
// ### KDE4 FIXME:
// It is desirable to be able to filter form submissions as well.
// For instance, forms can have a target and an inheriting class
// might want to filter based on the target. Make this protected
// and virtual, or provide a better solution.
// See the web_module for the sidebar for an example where this is
// necessary.
void submitForm( const char *action, const QString &url, const QByteArray &formData,
const QString &target, const QString& contentType = QString(),
const QString& boundary = QString() );
void popupMenu( const QString &url );
void init( KHTMLView *view, GUIProfile prof );
void clear();
QVariant crossFrameExecuteScript(const QString& target, const QString& script);
/**
* @internal returns a name for a frame without a name.
* This function returns a sequence of names.
* All names in a sequence are different but the sequence is
* always the same.
* The sequence is reset in clear().
*/
QString requestFrameName();
// Requests loading of a frame or iframe element
void loadFrameElement( DOM::HTMLPartContainerElementImpl *frame, const QString &url, const QString &frameName,
const QStringList &args = QStringList(), bool isIFrame = false );
// Requests loading of an object or embed element. Returns true if
// loading succeeded.
bool loadObjectElement( DOM::HTMLPartContainerElementImpl *frame, const QString &url, const QString &serviceType,
const QStringList &args = QStringList() );
// Tries an open a URL in given ChildFrame with all known navigation information
// like mimetype and the like in the KParts arguments.
//
// Returns true if it's done -- which excludes the case when it's still resolving
// the mimetype.
// ### refine comment wrt to error case
bool requestObject( khtml::ChildFrame *child, const KUrl &url,
const KParts::OpenUrlArguments &args = KParts::OpenUrlArguments(),
const KParts::BrowserArguments& browserArgs = KParts::BrowserArguments() );
// This method does the loading inside a ChildFrame once we know what mimetype to
// load it as
bool processObjectRequest( khtml::ChildFrame *child, const KUrl &url, const QString &mimetype );
// helper for reporting ChildFrame load failure
void childLoadFailure( khtml::ChildFrame *child );
// Updates the ChildFrame to use the particular part, hooking up the various
// signals, connections, etc.
void connectToChildPart( khtml::ChildFrame *child, KParts::ReadOnlyPart *part,
const QString &mimetype );
// Low-level navigation of the part itself --- this doesn't ask the user
// to save things or such, and assumes that all the ChildFrame info is already
// filed in with things like the mimetype and so on
//
// Returns if successful or not
bool navigateChild( khtml::ChildFrame *child, const KUrl& url );
// Helper for executing javascript: or about: protocols
bool navigateLocalProtocol( khtml::ChildFrame *child, KParts::ReadOnlyPart *part,
const KUrl& url );
DOM::EventListener *createHTMLEventListener( QString code, QString name, DOM::NodeImpl *node, bool svg = false );
DOM::HTMLDocumentImpl *docImpl() const;
DOM::DocumentImpl *xmlDocImpl() const;
khtml::ChildFrame *frame( const QObject *obj );
khtml::ChildFrame *recursiveFrameRequest( KHTMLPart *callingHtmlPart, const KUrl &url,
const KParts::OpenUrlArguments& args, const KParts::BrowserArguments &browserArgs,
bool callParent = true );
bool checkLinkSecurity( const KUrl &linkURL,const KLocalizedString &message = KLocalizedString(), const QString &button = QString() );
QVariant executeScript( const QString& filename, int baseLine, const DOM::Node &n, const QString& script );
KJSProxy *jScript();
KHTMLPart *opener();
long cacheId() const;
void setOpener( KHTMLPart *_opener );
bool openedByJS();
void setOpenedByJS( bool _openedByJS );
void checkEmitLoadEvent();
void emitLoadEvent();
bool initFindNode( bool selection, bool reverse, bool fromCursor );
/** extends the current selection to the given content-coordinates @p x, @p y
* @param x content x-coordinate
* @param y content y-coordinate
* @param absX absolute x-coordinate of @p innerNode
* @param absY absolute y-coordinate of @p innerNode
* @param innerNode node from which to start extending the selection. The
* caller has to ensure that the node has a renderer.
* @internal
*/
void extendSelectionTo(int x, int y, const DOM::Node &innerNode);
/** checks whether a selection is extended.
* @return @p true if a selection is extended by the mouse.
*/
bool isExtendingSelection() const;
KEncodingDetector *createDecoder();
QString defaultEncoding() const;
/** .html, .xhtml or .xml */
QString defaultExtension() const;
/** @internal
* generic zoom in
*/
void zoomIn(const int stepping[], int count);
/** @internal
* generic zoom out
*/
void zoomOut(const int stepping[], int count);
void incFontSize(const int stepping[], int count);
void decFontSize(const int stepping[], int count);
void emitCaretPositionChanged(const DOM::Position &pos);
void setDebugScript( bool enable );
void runAdFilter();
khtml::EditorContext *editorContext() const;
/**
* initialises the caret if it hasn't been used yet.
* @internal
*/
void initCaret();
/**
* Returns the selected part of the HTML.
*/
const DOM::Selection &caret() const;
/**
* Returns the drag caret of the HTML.
*/
const DOM::Selection &dragCaret() const;
/**
* Sets the current caret to the given selection.
*/
void setCaret(const DOM::Selection &, bool closeTyping=true);
/**
* Sets the current drag caret.
*/
void setDragCaret(const DOM::Selection &);
/**
* Clears the current selection.
*/
void clearSelection();
/**
* Invalidates the current selection.
*/
void invalidateSelection();
/**
* Controls the visibility of the selection.
*/
void setSelectionVisible(bool flag=true);
/**
* Paints the caret.
*/
void paintCaret(QPainter *p, const QRect &rect) const;
/**
* Paints the drag caret.
*/
void paintDragCaret(QPainter *p, const QRect &rect) const;
/**
* Returns selectedText without any leading or trailing whitespace,
* and with non-breaking-spaces turned into normal spaces.
*
* Note that hasSelection can return true and yet simplifiedSelectedText can be empty,
* e.g. when selecting a single space.
*/
QString simplifiedSelectedText() const;
bool handleMouseMoveEventDrag(khtml::MouseMoveEvent *event);
bool handleMouseMoveEventOver(khtml::MouseMoveEvent *event);
void handleMouseMoveEventSelection(khtml::MouseMoveEvent *event);
void handleMousePressEventSingleClick(khtml::MousePressEvent *event);
void handleMousePressEventDoubleClick(khtml::MouseDoubleClickEvent *event);
void handleMousePressEventTripleClick(khtml::MouseDoubleClickEvent *event);
KHTMLPartPrivate *d;
friend class KHTMLPartPrivate;
public: // So we don't end up having to add 50 more friends
/** @internal Access to internal APIs. Don't use outside */
KHTMLPartPrivate* impl() { return d; }
};
#endif
Reference in a new issue View git blame Copy permalink