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