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