khtml_part.h

Go to the documentation of this file.

// -*- 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;
}

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 /* ... */ };

  enum DNSPrefetch {
       DNSPrefetchDisabled=0,
       DNSPrefetchEnabled,
       DNSPrefetchOnlyWWWAndSLD
  };

  KHTMLPart( QWidget *parentWidget = 0,
             QObject *parent = 0, GUIProfile prof = DefaultGUI );
  KHTMLPart( KHTMLView *view, QObject *parent = 0, GUIProfile prof = DefaultGUI );

  virtual ~KHTMLPart();

  virtual bool openUrl( const KUrl &url );

  virtual bool closeUrl();

  virtual void showError( KJob* job );

  DOM::HTMLDocument htmlDocument() const;

  DOM::Document document() const;

   QString documentSource() const;

  DOM::Node activeNode() const;

  KParts::BrowserExtension *browserExtension() const;
  KParts::BrowserHostExtension *browserHostExtension() const;

  KHTMLView *view() const;

  void setJScriptEnabled( bool enable );

  bool jScriptEnabled() const;

  KJS::Interpreter *jScriptInterpreter();

  void setStatusMessagesEnabled( bool enable );

  bool statusMessagesEnabled() const;

  void setMetaRefreshEnabled( bool enable );

  bool metaRefreshEnabled() const;

  QVariant executeScript( const DOM::Node &n, const QString &script );

  void setDNDEnabled( bool b );

  bool dndEnabled() const;

  void setJavaEnabled( bool enable );

  bool javaEnabled() const;

  void setPluginsEnabled( bool enable );

  bool pluginsEnabled() const;

  void setAutoloadImages( bool enable );
  bool autoloadImages() const;

  void setOnlyLocalReferences( bool enable );

  void setForcePermitLocalImages( bool enable );

  void setDNSPrefetch( DNSPrefetch pmode );

  DNSPrefetch dnsPrefetch() const;

  bool onlyLocalReferences() const;

  bool forcePermitLocalImages() const;

  bool isCaretMode() const;

  bool isEditable() const;

  void setCaretPosition(DOM::Node node, long offset, bool extendSelection = false);

  enum CaretDisplayPolicy {
      CaretVisible, 
      CaretInvisible, 
      CaretBlink 
  };

  CaretDisplayPolicy caretDisplayPolicyNonFocused() const;

  void setCaretDisplayPolicyNonFocused(CaretDisplayPolicy policy);

#ifndef KDE_NO_COMPAT
  KUrl baseURL() const;
#endif

  KUrl backgroundURL() const;

  void scheduleRedirection( int delay, const QString &url, bool lockHistory = true );

  virtual void begin( const KUrl &url = KUrl(), int xOffset = 0, int yOffset = 0 );

  virtual void write( const char *str, int len = -1 );

   // FIXME KDE5: always honour doctype, remove setAlwaysHonourDoctype()
  virtual void write( const QString &str );

  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);

  void paint( QPainter *, const QRect &, int = 0, bool * = 0 );

  bool setEncoding( const QString &name, bool override = false );

  QString encoding() const;

  void setUserStyleSheet( const KUrl &url );

  void setUserStyleSheet( const QString &styleSheet );

public:

  void setStandardFont( const QString &name );

  void setFixedFont( const QString &name );

  bool gotoAnchor( const QString &name );

  bool nextAnchor();

  bool prevAnchor();

  void setURLCursor( const QCursor &c );

  QCursor urlCursor() const;

  enum FindOptions
  {
    FindLinksOnly   = 1 * KFind::MinimumUserOption,
    FindNoPopups    = 2 * KFind::MinimumUserOption
    //FindIncremental = 4 * KFind::MinimumUserOption
  };

  void findText();

  void findText( const QString &str, long options, QWidget *parent = 0,
                 KFindDialog *findDialog = 0 );

  void findTextBegin();

  bool findTextNext( bool reverse = false );

  void setZoomFactor(int percent);

  int zoomFactor() const;

  void setFontScaleFactor(int percent);

  int fontScaleFactor() const;

  virtual QString selectedText() const;

  QString selectedTextAsHTML() const;

  DOM::Range selection() const;

  void selection(DOM::Node &startNode, long &startOffset,
        DOM::Node &endNode, long &endOffset) const;

  void setSelection( const DOM::Range & );

  bool hasSelection() const;

  DOM::Editor *editor() const;

  void selectAll();

  void show();

  void hide();

  KParts::PartManager *partManager();

  virtual void saveState( QDataStream &stream );
  virtual void restoreState( QDataStream &stream );

  DOM::Node nodeUnderMouse() const;

  DOM::Node nonSharedNodeUnderMouse() const;

  const KHTMLSettings *settings() const;

   // ### KDE5 make const
  KHTMLPart *parentPart();

  QStringList frameNames() const;

  QList<KParts::ReadOnlyPart*> frames() const;

  KHTMLPart *findFrame( const QString &f );

  KHTMLPart *findFrameParent( KParts::ReadOnlyPart *callingPart, const QString &f, khtml::ChildFrame **childFrame=0 );

  KParts::ReadOnlyPart *currentFrame() const;

  bool frameExists( const QString &frameName );

  KJSProxy *framejScript(KParts::ReadOnlyPart *framePart);

  KParts::ReadOnlyPart *findFramePart( const QString &f );
  void setJSStatusBarText( const QString &text );

  void setJSDefaultStatusBarText( const QString &text );

  QString jsStatusBarText() const;

  QString jsDefaultStatusBarText() const;

  QString referrer() const;

  QString pageReferrer() const;

  QString lastModified() const;

  void preloadStyleSheet( const QString &url, const QString &stylesheet );

  void preloadScript( const QString &url, const QString &script );

   bool isPointInsideSelection(int x, int y);

  bool restored() const;

   // ### KDE5 remove - fix write( const QString &str ) instead
  void setAlwaysHonourDoctype( bool b = true );

  // ### KDE5 remove me
  enum FormNotification { NoNotification = 0, Before, Only, Unused=255 };
  void setFormNotification(FormNotification fn);

  FormNotification formNotification() const;

  KUrl toplevelURL();

  bool isModified() const;

  void setSuppressedPopupIndicator( bool enable, KHTMLPart *originPart = 0 );

  bool inProgress() const;

Q_SIGNALS:
  void onURL( const QString &url );

  void popupMenu( const QString &url, const QPoint &point );

  void selectionChanged();

  void nodeActivated( const DOM::Node & );

  void docCreated();

  void caretPositionChanged(const DOM::Node &node, long offset);


  void formSubmitNotification(const char *action, const QString& url,
                  const QByteArray& formData, const QString& target,
                  const QString& contentType, const QString& boundary);

  void configurationChanged();


protected:

  KUrl completeURL( const QString &url );

  void htmlError( int errorCode, const QString& text, const KUrl& reqUrl );

  virtual void customEvent( QEvent *event );

  virtual void khtmlMousePressEvent( khtml::MousePressEvent *event );
  virtual void khtmlMouseDoubleClickEvent( khtml::MouseDoubleClickEvent * );
  virtual void khtmlMouseMoveEvent( khtml::MouseMoveEvent *event );
  virtual void khtmlMouseReleaseEvent( khtml::MouseReleaseEvent *event );
  virtual void khtmlDrawContentsEvent( khtml::DrawContentsEvent * );

  virtual void guiActivateEvent( KParts::GUIActivateEvent *event );

  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() );

  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 );

  virtual bool doOpenStream( const QString& mimeType );

  virtual bool doWriteStream( const QByteArray& data );

  virtual bool doCloseStream();

  virtual void timerEvent(QTimerEvent *);

  bool mayPrefetchHostname( const QString& name );

  void updateZoomFactor();

public Q_SLOTS:

  void setActiveNode( const DOM::Node &node );

  void stopAnimations();

  QVariant executeScript( const QString &script );

  void setCaretMode(bool enable);

  void setEditable(bool enable);

  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:

  virtual void slotFinished( KJob* );

protected:
  virtual void startingJob( KIO::Job * ) {}

private Q_SLOTS:

  void reparseConfiguration();

  void slotData( KIO::Job*, const QByteArray &data );
  void slotInfoMessage( KJob*, const QString& msg );
  void slotRestoreData( const QByteArray &data );
  void slotFinishedParsing();
  void slotRedirect();
  void slotRedirection( KIO::Job*, const KUrl& );
  void slotDebugScript();
  void slotDebugDOMTree();
  void slotDebugRenderTree();

  void slotDebugFrameTree();

  void slotStopAnimations();
  virtual void slotViewDocumentSource();
  virtual void slotViewFrameSource();
  void slotViewPageInfo();
  virtual void slotSaveBackground();
  virtual void slotSaveDocument();
  virtual void slotSaveFrame();
  virtual void slotSecurity();
  virtual void slotSetEncoding(const QString &);

  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);

  void submitFormAgain();

  void updateActions();
  void slotPartRemoved( KParts::Part *part );
  void slotActiveFrameChanged( KParts::Part *part );
  void slotChildStarted( KIO::Job *job );
  void slotChildCompleted();
  void slotChildCompleted( bool );
  void slotParentCompleted();
  void slotChildURLRequest( const KUrl &url, const KParts::OpenUrlArguments&, const KParts::BrowserArguments &args );
  void slotChildDocCreated();
  void slotRequestFocus( KParts::ReadOnlyPart * );
  void slotLoaderRequestStarted( khtml::DocLoader*, khtml::CachedObject* obj);
  void slotLoaderRequestDone( khtml::DocLoader*, khtml::CachedObject *obj );
  void checkCompleted();

  void slotAutoScroll();

  void slotPrintFrame();

  void slotSelectAll();

  void slotProgressUpdate();

  /*
   * @internal
   */
  void slotJobPercent( KJob*, unsigned long );

  /*
   * @internal
   */
  void slotJobDone( KJob* );

  /*
   * @internal
   */
  void slotUserSheetStatDone( KJob* );

  /*
   * @internal
   */
  void slotJobSpeed( KJob*, unsigned long );

  void slotClearSelection();

  void slotZoomView( int );

  void slotAutomaticDetectionLanguage(KEncodingDetector::AutoDetectScript scri);

  void slotToggleCaretMode();

  void suppressedPopupMenu();

  void togglePopupPassivePopup();

  void showSuppressedPopups();

  void launchJSConfigDialog();

  void launchJSErrorDialog();

  void removeJSErrorExtension();

  void disableJSErrorExtension();

  void jsErrorDialogContextMenu();

  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);

  KHTMLViewBar *pTopViewBar() const;

  KHTMLViewBar *pBottomViewBar() const;

  bool pFindTextNextInThisFrame( bool reverse );

  // ### 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);

  QString requestFrameName();

  // Requests loading of a frame or iframe element
  bool 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 );

  void extendSelectionTo(int x, int y, const DOM::Node &innerNode);
  bool isExtendingSelection() const;
  KEncodingDetector *createDecoder();
  QString defaultEncoding() const;

  QString defaultExtension() const;

  void zoomIn(const int stepping[], int count);
  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;

  void initCaret();

  const DOM::Selection &caret() const;

  const DOM::Selection &dragCaret() const;

  void setCaret(const DOM::Selection &, bool closeTyping=true);

  void setDragCaret(const DOM::Selection &);

  void clearSelection();

  void invalidateSelection();

  void setSelectionVisible(bool flag=true);

  void paintCaret(QPainter *p, const QRect &rect) const;

  void paintDragCaret(QPainter *p, const QRect &rect) const;

  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

  KHTMLPartPrivate* impl() { return d; }
};


#endif