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