WebCore/khtml/khtml_part.h

   1 // -*- c-basic-offset: 2 -*-
   2 /* This file is part of the KDE project
   3  *
   4  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
   5  *                     1999-2001 Lars Knoll <knoll@kde.org>
   6  *                     1999-2001 Antti Koivisto <koivisto@kde.org>
   7  *                     2000-2001 Simon Hausmann <hausmann@kde.org>
   8  *                     2000-2001 Dirk Mueller <mueller@kde.org>
   9  *                     2000 Stefan Schimanski <1Stein@gmx.de>
  10  * Copyright (C) 2004 Apple Computer, Inc.
  11  *
  12  * This library is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Library General Public
  14  * License as published by the Free Software Foundation; either
  15  * version 2 of the License, or (at your option) any later version.
  16  *
  17  * This library is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * Library General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Library General Public License
  23  * along with this library; see the file COPYING.LIB.  If not, write to
  24  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  25  * Boston, MA 02111-1307, USA.
  26  */
  27 #ifndef __khtml_part_h__
  28 #define __khtml_part_h__
  29
  30 #include "editing/text_granularity.h"
  31 #include "editing/edit_actions.h"
  32
  33 #include <kparts/part.h>
  34 #include <kparts/browserextension.h>
  35
  36 class KHTMLPartPrivate;
  37 class KHTMLPartBrowserExtension;
  38 class KJSProxy;
  39 class KHTMLView;
  40 class KHTMLSettings;
  41 class KJavaAppletContext;
  42
  43 namespace DOM
  44 {
  45   class CSSComputedStyleDeclarationImpl;
  46   class CSSMutableStyleDeclarationImpl;
  47   class CSSStyleDeclarationImpl;
  48   class DOMString;
  49   class Document;
  50   class DocumentImpl;
  51   class ElementImpl;
  52   class EventListener;
  53   class HTMLAnchorElementImpl;
  54   class HTMLDocument;
  55   class HTMLDocumentImpl;
  56   class HTMLElementImpl;
  57   class HTMLEventListener;
  58   class HTMLFormElementImpl;
  59   class HTMLFrameElementImpl;
  60   class HTMLIFrameElementImpl;
  61   class HTMLMetaElementImpl;
  62   class HTMLObjectElementImpl;
  63   class HTMLTitleElementImpl;
  64   class Node;
  65   class NodeImpl;
  66   class Range;
  67 }
  68
  69 namespace khtml
  70 {
  71   class CachedObject;
  72   struct ChildFrame;
  73   class CSSStyleSelector;
  74   class DocLoader;
  75   class DrawContentsEvent;
  76   class EditCommandPtr;
  77   class FormData;
  78   class HTMLTokenizer;
  79   class MouseDoubleClickEvent;
  80   class MouseEvent;
  81   class MouseMoveEvent;
  82   class MousePressEvent;
  83   class MouseReleaseEvent;
  84   class RenderPart;
  85   class RenderPartObject;
  86   class RenderWidget;
  87   class Selection;
  88   class XMLTokenizer;
  89 }
  90
  91 namespace KJS {
  92     class DOMDocument;
  93     class JSEventListener;
  94     class Selection;
  95     class SelectionFunc;
  96     class Window;
  97     class WindowFunc;
  98 }
  99
 100 namespace KParts
 101 {
 102   class PartManager;
 103 };
 104
 105 /**
 106  * This class is khtml's main class. It features an almost complete
 107  * web browser, and html renderer.
 108  *
 109  * The easiest way to use this class (if you just want to display an HTML
 110  * page at some URL) is the following:
 111  *
 112  * <pre>
 113  * KURL url = "http://www.kde.org";
 114  * KHTMLPart *w = new KHTMLPart();
 115  * w->openURL(url);
 116  * w->view()->resize(500, 400);
 117  * w->show();
 118  * </pre>
 119  *
 120  * By default Java and JavaScript support are disabled. You can enable them by
 121  * using the @ref setJavaEnabled() and @ref setJScriptEnabled() methods.
 122  *
 123  * Some apps want to write their HTML code directly into the widget instead of
 124  * it opening an url. You can also do that in the following way:
 125  *
 126  * <pre>
 127  * QString myHTMLCode = ...;
 128  * KHTMLPart *w = new KHTMLPart();
 129  * w->begin();
 130  * w->write(myHTMLCode);
 131  * ...
 132  * w->end();
 133  * </pre>
 134  *
 135  * You can do as many calls to write as you want. But there are two
 136  * @ref write() methods, one accepting a @ref QString one accepting a
 137  * @p char @p * argument. You should use one or the other
 138  * (but not both) since the method using
 139  * the @p char @p * argument does an additional decoding step to convert the
 140  * written data to Unicode.
 141  *
 142  * @short HTML Browser Widget
 143  * @author Lars Knoll (knoll@kde.org)
 144  * */
 145 class KHTMLPart : public KParts::ReadOnlyPart
 146 {
 147   Q_OBJECT
 148   friend class KHTMLView;
 149   friend class DOM::HTMLTitleElementImpl;
 150   friend class DOM::HTMLFrameElementImpl;
 151   friend class DOM::HTMLIFrameElementImpl;
 152   friend class DOM::HTMLObjectElementImpl;
 153   friend class DOM::HTMLAnchorElementImpl;
 154   friend class DOM::HTMLMetaElementImpl;
 155   friend class DOM::NodeImpl;
 156   friend class KHTMLRun;
 157   friend class DOM::HTMLFormElementImpl;
 158   friend class khtml::RenderPartObject;
 159   friend class KJS::Selection;
 160   friend class KJS::SelectionFunc;
 161   friend class KJS::Window;
 162   friend class KJS::WindowFunc;
 163   friend class KJS::JSEventListener;
 164   friend class KJS::DOMDocument;
 165   friend class KJSProxy;
 166   friend class KHTMLPartBrowserExtension;
 167   friend class DOM::DocumentImpl;
 168   friend class DOM::HTMLDocumentImpl;
 169   friend class KHTMLPartBrowserHostExtension;
 170   friend class khtml::HTMLTokenizer;
 171   friend class khtml::XMLTokenizer;
 172   friend class khtml::RenderWidget;
 173   friend class khtml::CSSStyleSelector;
 174   friend class KHTMLPartIface;
 175
 176   Q_PROPERTY( bool javaScriptEnabled READ jScriptEnabled WRITE setJScriptEnabled )
 177   Q_PROPERTY( bool javaEnabled READ javaEnabled WRITE setJavaEnabled )
 178   Q_PROPERTY( bool autoloadImages READ autoloadImages WRITE setAutoloadImages )
 179   Q_PROPERTY( bool dndEnabled READ dndEnabled WRITE setDNDEnabled )
 180   Q_PROPERTY( bool pluginsEnabled READ pluginsEnabled WRITE setPluginsEnabled )
 181   Q_PROPERTY( bool onlyLocalReferences READ onlyLocalReferences WRITE setOnlyLocalReferences )
 182   Q_PROPERTY( QCString dcopObjectId READ dcopObjectId )
 183
 184 public:
 185   enum GUIProfile { DefaultGUI, BrowserViewGUI /* ... */ };
 186   enum { NoXPosForVerticalArrowNavigation = INT_MIN };
 187
 188   /**
 189    * Constructs a new KHTMLPart.
 190    *
 191    * KHTML basically consists of two objects: The KHTMLPart itself,
 192    * holding the document data (DOM document), and the @ref KHTMLView,
 193    * derived from @ref QScrollView, in which the document content is
 194    * rendered in. You can specify two different parent objects for a
 195    * KHTMLPart, one parent for the KHTMLPart document and on parent
 196    * for the @ref KHTMLView. If the second @p parent argument is 0L, then
 197    * @p parentWidget is used as parent for both objects, the part and
 198    * the view.
 199    */
 200   KHTMLPart( QWidget *parentWidget = 0, const char *widgetname = 0,
 201              QObject *parent = 0, const char *name = 0, GUIProfile prof = DefaultGUI );
 202
 203   KHTMLPart( KHTMLView *view, QObject *parent = 0, const char *name = 0, GUIProfile prof = DefaultGUI );
 204
 205   /**
 206    * Destructor.
 207    */
 208   virtual ~KHTMLPart();
 209
 210   /**
 211    * Opens the specified URL @p url.
 212    *
 213    * Reimplemented from @ref KParts::ReadOnlyPart::openURL .
 214    */
 215   virtual bool openURL( const KURL &url );
 216
 217   void didExplicitOpen();
 218
 219   /**
 220    * Stops loading the document and kill all data requests (for images, etc.)
 221    */
 222   virtual bool closeURL();
 223
 224 #if !APPLE_CHANGES
 225   /**
 226    * is called when a certain error situation (i.e. connection timed out) occured.
 227    * default implementation either shows a KIO error dialog or loads a more verbose
 228    * error description a as page, depending on the users configuration.
 229    * @p job is the job that signaled the error situation
 230    */
 231   virtual void showError(KIO::Job* job);
 232 #endif
 233
 234   /**
 235    * Returns a reference to the DOM HTML document (for non-HTML documents, returns null)
 236    */
 237   DOM::HTMLDocument htmlDocument() const;
 238
 239   /**
 240    * Returns a reference to the DOM document.
 241    */
 242   DOM::Document document() const;
 243
 244   /**
 245    * Returns the node that has the keyboard focus.
 246    */
 247   DOM::Node activeNode() const;
 248
 249   /**
 250    * Returns a pointer to the @ref KParts::BrowserExtension.
 251    */
 252   KParts::BrowserExtension *browserExtension() const;
 253
 254   /**
 255    * Returns a pointer to the HTML document's view.
 256    */
 257   KHTMLView *view() const;
 258
 259   /**
 260    * Enable/disable Javascript support. Note that this will
 261    * in either case permanently override the default usersetting.
 262    * If you want to have the default UserSettings, don't call this
 263    * method.
 264    */
 265   void setJScriptEnabled( bool enable );
 266
 267   /**
 268    * Returns @p true if Javascript support is enabled or @p false
 269    * otherwise.
 270    */
 271   bool jScriptEnabled() const;
 272
 273   /**
 274    * Enable/disable the automatic forwarding by <meta http-equiv="refresh" ....>
 275    */
 276   void setMetaRefreshEnabled( bool enable );
 277
 278   /**
 279    * Returns @p true if automtaic forwarding is enabled.
 280    */
 281   bool metaRefreshEnabled() const;
 282
 283   /**
 284    * Execute the specified snippet of JavaScript code.
 285    *
 286    * Returns @p true if JavaScript was enabled, no error occured
 287    * and the code returned true itself or @p false otherwise.
 288    * @deprecated, use the one below.
 289    */
 290   QVariant executeScript( const QString &script, bool forceUserGesture = false );
 291   /**
 292    * Same as above except the Node parameter specifying the 'this' value.
 293    */
 294   QVariant executeScript( const DOM::Node &n, const QString &script, bool forceUserGesture = false );
 295
 296   /**
 297    * Enables or disables Drag'n'Drop support. A drag operation is started if
 298    * the users drags a link.
 299    */
 300   void setDNDEnabled( bool b );
 301   /**
 302    * Returns whether Dragn'n'Drop support is enabled or not.
 303    */
 304   bool dndEnabled() const;
 305
 306   /**
 307    * Implementation of CSS property -khtml-user-drag == auto
 308    */
 309   virtual bool shouldDragAutoNode(DOM::NodeImpl*, int x, int y) const;
 310
 311   /**
 312    * Enables/disables Java applet support. Note that calling this function
 313    * will permanently override the User settings about Java applet support.
 314    * Not calling this function is the only way to let the default settings
 315    * apply.
 316    */
 317   void setJavaEnabled( bool enable );
 318
 319   /**
 320    * Return if Java applet support is enabled/disabled.
 321    */
 322   bool javaEnabled() const;
 323
 324   /**
 325    * Returns the java context of the applets. If no applet exists, 0 is returned.
 326    */
 327   KJavaAppletContext *javaContext();
 328
 329   /**
 330    * Returns the java context of the applets. If no context exists yet, a new one is
 331    * created.
 332    */
 333   KJavaAppletContext *createJavaContext();
 334
 335   /**
 336    * Enables or disables plugins via, default is enabled
 337    */
 338   void setPluginsEnabled( bool enable );
 339
 340   /**
 341    * Returns trie if plugins are enabled/disabled.
 342    */
 343   bool pluginsEnabled() const;
 344
 345   /**
 346    * Specifies whether images contained in the document should be loaded
 347    * automatically or not.
 348    *
 349    * @note Request will be ignored if called before @ref begin().
 350    */
 351   void setAutoloadImages( bool enable );
 352   /**
 353    * Returns whether images contained in the document are loaded automatically
 354    * or not.
 355    * @note that the returned information is unrelieable as long as no begin()
 356    * was called.
 357    */
 358   bool autoloadImages() const;
 359
 360   /**
 361    * Security option.
 362    *
 363    * Specify whether only local references ( stylesheets, images, scripts, subdocuments )
 364    * should be loaded. ( default false - everything is loaded, if the more specific
 365    * options allow )
 366    */
 367   void setOnlyLocalReferences(bool enable);
 368
 369   /**
 370    * Returns whether references should be loaded ( default false )
 371    **/
 372   bool onlyLocalReferences() const;
 373
 374 #ifndef KDE_NO_COMPAT
 375   void enableJScript(bool e) { setJScriptEnabled(e); }
 376   void enableJava(bool e) { setJavaEnabled(e); }
 377   void enablePlugins(bool e) { setPluginsEnabled(e); }
 378   void autoloadImages(bool e) { setAutoloadImages(e); }
 379   void enableMetaRefresh(bool e) { setMetaRefreshEnabled(e); }
 380   bool setCharset( const QString &, bool ) { return true; }
 381
 382   KURL baseURL() const;
 383   QString baseTarget() const;
 384 #endif
 385
 386   /**
 387    * Returns the URL for the background Image (used by save background)
 388    */
 389   KURL backgroundURL() const;
 390
 391   /**
 392    * Schedules a redirection after @p delay seconds.
 393    */
 394   void scheduleRedirection(double delay, const QString &url, bool lockHistory = true);
 395
 396   /**
 397    * Schedules a location change.
 398    * This is used for JavaScript-triggered location changes.
 399    */
 400   void scheduleLocationChange(const QString &url, bool lockHistory = true, bool userGesture = false);
 401   bool isScheduledLocationChangePending() const;
 402
 403   /**
 404    * Schedules a history navigation operation (go forward, go back, etc.).
 405    * This is used for JavaScript-triggered location changes.
 406    */
 407   void scheduleHistoryNavigation( int steps );
 408
 409   /**
 410    * Clears the widget and prepares it for new content.
 411    *
 412    * If you want @ref url() to return
 413    * for example "file:/tmp/test.html", you can use the following code:
 414    * <PRE>
 415    * view->begin( KURL("file:/tmp/test.html" ) );
 416    * </PRE>
 417    *
 418    * @param url is the url of the document to be displayed.  Even if you
 419    * are generating the HTML on the fly, it may be useful to specify
 420    * a directory so that any pixmaps are found.
 421    *
 422    * @param xOffset is the initial horizontal scrollbar value. Usually
 423    * you don't want to use this.
 424    *
 425    * @param yOffset is the initial vertical scrollbar value. Usually
 426    * you don't want to use this.
 427    *
 428    * All child frames and the old document are removed if you call
 429    * this method.
 430    */
 431   virtual void begin( const KURL &url = KURL(), int xOffset = 0, int yOffset = 0 );
 432
 433   /**
 434    * Writes another part of the HTML code to the widget.
 435    *
 436    * You may call
 437    * this function many times in sequence. But remember: The fewer calls
 438    * you make, the faster the widget will be.
 439    *
 440    * The HTML code is send through a decoder which decodes the stream to
 441    * Unicode.
 442    *
 443    * The @p len parameter is needed for streams encoded in utf-16,
 444    * since these can have \0 chars in them. In case the encoding
 445    * you're using isn't utf-16, you can safely leave out the length
 446    * parameter.
 447    *
 448    * Attention: Don't mix calls to @ref write( const char *) with calls
 449    * to @ref write( const QString & ).
 450    *
 451    * The result might not be what you want.
 452    */
 453   virtual void write( const char *str, int len = -1 );
 454
 455   /**
 456    * Writes another part of the HTML code to the widget.
 457    *
 458    * You may call
 459    * this function many times in sequence. But remember: The fewer calls
 460    * you make, the faster the widget will be.
 461    */
 462   virtual void write( const QString &str );
 463
 464   /**
 465    * Call this after your last call to @ref write().
 466    */
 467   virtual void end();
 468
 469   void endIfNotLoading();
 470
 471   /**
 472    * Similar to end, but called to abort a load rather than cleanly end.
 473    */
 474   void stop();
 475
 476   /*
 477    * Prints the current HTML page layed out for the printer.
 478    *
 479    * (not implemented at the moment)
 480    */
 481   //    void print(QPainter *, int pageHeight, int pageWidth);
 482
 483   /**
 484    * Paints the HTML page to a QPainter. See @ref KHTMLView::paint for details
 485    */
 486   void paint(QPainter *, const QRect &, int = 0, bool * = 0);
 487
 488   /**
 489    * Sets the encoding the page uses.
 490    *
 491    * This can be different from the charset. The widget will try to reload the current page in the new
 492    * encoding, if url() is not empty.
 493    */
 494   bool setEncoding( const QString &name, bool override = false );
 495
 496   /**
 497    * Returns the encoding the page currently uses.
 498    *
 499    * Note that the encoding might be different from the charset.
 500    */
 501   QString encoding() const;
 502
 503   /**
 504    * Sets a user defined style sheet to be used on top of the HTML 4
 505    * default style sheet.
 506    *
 507    * This gives a wide range of possibilities to
 508    * change the layout of the page.
 509    */
 510   void setUserStyleSheet(const KURL &url);
 511
 512   /**
 513    * Sets a user defined style sheet to be used on top of the HTML 4
 514    * default style sheet.
 515    *
 516    * This gives a wide range of possibilities to
 517    * change the layout of the page.
 518    */
 519   void setUserStyleSheet(const QString &styleSheet);
 520
 521 public:
 522
 523   /**
 524    * Sets the standard font style.
 525    *
 526    * @param name The font name to use for standard text.
 527    */
 528   void setStandardFont( const QString &name );
 529
 530   /**
 531    * Sets the fixed font style.
 532    *
 533    * @param name The font name to use for fixed text, e.g.
 534    * the <tt>&lt;pre&gt;</tt> tag.
 535    */
 536   void setFixedFont( const QString &name );
 537
 538   /**
 539    * Finds the anchor named @p name.
 540    *
 541    * If the anchor is found, the widget
 542    * scrolls to the closest position. Returns @p if the anchor has
 543    * been found.
 544    */
 545   bool gotoAnchor( const QString &name );
 546
 547   /**
 548    * Sets the cursor to use when the cursor is on a link.
 549    */
 550   void setURLCursor( const QCursor &c );
 551
 552   /**
 553    * Returns the cursor which is used when the cursor is on a link.
 554    */
 555   QCursor urlCursor() const;
 556
 557   /**
 558    * Initiates a text search.
 559    */
 560   void findTextBegin(DOM::NodeImpl *startNode = 0, int startPos = -1);
 561
 562   /**
 563    * Finds the next occurrence of the string or expression.
 564    * If isRegExp is true then str is converted to a QRegExp, and caseSensitive is ignored.
 565    */
 566   bool findTextNext( const QString &str, bool forward, bool caseSensitive, bool isRegExp );
 567
 568   /**
 569    * Sets the Zoom factor. The value is given in percent, larger values mean a
 570    * generally larger font and larger page contents. It is not guaranteed that
 571    * all parts of the page are scaled with the same factor though.
 572    *
 573    * The given value should be in the range of 20..300, values outside that
 574    * range are not guaranteed to work. A value of 100 will disable all zooming
 575    * and show the page with the sizes determined via the given lengths in the
 576    * stylesheets.
 577    */
 578   void setZoomFactor(int percent);
 579
 580   /**
 581    * Returns the current zoom factor.
 582    */
 583   int zoomFactor() const;
 584
 585   /**
 586    * Returns the text the user has marked.
 587    */
 588   virtual QString selectedText() const;
 589
 590   /**
 591    * Returns the selected part of the HTML.
 592    */
 593   const khtml::Selection &selection() const;
 594
 595   /**
 596    * Returns the granularity of the selection (character, word, line, paragraph).
 597    */
 598   khtml::ETextGranularity selectionGranularity() const;
 599
 600   /**
 601    * Sets the granularity of the selection (character, word, line, paragraph).
 602    */
 603   void KHTMLPart::setSelectionGranularity(khtml::ETextGranularity granularity) const;
 604
 605   /**
 606    * Returns the drag caret of the HTML.
 607    */
 608   const khtml::Selection &dragCaret() const;
 609
 610   /**
 611    * Sets the current selection.
 612    */
 613   void setSelection(const khtml::Selection &, bool closeTyping = true, bool keepTypingStyle = false);
 614
 615   /**
 616    * Returns a mark, to be used as emacs uses it.
 617    */
 618   const khtml::Selection &mark() const;
 619
 620   /**
 621    * Returns the mark.
 622    */
 623   void setMark(const khtml::Selection &);
 624
 625   /**
 626    * Sets the current drag cart.
 627    */
 628   void setDragCaret(const khtml::Selection &);
 629
 630   /**
 631    * Clears the current selection.
 632    */
 633   void clearSelection();
 634
 635   /**
 636    * Invalidates the current selection.
 637    */
 638   void invalidateSelection();
 639
 640   /**
 641    * Controls the visibility of the selection.
 642    */
 643   void setCaretVisible(bool flag=true);
 644
 645   /**
 646    * Paints the caret.
 647    */
 648   void paintCaret(QPainter *p, const QRect &rect) const;
 649
 650  /**
 651    * Paints the drag caret.
 652    */
 653   void paintDragCaret(QPainter *p, const QRect &rect) const;
 654
 655   /**
 656    * Set info for vertical arrow navigation.
 657    */
 658   void setXPosForVerticalArrowNavigation(int x);
 659
 660   /**
 661    * Get info for vertical arrow navigation.
 662    */
 663   int xPosForVerticalArrowNavigation() const;
 664
 665   /**
 666    * Returns the text for a part of the document.
 667    */
 668   QString text(const DOM::Range &) const;
 669
 670   /**
 671    * Has the user selected anything?
 672    *
 673    *  Call @ref selectedText() to
 674    * retrieve the selected text.
 675    *
 676    * @return @p true if there is text selected.
 677    */
 678   bool hasSelection() const;
 679
 680   /**
 681    * Marks all text in the document as selected.
 682    */
 683   void selectAll();
 684
 685   /**
 686    * Returns whether editing should end in the given range
 687    */
 688   virtual bool shouldBeginEditing(const DOM::Range &) const;
 689
 690   /**
 691    * Returns whether editing should end in the given range
 692    */
 693   virtual bool shouldEndEditing(const DOM::Range &) const;
 694
 695   /**
 696    * Returns the contentEditable "override" value for the part
 697    */
 698   virtual bool isContentEditable() const;
 699
 700   /**
 701    * Returns the most recent edit command applied.
 702    */
 703   khtml::EditCommandPtr lastEditCommand();
 704
 705   /**
 706    * Called when editing has been applied.
 707    */
 708   void appliedEditing(khtml::EditCommandPtr &);
 709
 710   /**
 711    * Called when editing has been unapplied.
 712    */
 713   void unappliedEditing(khtml::EditCommandPtr &);
 714
 715   /**
 716    * Called when editing has been reapplied.
 717    */
 718   void reappliedEditing(khtml::EditCommandPtr &);
 719
 720   /**
 721    * Returns the typing style for the document.
 722    */
 723   DOM::CSSMutableStyleDeclarationImpl *typingStyle() const;
 724
 725   /**
 726    * Sets the typing style for the document.
 727    */
 728   void setTypingStyle(DOM::CSSMutableStyleDeclarationImpl *);
 729
 730   /**
 731    * Clears the typing style for the document.
 732    */
 733   void clearTypingStyle();
 734
 735   /**
 736    * Convenience method to show the document's view.
 737    *
 738    * Equivalent to widget()->show() or view()->show() .
 739    */
 740   void show();
 741
 742   /**
 743    * Convenience method to hide the document's view.
 744    *
 745    * Equivalent to widget()->hide() or view()->hide().
 746    */
 747   void hide();
 748
 749   /**
 750    * Returns a reference to the partmanager instance which
 751    * manages html frame objects.
 752    */
 753   KParts::PartManager *partManager();
 754
 755 #if !APPLE_CHANGES
 756   /**
 757    * Saves the KHTMLPart's complete state (including child frame
 758    * objects) to the provided @ref QDataStream.
 759    *
 760    * This is called from the @ref saveState() method of the
 761    *  @ref browserExtension().
 762    */
 763   virtual void saveState( QDataStream &stream );
 764   /**
 765    * Restores the KHTMLPart's previously saved state (including
 766    * child frame objects) from the provided QDataStream.
 767    *
 768    * @see saveState()
 769    *
 770    * This is called from the @ref restoreState() method of the
 771    * @ref browserExtension() .
 772    **/
 773   virtual void restoreState( QDataStream &stream );
 774 #endif
 775
 776   virtual void tokenizerProcessedData() {};
 777
 778   /**
 779    * Returns the @p Node currently under the mouse
 780    */
 781   DOM::Node nodeUnderMouse() const;
 782
 783   /**
 784    * @internal
 785    */
 786   const KHTMLSettings *settings() const;
 787
 788   /**
 789    * Returns a pointer to the parent KHTMLPart if the part is a frame
 790    * in an HTML frameset.
 791    *
 792    *  Returns 0L otherwise.
 793    */
 794   KHTMLPart *parentPart() const;
 795
 796   /**
 797    * Returns a list of names of all frame (including iframe) objects of
 798    * the current document. Note that this method is not working recursively
 799    * for sub-frames.
 800    */
 801   QStringList frameNames() const;
 802
 803   QPtrList<KParts::ReadOnlyPart> frames() const;
 804
 805   KHTMLPart *childFrameNamed(const QString &name) const;
 806
 807   /**
 808    * Finds a frame by name. Returns 0L if frame can't be found.
 809    */
 810   KHTMLPart *findFrame( const QString &f );
 811
 812   /**
 813    * Return the current frame (the one that has focus)
 814    * Not necessarily a direct child of ours, framesets can be nested.
 815    * Returns "this" if this part isn't a frameset.
 816    */
 817   KParts::ReadOnlyPart *currentFrame() const;
 818
 819   /**
 820    * Returns whether a frame with the specified name is exists or not.
 821    * In contrary to the @ref findFrame method this one also returns true
 822    * if the frame is defined but no displaying component has been
 823    * found/loaded, yet.
 824    */
 825   bool frameExists( const QString &frameName );
 826
 827
 828   /**
 829    * Called by KJS.
 830    * Sets the StatusBarText assigned
 831    * via window.status
 832    */
 833   void setJSStatusBarText( const QString &text );
 834
 835   /**
 836    * Called by KJS.
 837    * Sets the DefaultStatusBarText assigned
 838    * via window.defaultStatus
 839    */
 840   void setJSDefaultStatusBarText( const QString &text );
 841
 842   /**
 843    * Called by KJS.
 844    * Returns the StatusBarText assigned
 845    * via window.status
 846    */
 847   QString jsStatusBarText() const;
 848
 849   /**
 850    * Called by KJS.
 851    * Returns the DefaultStatusBarText assigned
 852    * via window.defaultStatus
 853    */
 854   QString jsDefaultStatusBarText() const;
 855
 856   /**
 857    * Referrer used for links in this page.
 858    */
 859   QString referrer() const;
 860
 861   /**
 862    * Last-modified date (in raw string format), if received in the [HTTP] headers.
 863    */
 864   QString lastModified() const;
 865
 866   /**
 867    * Loads a style sheet into the stylesheet cache.
 868    */
 869   void preloadStyleSheet(const QString &url, const QString &stylesheet);
 870
 871   /**
 872    * Loads a script into the script cache.
 873    */
 874   void preloadScript(const QString &url, const QString &script);
 875
 876   bool isPointInsideSelection(int x, int y);
 877
 878   virtual bool tabsToLinks() const;
 879   virtual bool tabsToAllControls() const;
 880
 881   /**
 882    * @internal
 883    */
 884   bool restored() const;
 885
 886   void incrementFrameCount();
 887   void decrementFrameCount();
 888   int topLevelFrameCount();
 889
 890   // Editing operations.
 891   // Not clear if these will be wanted in KHTMLPart by KDE,
 892   // but for now these bridge so we don't have to pepper the
 893   // KHTML code with WebCore-specific stuff.
 894   enum TriState { falseTriState, trueTriState, mixedTriState };
 895   void copyToPasteboard();
 896   void cutToPasteboard();
 897   void pasteFromPasteboard();
 898   bool canPaste() const;
 899   void redo();
 900   void undo();
 901   bool canRedo() const;
 902   bool canUndo() const;
 903   void computeAndSetTypingStyle(DOM::CSSStyleDeclarationImpl *, khtml::EditAction editingAction=khtml::EditActionUnspecified);
 904   void applyStyle(DOM::CSSStyleDeclarationImpl *, khtml::EditAction editingAction=khtml::EditActionUnspecified);
 905   void applyParagraphStyle(DOM::CSSStyleDeclarationImpl *, khtml::EditAction editingAction=khtml::EditActionUnspecified);
 906   TriState selectionHasStyle(DOM::CSSStyleDeclarationImpl *) const;
 907   bool selectionStartHasStyle(DOM::CSSStyleDeclarationImpl *) const;
 908   DOM::DOMString selectionStartStylePropertyValue(int stylePropertyID) const;
 909   void applyEditingStyleToBodyElement() const;
 910   void removeEditingStyleFromBodyElement() const;
 911   void applyEditingStyleToElement(DOM::ElementImpl *) const;
 912   void removeEditingStyleFromElement(DOM::ElementImpl *) const;
 913   void print();
 914   virtual bool isCharacterSmartReplaceExempt(const QChar &, bool);
 915
 916   // Used to keep the part alive when running a script that might destroy it.
 917   void keepAlive();
 918
 919 signals:
 920   /**
 921    * Emitted if the cursor is moved over an URL.
 922    */
 923   void onURL( const QString &url );
 924
 925   /**
 926    * Emitted when the user clicks the right mouse button on the document.
 927    */
 928   void popupMenu(const QString &url, const QPoint &point);
 929
 930   /**
 931    * This signal is emitted when the selection changes.
 932    */
 933   void selectionChanged();
 934
 935   /**
 936    * This signal is emitted when an element retrieves the
 937    * keyboard focus. Note that the signal argument can be
 938    * a null node if no element is active, meaning a node
 939    * has explicitly been deactivated without a new one
 940    * becoming active.
 941    */
 942   void nodeActivated(const DOM::Node &);
 943
 944 public:
 945
 946   /**
 947    * returns a KURL object for the given url. Use when
 948    * you know what you're doing.
 949    */
 950   KURL completeURL( const QString &url );
 951
 952 protected:
 953
 954   /**
 955    * presents a detailed error message to the user.
 956    * @p errorCode kio error code, eg KIO::ERR_SERVER_TIMEOUT.
 957    * @p text kio additional information text.
 958    * @p url the url that triggered the error.
 959    */
 960   void htmlError(int errorCode, const QString& text, const KURL& reqUrl);
 961
 962   virtual void customEvent( QCustomEvent *event );
 963
 964   /**
 965    * Eventhandler of the khtml::MousePressEvent.
 966    */
 967   virtual void khtmlMousePressEvent( khtml::MousePressEvent *event );
 968   /**
 969    * Eventhandler for the khtml::MouseDoubleClickEvent.
 970    */
 971   virtual void khtmlMouseDoubleClickEvent( khtml::MouseDoubleClickEvent * );
 972
 973   /**
 974    * Eventhandler for the khtml::MouseDoubleMoveEvent.
 975    */
 976   virtual void khtmlMouseMoveEvent( khtml::MouseMoveEvent *event );
 977   /**
 978    * Eventhandler for the khtml::MouseMoveEvent.
 979    */
 980   virtual void khtmlMouseReleaseEvent( khtml::MouseReleaseEvent *event );
 981   /**
 982    * Eventhandler for the khtml::DrawContentsEvent.
 983    */
 984   virtual void khtmlDrawContentsEvent( khtml::DrawContentsEvent * );
 985
 986   void selectClosestWordFromMouseEvent(QMouseEvent *mouse, DOM::Node &innerNode, int x, int y);
 987
 988 #if !APPLE_CHANGES
 989   /**
 990    * Internal reimplementation of KParts::Part::guiActivateEvent .
 991    */
 992   virtual void guiActivateEvent( KParts::GUIActivateEvent *event );
 993 #endif
 994
 995   /**
 996    * Internal empty reimplementation of @ref KParts::ReadOnlyPart::openFile .
 997    */
 998   virtual bool openFile();
 999
1000   virtual void urlSelected( const QString &url, int button, int state,
1001                             const QString &_target, KParts::URLArgs args = KParts::URLArgs());
1002
1003 #if !APPLE_CHANGES
1004   /**
1005    * This method is called when a new embedded object (include html frames) is to be created.
1006    * Reimplement it if you want to add support for certain embeddable objects without registering
1007    * them in the KDE wide registry system (KSyCoCa) . Another reason for re-implementing this
1008    * method could be if you want to derive from KTHMLPart and also want all html frame objects
1009    * to be a object of your derived type, in which case you should return a new instance for
1010    * the mimetype 'text/html' .
1011    */
1012   virtual KParts::ReadOnlyPart *createPart( QWidget *parentWidget, const char *widgetName,
1013                                             QObject *parent, const char *name,
1014                                             const QString &mimetype, QString &serviceName,
1015                                             QStringList &serviceTypes, const QStringList &params);
1016 #endif
1017
1018 public slots:
1019
1020   /**
1021    * Sets the focussed node of the document to the specified node. If the node is a form control, the control will
1022    * receive focus in the same way that it would if the user had clicked on it or tabbed to it with the keyboard. For
1023    * most other types of elements, there is no visul indiction of whether or not they are focussed.
1024    *
1025    * See @ref activeNode
1026    *
1027    * @param node The node to focus
1028    */
1029   void setActiveNode(const DOM::Node &node);
1030
1031   /**
1032    * Stops all animated images on the current and child pages
1033    */
1034   void stopAnimations();
1035
1036   QCString dcopObjectId() const;
1037
1038 private slots:
1039
1040   /**
1041    * @internal
1042    */
1043   void reparseConfiguration();
1044
1045   /**
1046    * @internal
1047    */
1048   void slotData( KIO::Job*, const QByteArray &data );
1049   /**
1050    * @internal
1051    */
1052   void slotRestoreData( const QByteArray &data );
1053   /**
1054    * @internal
1055    */
1056   void slotFinished( KIO::Job* );
1057   /**
1058    * @internal
1059    */
1060   void slotFinishedParsing();
1061   /**
1062    * @internal
1063    */
1064   void slotRedirect();
1065   /**
1066    * @internal
1067    */
1068   void slotRedirection(KIO::Job*, const KURL&);
1069   /**
1070    * @internal
1071    */
1072   void slotDebugDOMTree();
1073   /**
1074    * @internal
1075    */
1076   void slotDebugRenderTree();
1077 #if !APPLE_CHANGES
1078   /**
1079    * @internal
1080    */
1081   virtual void slotViewDocumentSource();
1082   /**
1083    * @internal
1084    */
1085   virtual void slotViewFrameSource();
1086   /**
1087    * @internal
1088    */
1089   virtual void slotSaveBackground();
1090   /**
1091    * @internal
1092    */
1093   virtual void slotSaveDocument();
1094   /**
1095    * @internal
1096    */
1097   virtual void slotSaveFrame();
1098   /**
1099    * @internal
1100    */
1101   virtual void slotSecurity();
1102   /**
1103    * @internal
1104    */
1105   virtual void slotSetEncoding();
1106
1107   /**
1108    * @internal
1109    */
1110   virtual void slotUseStylesheet();
1111
1112   virtual void slotFind();
1113   virtual void slotFindDone();
1114   virtual void slotFindDialogDestroyed();
1115 #endif
1116
1117   void slotIncZoom();
1118   void slotDecZoom();
1119
1120 #if APPLE_CHANGES
1121   void childBegin();
1122 #endif
1123
1124   void slotLoadImages();
1125
1126   /**
1127    * @internal
1128    */
1129   void submitFormAgain();
1130
1131   /**
1132    * @internal
1133    */
1134   void updateActions();
1135   /**
1136    * @internal
1137    */
1138   void slotPartRemoved( KParts::Part *part );
1139   /**
1140    * @internal
1141    */
1142   void slotActiveFrameChanged( KParts::Part *part );
1143   /**
1144    * @internal
1145    */
1146   void slotChildStarted( KIO::Job *job );
1147   /**
1148    * @internal
1149    */
1150   void slotChildCompleted();
1151   /**
1152    * @internal
1153    */
1154   void slotChildCompleted( bool );
1155   /**
1156    * @internal
1157    */
1158   void slotParentCompleted();
1159   /**
1160    * @internal
1161    */
1162   void slotChildURLRequest( const KURL &url, const KParts::URLArgs &args );
1163
1164   void slotLoaderRequestStarted( khtml::DocLoader*, khtml::CachedObject* obj);
1165   void slotLoaderRequestDone( khtml::DocLoader*, khtml::CachedObject *obj );
1166   void checkCompleted();
1167
1168   /**
1169    * @internal
1170    */
1171   void slotShowDocument( const QString &url, const QString &target );
1172
1173   /**
1174    * @internal
1175    */
1176   void slotAutoScroll();
1177
1178   void slotPrintFrame();
1179
1180   void slotSelectAll();
1181
1182   /**
1183    * @internal
1184    */
1185   void slotProgressUpdate();
1186
1187   /*
1188    * @internal
1189    */
1190   void slotJobPercent(KIO::Job*, unsigned long);
1191
1192   /*
1193    * @internal
1194    */
1195   void slotJobSpeed(KIO::Job*, unsigned long);
1196
1197   /**
1198    * @internal
1199    */
1200   void slotClearSelection();
1201
1202   void slotEndLifeSupport();
1203
1204 private:
1205
1206
1207   /**
1208    * @internal
1209    */
1210   bool restoreURL( const KURL &url );
1211
1212   /**
1213    * @internal
1214    */
1215   void clearCaretRectIfNeeded();
1216
1217   /**
1218    * @internal
1219    */
1220   void setFocusNodeIfNeeded();
1221
1222   /**
1223    * @internal
1224    */
1225   void selectionLayoutChanged();
1226
1227   /**
1228    * @internal
1229    */
1230   void emitSelectionChanged();
1231
1232   /**
1233    * @internal
1234    */
1235   void timerEvent(QTimerEvent *);
1236
1237   /**
1238    * @internal
1239    */
1240   bool openURLInFrame( const KURL &url, const KParts::URLArgs &urlArgs );
1241
1242   void startAutoScroll();
1243   void stopAutoScroll();
1244   void overURL( const QString &url, const QString &target, bool shiftPressed = false );
1245
1246   /**
1247    * @internal
1248    */
1249   bool processObjectRequest( khtml::ChildFrame *child, const KURL &url, const QString &mimetype );
1250
1251   /**
1252    * @internal
1253    */
1254   void submitForm( const char *action, const QString &url, const khtml::FormData &formData,
1255                    const QString &target, const QString& contentType = QString::null,
1256                    const QString& boundary = QString::null );
1257
1258   /**
1259    * @internal
1260    */
1261   void popupMenu( const QString &url );
1262
1263
1264   void init( KHTMLView *view, GUIProfile prof );
1265
1266   virtual void clear();
1267
1268   bool scheduleScript( const DOM::Node &n, const QString& script);
1269
1270   QVariant executeScheduledScript();
1271
1272   bool requestFrame( khtml::RenderPart *frame, const QString &url, const QString &frameName,
1273                      const QStringList &paramNames = QStringList(), const QStringList &paramValues = QStringList(), bool isIFrame = false );
1274
1275   /**
1276    * @internal returns a name for a frame without a name.
1277    * This function returns a sequence of names.
1278    * All names in a sequence are different but the sequence is
1279    * always the same.
1280    * The sequence is reset in clear().
1281    */
1282   QString requestFrameName();
1283
1284   bool requestObject( khtml::RenderPart *frame, const QString &url, const QString &serviceType,
1285                       const QStringList &paramNames = QStringList(), const QStringList &paramValues = QStringList()  );
1286
1287   bool requestObject( khtml::ChildFrame *child, const KURL &url, const KParts::URLArgs &args = KParts::URLArgs() );
1288
1289   DOM::EventListener *createHTMLEventListener( QString code );
1290
1291 public:
1292   DOM::DocumentImpl *xmlDocImpl() const;
1293   void replaceDocImpl(DOM::DocumentImpl* newDoc);
1294
1295 private:
1296   khtml::ChildFrame *childFrame( const QObject *obj );
1297
1298   khtml::ChildFrame *recursiveFrameRequest( const KURL &url, const KParts::URLArgs &args, bool callParent = true );
1299
1300   void connectChild(const khtml::ChildFrame *) const;
1301   void disconnectChild(const khtml::ChildFrame *) const;
1302
1303   bool checkLinkSecurity(const KURL &linkURL,const QString &message = QString::null, const QString &button = QString::null);
1304   QVariant executeScript(QString filename, int baseLine, const DOM::Node &n, const QString &script);
1305
1306   void cancelRedirection(bool newLoadInProgress = false);
1307
1308   KJSProxy *jScript();
1309
1310 #if APPLE_CHANGES
1311  public:
1312 #endif
1313   KHTMLPart *opener();
1314 #if APPLE_CHANGES
1315  private:
1316 #endif
1317   long cacheId() const;
1318   void setOpener(KHTMLPart *_opener);
1319   bool openedByJS();
1320   void setOpenedByJS(bool _openedByJS);
1321
1322   void checkEmitLoadEvent();
1323   void emitLoadEvent();
1324
1325   void receivedFirstData();
1326
1327   void replaceContentsWithScriptResult( const KURL &url );
1328
1329   bool handleMouseMoveEventDrag(khtml::MouseMoveEvent *event);
1330   bool handleMouseMoveEventOver(khtml::MouseMoveEvent *event);
1331   void handleMouseMoveEventSelection(khtml::MouseMoveEvent *event);
1332
1333   /**
1334    * @internal Extracts anchor and tries both encoded and decoded form.
1335    */
1336   void gotoAnchor();
1337
1338 #if APPLE_CHANGES
1339   void handleMousePressEventSingleClick(khtml::MousePressEvent *event);
1340   void handleMousePressEventDoubleClick(khtml::MousePressEvent *event);
1341   void handleMousePressEventTripleClick(khtml::MousePressEvent *event);
1342 #endif
1343
1344   DOM::CSSComputedStyleDeclarationImpl *selectionComputedStyle(DOM::NodeImpl *&nodeToRemove) const;
1345
1346   KHTMLPartPrivate *d;
1347   friend class KHTMLPartPrivate;
1348   friend class khtml::Selection;
1349
1350 #if APPLE_CHANGES
1351 public:
1352   friend class KWQKHTMLPart;
1353
1354   void completed();
1355   void completed(bool);
1356   bool didOpenURL(const KURL &);
1357   void setStatusBarText(const QString &);
1358   void started(KIO::Job *);
1359   void frameDetached();
1360   virtual void didFirstLayout() {}
1361 #endif
1362
1363   int frameCount;
1364 };
1365
1366 #if APPLE_CHANGES
1367 #include "KWQKHTMLPart.h"
1368 #endif
1369
1370 #endif