// -*- 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->setJavaEnabled(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 javaEnabled READ javaEnabled WRITE setJavaEnabled )
  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/disables Java applet support. Note that calling this function
   * will permanently override the User settings about Java applet support.
   * Not calling this function is the only way to let the default settings
   * apply.
   */
  void setJavaEnabled( bool enable );

  /**
   * Return @p true if Java applet support is enabled, @p false if disabled
   */
  bool javaEnabled() 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 slotRestoreData( const QByteArray &data );
  /**
   * @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
