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