• Skip to content
  • Skip to link menu
  • KDE API Reference
  • kdelibs-4.14.3 API Reference
  • KDE Home
  • Contact Us
 

KHTML

  • home
  • ichiro
  • data
  • ssd
  • Momonga
  • trunk
  • pkgs
  • kdelibs
  • BUILD
  • kdelibs-4.14.3
  • khtml
khtml_part.cpp
Go to the documentation of this file.
1 /* This file is part of the KDE project
2  *
3  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
4  * 1999 Lars Knoll <knoll@kde.org>
5  * 1999 Antti Koivisto <koivisto@kde.org>
6  * 2000 Simon Hausmann <hausmann@kde.org>
7  * 2000 Stefan Schimanski <1Stein@gmx.de>
8  * 2001-2005 George Staikos <staikos@kde.org>
9  * 2001-2003 Dirk Mueller <mueller@kde.org>
10  * 2000-2005 David Faure <faure@kde.org>
11  * 2002 Apple Computer, Inc.
12  * 2010 Maksim Orlovich (maksim@kde.org)
13  *
14  * This library is free software; you can redistribute it and/or
15  * modify it under the terms of the GNU Library General Public
16  * License as published by the Free Software Foundation; either
17  * version 2 of the License, or (at your option) any later version.
18  *
19  * This library is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22  * Library General Public License for more details.
23  *
24  * You should have received a copy of the GNU Library General Public License
25  * along with this library; see the file COPYING.LIB. If not, write to
26  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
27  * Boston, MA 02110-1301, USA.
28  */
29 
30 //#define SPEED_DEBUG
31 #include "khtml_part.h"
32 
33 #include "ui_htmlpageinfo.h"
34 
35 #include "khtmlviewbar.h"
36 #include "khtml_pagecache.h"
37 
38 #include "dom/dom_string.h"
39 #include "dom/dom_element.h"
40 #include "dom/dom_exception.h"
41 #include "dom/html_document.h"
42 #include "dom/dom2_range.h"
43 #include "editing/editor.h"
44 #include "html/html_documentimpl.h"
45 #include "html/html_baseimpl.h"
46 #include "html/html_objectimpl.h"
47 #include "html/html_miscimpl.h"
48 #include "html/html_imageimpl.h"
49 #include "imload/imagemanager.h"
50 #include "rendering/render_text.h"
51 #include "rendering/render_frames.h"
52 #include "rendering/render_layer.h"
53 #include "rendering/render_position.h"
54 #include "misc/loader.h"
55 #include "misc/khtml_partaccessor.h"
56 #include "xml/dom2_eventsimpl.h"
57 #include "xml/dom2_rangeimpl.h"
58 #include "xml/xml_tokenizer.h"
59 #include "css/cssstyleselector.h"
60 using namespace DOM;
61 
62 #include "khtmlview.h"
63 #include <kparts/partmanager.h>
64 #include <kparts/browseropenorsavequestion.h>
65 #include <kacceleratormanager.h>
66 #include "ecma/kjs_proxy.h"
67 #include "ecma/kjs_window.h"
68 #include "ecma/kjs_events.h"
69 #include "khtml_settings.h"
70 #include "kjserrordlg.h"
71 
72 #include <kjs/function.h>
73 #include <kjs/interpreter.h>
74 
75 #include <sys/types.h>
76 #include <assert.h>
77 #include <unistd.h>
78 
79 #include <config.h>
80 
81 #include <kstandarddirs.h>
82 #include <kstringhandler.h>
83 #include <kio/job.h>
84 #include <kio/jobuidelegate.h>
85 #include <kio/global.h>
86 #include <kio/netaccess.h>
87 #include <kio/hostinfo_p.h>
88 #include <kprotocolmanager.h>
89 #include <kdebug.h>
90 #include <kicon.h>
91 #include <kiconloader.h>
92 #include <klocale.h>
93 #include <kmessagebox.h>
94 #include <kstandardaction.h>
95 #include <kstandardguiitem.h>
96 #include <kactioncollection.h>
97 #include <kfiledialog.h>
98 #include <kmimetypetrader.h>
99 #include <ktemporaryfile.h>
100 #include <kglobalsettings.h>
101 #include <ktoolinvocation.h>
102 #include <kauthorized.h>
103 #include <kparts/browserinterface.h>
104 #include <kparts/scriptableextension.h>
105 #include <kde_file.h>
106 #include <kactionmenu.h>
107 #include <ktoggleaction.h>
108 #include <kcodecaction.h>
109 #include <kselectaction.h>
110 
111 #include <ksslinfodialog.h>
112 #include <ksslsettings.h>
113 
114 #include <kfileitem.h>
115 #include <kurifilter.h>
116 #include <kstatusbar.h>
117 #include <kurllabel.h>
118 
119 #include <QtGui/QClipboard>
120 #include <QtGui/QToolTip>
121 #include <QtCore/QFile>
122 #include <QtCore/QMetaEnum>
123 #include <QtGui/QTextDocument>
124 #include <QtCore/QDate>
125 #include <QtNetwork/QSslCertificate>
126 
127 #include "khtmlpart_p.h"
128 #include "khtml_iface.h"
129 #include "kpassivepopup.h"
130 #include "kmenu.h"
131 #include "rendering/render_form.h"
132 #include <kwindowsystem.h>
133 #include <kconfiggroup.h>
134 
135 #include "ecma/debugger/debugwindow.h"
136 
137 // SVG
138 #include <svg/SVGDocument.h>
139 
140 bool KHTMLPartPrivate::s_dnsInitialised = false;
141 
142 // DNS prefetch settings
143 static const int sMaxDNSPrefetchPerPage = 42;
144 static const int sDNSPrefetchTimerDelay = 200;
145 static const int sDNSTTLSeconds = 400;
146 static const int sDNSCacheSize = 500;
147 
148 
149 namespace khtml {
150 
151  class PartStyleSheetLoader : public CachedObjectClient
152  {
153  public:
154  PartStyleSheetLoader(KHTMLPart *part, DOM::DOMString url, DocLoader* dl)
155  {
156  m_part = part;
157  m_cachedSheet = dl->requestStyleSheet(url, QString(), "text/css",
158  true /* "user sheet" */);
159  if (m_cachedSheet)
160  m_cachedSheet->ref( this );
161  }
162  virtual ~PartStyleSheetLoader()
163  {
164  if ( m_cachedSheet ) m_cachedSheet->deref(this);
165  }
166  virtual void setStyleSheet(const DOM::DOMString&, const DOM::DOMString &sheet, const DOM::DOMString &, const DOM::DOMString &/*mimetype*/)
167  {
168  if ( m_part )
169  m_part->setUserStyleSheet( sheet.string() );
170 
171  delete this;
172  }
173  virtual void error( int, const QString& ) {
174  delete this;
175  }
176  QPointer<KHTMLPart> m_part;
177  khtml::CachedCSSStyleSheet *m_cachedSheet;
178  };
179 }
180 
181 KHTMLPart::KHTMLPart( QWidget *parentWidget, QObject *parent, GUIProfile prof )
182 : KParts::ReadOnlyPart( parent )
183 {
184  d = 0;
185  KHTMLGlobal::registerPart( this );
186  setComponentData( KHTMLGlobal::componentData(), false );
187  init( new KHTMLView( this, parentWidget ), prof );
188 }
189 
190 KHTMLPart::KHTMLPart( KHTMLView *view, QObject *parent, GUIProfile prof )
191 : KParts::ReadOnlyPart( parent )
192 {
193  d = 0;
194  KHTMLGlobal::registerPart( this );
195  setComponentData( KHTMLGlobal::componentData(), false );
196  assert( view );
197  if (!view->part())
198  view->setPart( this );
199  init( view, prof );
200 }
201 
202 void KHTMLPart::init( KHTMLView *view, GUIProfile prof )
203 {
204  if ( prof == DefaultGUI )
205  setXMLFile( "khtml.rc" );
206  else if ( prof == BrowserViewGUI )
207  setXMLFile( "khtml_browser.rc" );
208 
209  d = new KHTMLPartPrivate(this, parent());
210 
211  d->m_view = view;
212 
213  if (!parentPart()) {
214  QWidget *widget = new QWidget( view->parentWidget() );
215  widget->setObjectName("khtml_part_widget");
216  QVBoxLayout *layout = new QVBoxLayout( widget );
217  layout->setContentsMargins( 0, 0, 0, 0 );
218  layout->setSpacing( 0 );
219  widget->setLayout( layout );
220 
221  d->m_topViewBar = new KHTMLViewBar( KHTMLViewBar::Top, d->m_view, widget );
222  d->m_bottomViewBar = new KHTMLViewBar( KHTMLViewBar::Bottom, d->m_view, widget );
223 
224  layout->addWidget( d->m_topViewBar );
225  layout->addWidget( d->m_view );
226  layout->addWidget( d->m_bottomViewBar );
227  setWidget( widget );
228  widget->setFocusProxy( d->m_view );
229  } else {
230  setWidget( view );
231  }
232 
233  d->m_guiProfile = prof;
234  d->m_extension = new KHTMLPartBrowserExtension( this );
235  d->m_extension->setObjectName( "KHTMLBrowserExtension" );
236  d->m_hostExtension = new KHTMLPartBrowserHostExtension( this );
237  d->m_statusBarExtension = new KParts::StatusBarExtension( this );
238  d->m_scriptableExtension = new KJS::KHTMLPartScriptable( this );
239  new KHTMLTextExtension( this );
240  new KHTMLHtmlExtension( this );
241  d->m_statusBarPopupLabel = 0L;
242  d->m_openableSuppressedPopups = 0;
243 
244  d->m_paLoadImages = 0;
245  d->m_paDebugScript = 0;
246  d->m_bMousePressed = false;
247  d->m_bRightMousePressed = false;
248  d->m_bCleared = false;
249 
250  if ( prof == BrowserViewGUI ) {
251  d->m_paViewDocument = new KAction( i18n( "View Do&cument Source" ), this );
252  actionCollection()->addAction( "viewDocumentSource", d->m_paViewDocument );
253  connect( d->m_paViewDocument, SIGNAL(triggered(bool)), this, SLOT(slotViewDocumentSource()) );
254  if (!parentPart()) {
255  d->m_paViewDocument->setShortcut( QKeySequence(Qt::CTRL + Qt::Key_U) );
256  }
257 
258  d->m_paViewFrame = new KAction( i18n( "View Frame Source" ), this );
259  actionCollection()->addAction( "viewFrameSource", d->m_paViewFrame );
260  connect( d->m_paViewFrame, SIGNAL(triggered(bool)), this, SLOT(slotViewFrameSource()) );
261  if (!parentPart()) {
262  d->m_paViewFrame->setShortcut( QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_U) );
263  }
264 
265  d->m_paViewInfo = new KAction( i18n( "View Document Information" ), this );
266  actionCollection()->addAction( "viewPageInfo", d->m_paViewInfo );
267  if (!parentPart()) {
268  d->m_paViewInfo->setShortcut( QKeySequence(Qt::CTRL+Qt::Key_I) );
269  }
270  connect( d->m_paViewInfo, SIGNAL(triggered(bool)), this, SLOT(slotViewPageInfo()) );
271 
272  d->m_paSaveBackground = new KAction( i18n( "Save &Background Image As..." ), this );
273  actionCollection()->addAction( "saveBackground", d->m_paSaveBackground );
274  connect( d->m_paSaveBackground, SIGNAL(triggered(bool)), this, SLOT(slotSaveBackground()) );
275 
276  d->m_paSaveDocument = actionCollection()->addAction( KStandardAction::SaveAs, "saveDocument",
277  this, SLOT(slotSaveDocument()) );
278  if ( parentPart() )
279  d->m_paSaveDocument->setShortcuts( KShortcut() ); // avoid clashes
280 
281  d->m_paSaveFrame = new KAction( i18n( "Save &Frame As..." ), this );
282  actionCollection()->addAction( "saveFrame", d->m_paSaveFrame );
283  connect( d->m_paSaveFrame, SIGNAL(triggered(bool)), this, SLOT(slotSaveFrame()) );
284  } else {
285  d->m_paViewDocument = 0;
286  d->m_paViewFrame = 0;
287  d->m_paViewInfo = 0;
288  d->m_paSaveBackground = 0;
289  d->m_paSaveDocument = 0;
290  d->m_paSaveFrame = 0;
291  }
292 
293  d->m_paSecurity = new KAction( i18n( "SSL" ), this );
294  actionCollection()->addAction( "security", d->m_paSecurity );
295  connect( d->m_paSecurity, SIGNAL(triggered(bool)), this, SLOT(slotSecurity()) );
296 
297  d->m_paDebugRenderTree = new KAction( i18n( "Print Rendering Tree to STDOUT" ), this );
298  actionCollection()->addAction( "debugRenderTree", d->m_paDebugRenderTree );
299  connect( d->m_paDebugRenderTree, SIGNAL(triggered(bool)), this, SLOT(slotDebugRenderTree()) );
300 
301  d->m_paDebugDOMTree = new KAction( i18n( "Print DOM Tree to STDOUT" ), this );
302  actionCollection()->addAction( "debugDOMTree", d->m_paDebugDOMTree );
303  connect( d->m_paDebugDOMTree, SIGNAL(triggered(bool)), this, SLOT(slotDebugDOMTree()) );
304 
305  KAction* paDebugFrameTree = new KAction( i18n( "Print frame tree to STDOUT" ), this );
306  actionCollection()->addAction( "debugFrameTree", paDebugFrameTree );
307  connect( paDebugFrameTree, SIGNAL(triggered(bool)), this, SLOT(slotDebugFrameTree()) );
308 
309  d->m_paStopAnimations = new KAction( i18n( "Stop Animated Images" ), this );
310  actionCollection()->addAction( "stopAnimations", d->m_paStopAnimations );
311  connect( d->m_paStopAnimations, SIGNAL(triggered(bool)), this, SLOT(slotStopAnimations()) );
312 
313  d->m_paSetEncoding = new KCodecAction( KIcon("character-set"), i18n( "Set &Encoding" ), this, true );
314  actionCollection()->addAction( "setEncoding", d->m_paSetEncoding );
315 // d->m_paSetEncoding->setDelayed( false );
316 
317  connect( d->m_paSetEncoding, SIGNAL(triggered(QString)), this, SLOT(slotSetEncoding(QString)));
318  connect( d->m_paSetEncoding, SIGNAL(triggered(KEncodingDetector::AutoDetectScript)), this, SLOT(slotAutomaticDetectionLanguage(KEncodingDetector::AutoDetectScript)));
319 
320  if ( KGlobal::config()->hasGroup( "HTML Settings" ) ) {
321  KConfigGroup config( KGlobal::config(), "HTML Settings" );
322 
323  d->m_autoDetectLanguage = static_cast<KEncodingDetector::AutoDetectScript>(config.readEntry( "AutomaticDetectionLanguage", /*static_cast<int>(language) */0));
324  if (d->m_autoDetectLanguage==KEncodingDetector::None) {
325  const QByteArray name = KGlobal::locale()->encoding().toLower();
326 // kWarning() << "00000000 ";
327  if (name.endsWith("1251")||name.startsWith("koi")||name=="iso-8859-5")
328  d->m_autoDetectLanguage=KEncodingDetector::Cyrillic;
329  else if (name.endsWith("1256")||name=="iso-8859-6")
330  d->m_autoDetectLanguage=KEncodingDetector::Arabic;
331  else if (name.endsWith("1257")||name=="iso-8859-13"||name=="iso-8859-4")
332  d->m_autoDetectLanguage=KEncodingDetector::Baltic;
333  else if (name.endsWith("1250")|| name=="ibm852" || name=="iso-8859-2" || name=="iso-8859-3" )
334  d->m_autoDetectLanguage=KEncodingDetector::CentralEuropean;
335  else if (name.endsWith("1253")|| name=="iso-8859-7" )
336  d->m_autoDetectLanguage=KEncodingDetector::Greek;
337  else if (name.endsWith("1255")|| name=="iso-8859-8" || name=="iso-8859-8-i" )
338  d->m_autoDetectLanguage=KEncodingDetector::Hebrew;
339  else if (name=="jis7" || name=="eucjp" || name=="sjis" )
340  d->m_autoDetectLanguage=KEncodingDetector::Japanese;
341  else if (name.endsWith("1254")|| name=="iso-8859-9" )
342  d->m_autoDetectLanguage=KEncodingDetector::Turkish;
343  else if (name.endsWith("1252")|| name=="iso-8859-1" || name=="iso-8859-15" )
344  d->m_autoDetectLanguage=KEncodingDetector::WesternEuropean;
345  else
346  d->m_autoDetectLanguage=KEncodingDetector::SemiautomaticDetection;
347 // kWarning() << "0000000end " << d->m_autoDetectLanguage << " " << KGlobal::locale()->encodingMib();
348  }
349  d->m_paSetEncoding->setCurrentAutoDetectScript(d->m_autoDetectLanguage);
350  }
351 
352  d->m_paUseStylesheet = new KSelectAction( i18n( "Use S&tylesheet"), this );
353  actionCollection()->addAction( "useStylesheet", d->m_paUseStylesheet );
354  connect( d->m_paUseStylesheet, SIGNAL(triggered(int)), this, SLOT(slotUseStylesheet()) );
355 
356  if ( prof == BrowserViewGUI ) {
357  d->m_paIncZoomFactor = new KHTMLZoomFactorAction( this, true, "format-font-size-more", i18n( "Enlarge Font" ), this );
358  actionCollection()->addAction( "incFontSizes", d->m_paIncZoomFactor );
359  connect(d->m_paIncZoomFactor, SIGNAL(triggered(bool)), SLOT(slotIncFontSizeFast()));
360  d->m_paIncZoomFactor->setWhatsThis( i18n( "<qt>Enlarge Font<br /><br />"
361  "Make the font in this window bigger. "
362  "Click and hold down the mouse button for a menu with all available font sizes.</qt>" ) );
363 
364  d->m_paDecZoomFactor = new KHTMLZoomFactorAction( this, false, "format-font-size-less", i18n( "Shrink Font" ), this );
365  actionCollection()->addAction( "decFontSizes", d->m_paDecZoomFactor );
366  connect(d->m_paDecZoomFactor, SIGNAL(triggered(bool)), SLOT(slotDecFontSizeFast()));
367  d->m_paDecZoomFactor->setWhatsThis( i18n( "<qt>Shrink Font<br /><br />"
368  "Make the font in this window smaller. "
369  "Click and hold down the mouse button for a menu with all available font sizes.</qt>" ) );
370  if (!parentPart()) {
371  // For framesets, this action also affects frames, so only
372  // the frameset needs to define a shortcut for the action.
373 
374  // TODO: Why also CTRL+=? Because of http://trolltech.com/developer/knowledgebase/524/?
375  // Nobody else does it...
376  d->m_paIncZoomFactor->setShortcut( KShortcut("CTRL++; CTRL+=") );
377  d->m_paDecZoomFactor->setShortcut( QKeySequence(Qt::CTRL + Qt::Key_Minus) );
378  }
379  }
380 
381  d->m_paFind = actionCollection()->addAction( KStandardAction::Find, "find", this, SLOT(slotFind()) );
382  d->m_paFind->setWhatsThis( i18n( "<qt>Find text<br /><br />"
383  "Shows a dialog that allows you to find text on the displayed page.</qt>" ) );
384 
385  d->m_paFindNext = actionCollection()->addAction( KStandardAction::FindNext, "findNext", this, SLOT(slotFindNext()) );
386  d->m_paFindNext->setWhatsThis( i18n( "<qt>Find next<br /><br />"
387  "Find the next occurrence of the text that you "
388  "have found using the <b>Find Text</b> function.</qt>" ) );
389 
390  d->m_paFindPrev = actionCollection()->addAction( KStandardAction::FindPrev, "findPrevious",
391  this, SLOT(slotFindPrev()) );
392  d->m_paFindPrev->setWhatsThis( i18n( "<qt>Find previous<br /><br />"
393  "Find the previous occurrence of the text that you "
394  "have found using the <b>Find Text</b> function.</qt>" ) );
395 
396  // These two actions aren't visible in the menus, but exist for the (configurable) shortcut
397  d->m_paFindAheadText = new KAction( i18n("Find Text as You Type"), this );
398  actionCollection()->addAction( "findAheadText", d->m_paFindAheadText );
399  d->m_paFindAheadText->setShortcuts( KShortcut( '/' ) );
400  d->m_paFindAheadText->setHelpText(i18n("This shortcut shows the find bar, for finding text in the displayed page. It cancels the effect of \"Find Links as You Type\", which sets the \"Find links only\" option."));
401  connect( d->m_paFindAheadText, SIGNAL(triggered(bool)), this, SLOT(slotFindAheadText()) );
402 
403  d->m_paFindAheadLinks = new KAction( i18n("Find Links as You Type"), this );
404  actionCollection()->addAction( "findAheadLink", d->m_paFindAheadLinks );
405  // The issue is that it sets the (sticky) option FindLinksOnly, so
406  // if you trigger this shortcut once by mistake, Esc and Ctrl+F will still have the option set.
407  // Better let advanced users configure a shortcut for this advanced option
408  //d->m_paFindAheadLinks->setShortcuts( KShortcut( '\'' ) );
409  d->m_paFindAheadLinks->setHelpText(i18n("This shortcut shows the find bar, and sets the option \"Find links only\"."));
410  connect( d->m_paFindAheadLinks, SIGNAL(triggered(bool)), this, SLOT(slotFindAheadLink()) );
411 
412  if ( parentPart() )
413  {
414  d->m_paFind->setShortcuts( KShortcut() ); // avoid clashes
415  d->m_paFindNext->setShortcuts( KShortcut() ); // avoid clashes
416  d->m_paFindPrev->setShortcuts( KShortcut() ); // avoid clashes
417  d->m_paFindAheadText->setShortcuts( KShortcut());
418  d->m_paFindAheadLinks->setShortcuts( KShortcut());
419  }
420 
421  d->m_paPrintFrame = new KAction( i18n( "Print Frame..." ), this );
422  actionCollection()->addAction( "printFrame", d->m_paPrintFrame );
423  d->m_paPrintFrame->setIcon( KIcon( "document-print-frame" ) );
424  connect( d->m_paPrintFrame, SIGNAL(triggered(bool)), this, SLOT(slotPrintFrame()) );
425  d->m_paPrintFrame->setWhatsThis( i18n( "<qt>Print Frame<br /><br />"
426  "Some pages have several frames. To print only a single frame, click "
427  "on it and then use this function.</qt>" ) );
428 
429  // Warning: The name selectAll is used hardcoded by some 3rd parties to remove the
430  // shortcut for selectAll so they do not get ambigous shortcuts. Renaming it
431  // will either crash or render useless that workaround. It would be better
432  // to use the name KStandardAction::name(KStandardAction::SelectAll) but we
433  // can't for the same reason.
434  d->m_paSelectAll = actionCollection()->addAction( KStandardAction::SelectAll, "selectAll",
435  this, SLOT(slotSelectAll()) );
436  if ( parentPart() ) // Only the frameset has the shortcut, but the slot uses the current frame.
437  d->m_paSelectAll->setShortcuts( KShortcut() ); // avoid clashes
438 
439  d->m_paToggleCaretMode = new KToggleAction(i18n("Toggle Caret Mode"), this );
440  actionCollection()->addAction( "caretMode", d->m_paToggleCaretMode );
441  d->m_paToggleCaretMode->setShortcut( QKeySequence(Qt::Key_F7) );
442  connect( d->m_paToggleCaretMode, SIGNAL(triggered(bool)), this, SLOT(slotToggleCaretMode()) );
443  d->m_paToggleCaretMode->setChecked(isCaretMode());
444  if (parentPart())
445  d->m_paToggleCaretMode->setShortcut(KShortcut()); // avoid clashes
446 
447  // set the default java(script) flags according to the current host.
448  d->m_bOpenMiddleClick = d->m_settings->isOpenMiddleClickEnabled();
449  d->m_bJScriptEnabled = d->m_settings->isJavaScriptEnabled();
450  setDebugScript( d->m_settings->isJavaScriptDebugEnabled() );
451  d->m_bJavaEnabled = d->m_settings->isJavaEnabled();
452  d->m_bPluginsEnabled = d->m_settings->isPluginsEnabled();
453 
454  // Set the meta-refresh flag...
455  d->m_metaRefreshEnabled = d->m_settings->isAutoDelayedActionsEnabled ();
456 
457  KHTMLSettings::KSmoothScrollingMode ssm = d->m_settings->smoothScrolling();
458  if (ssm == KHTMLSettings::KSmoothScrollingDisabled)
459  d->m_view->setSmoothScrollingModeDefault(KHTMLView::SSMDisabled);
460  else if (ssm == KHTMLSettings::KSmoothScrollingWhenEfficient)
461  d->m_view->setSmoothScrollingModeDefault(KHTMLView::SSMWhenEfficient);
462  else
463  d->m_view->setSmoothScrollingModeDefault(KHTMLView::SSMEnabled);
464 
465  if (d->m_bDNSPrefetchIsDefault && !onlyLocalReferences()) {
466  KHTMLSettings::KDNSPrefetch dpm = d->m_settings->dnsPrefetch();
467  if (dpm == KHTMLSettings::KDNSPrefetchDisabled)
468  d->m_bDNSPrefetch = DNSPrefetchDisabled;
469  else if (dpm == KHTMLSettings::KDNSPrefetchOnlyWWWAndSLD)
470  d->m_bDNSPrefetch = DNSPrefetchOnlyWWWAndSLD;
471  else
472  d->m_bDNSPrefetch = DNSPrefetchEnabled;
473  }
474 
475  if (!KHTMLPartPrivate::s_dnsInitialised && d->m_bDNSPrefetch != DNSPrefetchDisabled) {
476  KIO::HostInfo::setCacheSize( sDNSCacheSize );
477  KIO::HostInfo::setTTL( sDNSTTLSeconds );
478  KHTMLPartPrivate::s_dnsInitialised = true;
479  }
480 
481  // all shortcuts should only be active, when this part has focus
482  foreach ( QAction *action, actionCollection ()->actions () ) {
483  action->setShortcutContext ( Qt::WidgetWithChildrenShortcut );
484  }
485  actionCollection()->associateWidget(view);
486 
487  connect( view, SIGNAL(zoomView(int)), SLOT(slotZoomView(int)) );
488 
489  connect( this, SIGNAL(completed()),
490  this, SLOT(updateActions()) );
491  connect( this, SIGNAL(completed(bool)),
492  this, SLOT(updateActions()) );
493  connect( this, SIGNAL(started(KIO::Job*)),
494  this, SLOT(updateActions()) );
495 
496  // #### FIXME: the process wide loader is going to signal every part about every loaded object.
497  // That's quite inefficient. Should be per-document-tree somehow. Even signaling to
498  // child parts that a request from an ancestor has loaded is inefficent..
499  connect( khtml::Cache::loader(), SIGNAL(requestStarted(khtml::DocLoader*,khtml::CachedObject*)),
500  this, SLOT(slotLoaderRequestStarted(khtml::DocLoader*,khtml::CachedObject*)) );
501  connect( khtml::Cache::loader(), SIGNAL(requestDone(khtml::DocLoader*,khtml::CachedObject*)),
502  this, SLOT(slotLoaderRequestDone(khtml::DocLoader*,khtml::CachedObject*)) );
503  connect( khtml::Cache::loader(), SIGNAL(requestFailed(khtml::DocLoader*,khtml::CachedObject*)),
504  this, SLOT(slotLoaderRequestDone(khtml::DocLoader*,khtml::CachedObject*)) );
505 
506  connect ( &d->m_progressUpdateTimer, SIGNAL(timeout()), this, SLOT(slotProgressUpdate()) );
507 
508  findTextBegin(); //reset find variables
509 
510  connect( &d->m_redirectionTimer, SIGNAL(timeout()),
511  this, SLOT(slotRedirect()) );
512 
513  if (QDBusConnection::sessionBus().isConnected()) {
514  new KHTMLPartIface(this); // our "adaptor"
515  for (int i = 1; ; ++i)
516  if (QDBusConnection::sessionBus().registerObject(QString("/KHTML/%1/widget").arg(i), this))
517  break;
518  else if (i == 0xffff)
519  kFatal() << "Something is very wrong in KHTMLPart!";
520  }
521 
522  if (prof == BrowserViewGUI && !parentPart())
523  loadPlugins();
524 
525  // "khtml" catalog does not exist, our translations are in kdelibs.
526  // removing this catalog from KGlobal::locale() prevents problems
527  // with changing the language in applications at runtime -Thomas Reitelbach
528  // DF: a better fix would be to set the right catalog name in the KComponentData!
529  KGlobal::locale()->removeCatalog("khtml");
530 }
531 
532 KHTMLPart::~KHTMLPart()
533 {
534  kDebug(6050) << this;
535  KConfigGroup config( KGlobal::config(), "HTML Settings" );
536  config.writeEntry( "AutomaticDetectionLanguage", int(d->m_autoDetectLanguage) );
537 
538  if (d->m_manager) { // the PartManager for this part's children
539  d->m_manager->removePart(this);
540  }
541 
542  slotWalletClosed();
543  if (!parentPart()) { // only delete it if the top khtml_part closes
544  removeJSErrorExtension();
545  }
546 
547  stopAutoScroll();
548  d->m_redirectionTimer.stop();
549 
550  if (!d->m_bComplete)
551  closeUrl();
552 
553  disconnect( khtml::Cache::loader(), SIGNAL(requestStarted(khtml::DocLoader*,khtml::CachedObject*)),
554  this, SLOT(slotLoaderRequestStarted(khtml::DocLoader*,khtml::CachedObject*)) );
555  disconnect( khtml::Cache::loader(), SIGNAL(requestDone(khtml::DocLoader*,khtml::CachedObject*)),
556  this, SLOT(slotLoaderRequestDone(khtml::DocLoader*,khtml::CachedObject*)) );
557  disconnect( khtml::Cache::loader(), SIGNAL(requestFailed(khtml::DocLoader*,khtml::CachedObject*)),
558  this, SLOT(slotLoaderRequestDone(khtml::DocLoader*,khtml::CachedObject*)) );
559 
560  clear();
561  hide();
562 
563  if ( d->m_view )
564  {
565  d->m_view->m_part = 0;
566  }
567 
568  // Have to delete this here since we forward declare it in khtmlpart_p and
569  // at least some compilers won't call the destructor in this case.
570  delete d->m_jsedlg;
571  d->m_jsedlg = 0;
572 
573  if (!parentPart()) // only delete d->m_frame if the top khtml_part closes
574  delete d->m_frame;
575  else if (d->m_frame && d->m_frame->m_run) // for kids, they may get detached while
576  d->m_frame->m_run.data()->abort(); // resolving mimetype; cancel that if needed
577  delete d; d = 0;
578  KHTMLGlobal::deregisterPart( this );
579 }
580 
581 bool KHTMLPart::restoreURL( const KUrl &url )
582 {
583  kDebug( 6050 ) << url;
584 
585  d->m_redirectionTimer.stop();
586 
587  /*
588  * That's not a good idea as it will call closeUrl() on all
589  * child frames, preventing them from further loading. This
590  * method gets called from restoreState() in case of a full frameset
591  * restoral, and restoreState() calls closeUrl() before restoring
592  * anyway.
593  kDebug( 6050 ) << "closing old URL";
594  closeUrl();
595  */
596 
597  d->m_bComplete = false;
598  d->m_bLoadEventEmitted = false;
599  d->m_workingURL = url;
600 
601  // set the java(script) flags according to the current host.
602  d->m_bJScriptEnabled = KHTMLGlobal::defaultHTMLSettings()->isJavaScriptEnabled(url.host());
603  setDebugScript( KHTMLGlobal::defaultHTMLSettings()->isJavaScriptDebugEnabled() );
604  d->m_bJavaEnabled = KHTMLGlobal::defaultHTMLSettings()->isJavaEnabled(url.host());
605  d->m_bPluginsEnabled = KHTMLGlobal::defaultHTMLSettings()->isPluginsEnabled(url.host());
606 
607  setUrl(url);
608 
609  d->m_restoreScrollPosition = true;
610  disconnect(d->m_view, SIGNAL(finishedLayout()), this, SLOT(restoreScrollPosition()));
611  connect(d->m_view, SIGNAL(finishedLayout()), this, SLOT(restoreScrollPosition()));
612 
613  KHTMLPageCache::self()->fetchData( d->m_cacheId, this, SLOT(slotRestoreData(QByteArray)));
614 
615  emit started( 0L );
616 
617  return true;
618 }
619 
620 bool KHTMLPartPrivate::isLocalAnchorJump( const KUrl& url )
621 {
622  // kio_help actually uses fragments to identify different pages, so
623  // always reload with it.
624  if (url.protocol() == QLatin1String("help"))
625  return false;
626 
627  return url.hasRef() && url.equals( q->url(),
628  KUrl::CompareWithoutTrailingSlash | KUrl::CompareWithoutFragment | KUrl::AllowEmptyPath );
629 }
630 
631 void KHTMLPartPrivate::executeAnchorJump( const KUrl& url, bool lockHistory )
632 {
633  // Note: we want to emit openUrlNotify first thing, to make the history capture the old state.
634  if (!lockHistory)
635  emit m_extension->openUrlNotify();
636 
637  DOM::HashChangeEventImpl *hashChangeEvImpl = 0;
638  const QString &oldRef = q->url().ref();
639  const QString &newRef = url.ref();
640  if ((oldRef != newRef) || (oldRef.isNull() && newRef.isEmpty())) {
641  hashChangeEvImpl = new DOM::HashChangeEventImpl();
642  hashChangeEvImpl->initHashChangeEvent("hashchange",
643  true, //bubble
644  false, //cancelable
645  q->url().url(), //oldURL
646  url.url() //newURL
647  );
648  }
649 
650  if ( !q->gotoAnchor( url.encodedHtmlRef()) )
651  q->gotoAnchor( url.htmlRef() );
652 
653  q->setUrl(url);
654  emit m_extension->setLocationBarUrl( url.prettyUrl() );
655 
656  if (hashChangeEvImpl) {
657  m_doc->dispatchWindowEvent(hashChangeEvImpl);
658  }
659 }
660 
661 bool KHTMLPart::openUrl( const KUrl &url )
662 {
663  kDebug( 6050 ) << this << "opening" << url;
664 #ifndef KHTML_NO_WALLET
665  // Wallet forms are per page, so clear it when loading a different page if we
666  // are not an iframe (because we store walletforms only on the topmost part).
667  if(!parentPart())
668  d->m_walletForms.clear();
669 #endif
670  d->m_redirectionTimer.stop();
671 
672  // check to see if this is an "error://" URL. This is caused when an error
673  // occurs before this part was loaded (e.g. KonqRun), and is passed to
674  // khtmlpart so that it can display the error.
675  if ( url.protocol() == "error" ) {
676  closeUrl();
677 
678  if( d->m_bJScriptEnabled ) {
679  d->m_statusBarText[BarOverrideText].clear();
680  d->m_statusBarText[BarDefaultText].clear();
681  }
682 
688  KUrl::List urls = KUrl::split( url );
689  //kDebug(6050) << "Handling error URL. URL count:" << urls.count();
690 
691  if ( !urls.isEmpty() ) {
692  const KUrl mainURL = urls.first();
693  int error = mainURL.queryItem( "error" ).toInt();
694  // error=0 isn't a valid error code, so 0 means it's missing from the URL
695  if ( error == 0 ) error = KIO::ERR_UNKNOWN;
696  const QString errorText = mainURL.queryItem( "errText" );
697  urls.pop_front();
698  d->m_workingURL = KUrl::join( urls );
699  //kDebug(6050) << "Emitting fixed URL " << d->m_workingURL.prettyUrl();
700  emit d->m_extension->setLocationBarUrl( d->m_workingURL.prettyUrl() );
701  htmlError( error, errorText, d->m_workingURL );
702  return true;
703  }
704  }
705 
706  if (!parentPart()) { // only do it for toplevel part
707  QString host = url.isLocalFile() ? "localhost" : url.host();
708  QString userAgent = KProtocolManager::userAgentForHost(host);
709  if (userAgent != KProtocolManager::userAgentForHost(QString())) {
710  if (!d->m_statusBarUALabel) {
711  d->m_statusBarUALabel = new KUrlLabel(d->m_statusBarExtension->statusBar());
712  d->m_statusBarUALabel->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Minimum));
713  d->m_statusBarUALabel->setUseCursor(false);
714  d->m_statusBarExtension->addStatusBarItem(d->m_statusBarUALabel, 0, false);
715  d->m_statusBarUALabel->setPixmap(SmallIcon("preferences-web-browser-identification"));
716  }
717  d->m_statusBarUALabel->setToolTip(i18n("The fake user-agent '%1' is in use.", userAgent));
718  } else if (d->m_statusBarUALabel) {
719  d->m_statusBarExtension->removeStatusBarItem(d->m_statusBarUALabel);
720  delete d->m_statusBarUALabel;
721  d->m_statusBarUALabel = 0L;
722  }
723  }
724 
725  KParts::BrowserArguments browserArgs( d->m_extension->browserArguments() );
726  KParts::OpenUrlArguments args( arguments() );
727 
728  // in case
729  // a) we have no frameset (don't test m_frames.count(), iframes get in there)
730  // b) the url is identical with the currently displayed one (except for the htmlref!)
731  // c) the url request is not a POST operation and
732  // d) the caller did not request to reload the page
733  // e) there was no HTTP redirection meanwhile (testcase: webmin's software/tree.cgi)
734  // => we don't reload the whole document and
735  // we just jump to the requested html anchor
736  bool isFrameSet = false;
737  if ( d->m_doc && d->m_doc->isHTMLDocument() ) {
738  HTMLDocumentImpl* htmlDoc = static_cast<HTMLDocumentImpl*>(d->m_doc);
739  isFrameSet = htmlDoc->body() && (htmlDoc->body()->id() == ID_FRAMESET);
740  }
741 
742  if (isFrameSet && d->isLocalAnchorJump(url) && browserArgs.softReload)
743  {
744  QList<khtml::ChildFrame*>::Iterator it = d->m_frames.begin();
745  const QList<khtml::ChildFrame*>::Iterator end = d->m_frames.end();
746  for (; it != end; ++it) {
747  KHTMLPart* const part = qobject_cast<KHTMLPart *>( (*it)->m_part.data() );
748  if (part)
749  {
750  // We are reloading frames to make them jump into offsets.
751  KParts::OpenUrlArguments partargs( part->arguments() );
752  partargs.setReload( true );
753  part->setArguments( partargs );
754 
755  part->openUrl( part->url() );
756  }
757  }/*next it*/
758  return true;
759  }
760 
761  if ( url.hasRef() && !isFrameSet )
762  {
763  bool noReloadForced = !args.reload() && !browserArgs.redirectedRequest() && !browserArgs.doPost();
764  if ( noReloadForced && d->isLocalAnchorJump(url) )
765  {
766  kDebug( 6050 ) << "jumping to anchor. m_url = " << url;
767  setUrl(url);
768  emit started( 0 );
769 
770  if ( !gotoAnchor( url.encodedHtmlRef()) )
771  gotoAnchor( url.htmlRef() );
772 
773  d->m_bComplete = true;
774  if (d->m_doc)
775  d->m_doc->setParsing(false);
776 
777  kDebug( 6050 ) << "completed...";
778  emit completed();
779  return true;
780  }
781  }
782 
783  // Save offset of viewport when page is reloaded to be compliant
784  // to every other capable browser out there.
785  if (args.reload()) {
786  args.setXOffset( d->m_view->contentsX() );
787  args.setYOffset( d->m_view->contentsY() );
788  setArguments(args);
789  }
790 
791  if (!d->m_restored)
792  closeUrl();
793 
794  d->m_restoreScrollPosition = d->m_restored;
795  disconnect(d->m_view, SIGNAL(finishedLayout()), this, SLOT(restoreScrollPosition()));
796  connect(d->m_view, SIGNAL(finishedLayout()), this, SLOT(restoreScrollPosition()));
797 
798  // Classify the mimetype. Some, like images and plugins are handled
799  // by wrapping things up in tags, so we want to plain output the HTML,
800  // and not start the job and all that (since we would want the
801  // KPart or whatever to load it).
802  // This is also the only place we need to do this, as it's for
803  // internal iframe use, not any other clients.
804  MimeType type = d->classifyMimeType(args.mimeType());
805 
806  if (type == MimeImage || type == MimeOther) {
807  begin(url, args.xOffset(), args.yOffset());
808  write(QString::fromLatin1("<html><head></head><body>"));
809  if (type == MimeImage)
810  write(QString::fromLatin1("<img "));
811  else
812  write(QString::fromLatin1("<embed "));
813  write(QString::fromLatin1("src=\""));
814 
815  assert(url.url().indexOf('"') == -1);
816  write(url.url());
817 
818  write(QString::fromLatin1("\">"));
819  end();
820  return true;
821  }
822 
823 
824  // initializing m_url to the new url breaks relative links when opening such a link after this call and _before_ begin() is called (when the first
825  // data arrives) (Simon)
826  d->m_workingURL = url;
827  if(url.protocol().startsWith( "http" ) && !url.host().isEmpty() &&
828  url.path().isEmpty()) {
829  d->m_workingURL.setPath("/");
830  emit d->m_extension->setLocationBarUrl( d->m_workingURL.prettyUrl() );
831  }
832  setUrl(d->m_workingURL);
833 
834  QMap<QString,QString>& metaData = args.metaData();
835  metaData.insert("main_frame_request", parentPart() == 0 ? "TRUE" : "FALSE" );
836  metaData.insert("ssl_parent_ip", d->m_ssl_parent_ip);
837  metaData.insert("ssl_parent_cert", d->m_ssl_parent_cert);
838  metaData.insert("PropagateHttpHeader", "true");
839  metaData.insert("ssl_was_in_use", d->m_ssl_in_use ? "TRUE" : "FALSE" );
840  metaData.insert("ssl_activate_warnings", "TRUE" );
841  metaData.insert("cross-domain", toplevelURL().url());
842 
843  if (d->m_restored)
844  {
845  metaData.insert("referrer", d->m_pageReferrer);
846  d->m_cachePolicy = KIO::CC_Cache;
847  }
848  else if (args.reload() && !browserArgs.softReload)
849  d->m_cachePolicy = KIO::CC_Reload;
850  else
851  d->m_cachePolicy = KProtocolManager::cacheControl();
852 
853  if ( browserArgs.doPost() && (url.protocol().startsWith("http")) )
854  {
855  d->m_job = KIO::http_post( url, browserArgs.postData, KIO::HideProgressInfo );
856  d->m_job->addMetaData("content-type", browserArgs.contentType() );
857  }
858  else
859  {
860  d->m_job = KIO::get( url, KIO::NoReload, KIO::HideProgressInfo );
861  d->m_job->addMetaData("cache", KIO::getCacheControlString(d->m_cachePolicy));
862  }
863 
864  if (widget())
865  d->m_job->ui()->setWindow(widget()->topLevelWidget());
866  d->m_job->addMetaData(metaData);
867 
868  connect( d->m_job, SIGNAL(result(KJob*)),
869  SLOT(slotFinished(KJob*)) );
870  connect( d->m_job, SIGNAL(data(KIO::Job*,QByteArray)),
871  SLOT(slotData(KIO::Job*,QByteArray)) );
872  connect ( d->m_job, SIGNAL(infoMessage(KJob*,QString,QString)),
873  SLOT(slotInfoMessage(KJob*,QString)) );
874  connect( d->m_job, SIGNAL(redirection(KIO::Job*,KUrl)),
875  SLOT(slotRedirection(KIO::Job*,KUrl)) );
876 
877  d->m_bComplete = false;
878  d->m_bLoadEventEmitted = false;
879 
880  // delete old status bar msg's from kjs (if it _was_ activated on last URL)
881  if( d->m_bJScriptEnabled ) {
882  d->m_statusBarText[BarOverrideText].clear();
883  d->m_statusBarText[BarDefaultText].clear();
884  }
885 
886  // set the javascript flags according to the current url
887  d->m_bJScriptEnabled = KHTMLGlobal::defaultHTMLSettings()->isJavaScriptEnabled(url.host());
888  setDebugScript( KHTMLGlobal::defaultHTMLSettings()->isJavaScriptDebugEnabled() );
889  d->m_bJavaEnabled = KHTMLGlobal::defaultHTMLSettings()->isJavaEnabled(url.host());
890  d->m_bPluginsEnabled = KHTMLGlobal::defaultHTMLSettings()->isPluginsEnabled(url.host());
891 
892 
893  connect( d->m_job, SIGNAL(speed(KJob*,ulong)),
894  this, SLOT(slotJobSpeed(KJob*,ulong)) );
895 
896  connect( d->m_job, SIGNAL(percent(KJob*,ulong)),
897  this, SLOT(slotJobPercent(KJob*,ulong)) );
898 
899  connect( d->m_job, SIGNAL(result(KJob*)),
900  this, SLOT(slotJobDone(KJob*)) );
901 
902  d->m_jobspeed = 0;
903 
904  // If this was an explicit reload and the user style sheet should be used,
905  // do a stat to see whether the stylesheet was changed in the meanwhile.
906  if ( args.reload() && !settings()->userStyleSheet().isEmpty() ) {
907  KUrl url( settings()->userStyleSheet() );
908  KIO::StatJob *job = KIO::stat( url, KIO::HideProgressInfo );
909  connect( job, SIGNAL(result(KJob*)),
910  this, SLOT(slotUserSheetStatDone(KJob*)) );
911  }
912  startingJob( d->m_job );
913  emit started( 0L );
914 
915  return true;
916 }
917 
918 bool KHTMLPart::closeUrl()
919 {
920  if ( d->m_job )
921  {
922  KHTMLPageCache::self()->cancelEntry(d->m_cacheId);
923  d->m_job->kill();
924  d->m_job = 0;
925  }
926 
927  if ( d->m_doc && d->m_doc->isHTMLDocument() ) {
928  HTMLDocumentImpl* hdoc = static_cast<HTMLDocumentImpl*>( d->m_doc );
929 
930  if ( hdoc->body() && d->m_bLoadEventEmitted ) {
931  hdoc->body()->dispatchWindowEvent( EventImpl::UNLOAD_EVENT, false, false );
932  if ( d->m_doc )
933  d->m_doc->updateRendering();
934  d->m_bLoadEventEmitted = false;
935  }
936  }
937 
938  d->m_bComplete = true; // to avoid emitting completed() in slotFinishedParsing() (David)
939  d->m_bLoadEventEmitted = true; // don't want that one either
940  d->m_cachePolicy = KProtocolManager::cacheControl(); // reset cache policy
941 
942  disconnect(d->m_view, SIGNAL(finishedLayout()), this, SLOT(restoreScrollPosition()));
943 
944  KHTMLPageCache::self()->cancelFetch(this);
945  if ( d->m_doc && d->m_doc->parsing() )
946  {
947  kDebug( 6050 ) << " was still parsing... calling end ";
948  slotFinishedParsing();
949  d->m_doc->setParsing(false);
950  }
951 
952  if ( !d->m_workingURL.isEmpty() )
953  {
954  // Aborted before starting to render
955  kDebug( 6050 ) << "Aborted before starting to render, reverting location bar to " << url().prettyUrl();
956  emit d->m_extension->setLocationBarUrl( url().prettyUrl() );
957  }
958 
959  d->m_workingURL = KUrl();
960 
961  if ( d->m_doc && d->m_doc->docLoader() )
962  khtml::Cache::loader()->cancelRequests( d->m_doc->docLoader() );
963 
964  // tell all subframes to stop as well
965  {
966  ConstFrameIt it = d->m_frames.constBegin();
967  const ConstFrameIt end = d->m_frames.constEnd();
968  for (; it != end; ++it )
969  {
970  if ( (*it)->m_run )
971  (*it)->m_run.data()->abort();
972  if ( !( *it )->m_part.isNull() )
973  ( *it )->m_part.data()->closeUrl();
974  }
975  }
976  // tell all objects to stop as well
977  {
978  ConstFrameIt it = d->m_objects.constBegin();
979  const ConstFrameIt end = d->m_objects.constEnd();
980  for (; it != end; ++it)
981  {
982  if ( !( *it )->m_part.isNull() )
983  ( *it )->m_part.data()->closeUrl();
984  }
985  }
986  // Stop any started redirections as well!! (DA)
987  if ( d && d->m_redirectionTimer.isActive() )
988  d->m_redirectionTimer.stop();
989 
990  // null node activated.
991  emit nodeActivated(Node());
992 
993  // make sure before clear() runs, we pop out of a dialog's message loop
994  if ( d->m_view )
995  d->m_view->closeChildDialogs();
996 
997  return true;
998 }
999 
1000 DOM::HTMLDocument KHTMLPart::htmlDocument() const
1001 {
1002  if (d->m_doc && d->m_doc->isHTMLDocument())
1003  return static_cast<HTMLDocumentImpl*>(d->m_doc);
1004  else
1005  return static_cast<HTMLDocumentImpl*>(0);
1006 }
1007 
1008 DOM::Document KHTMLPart::document() const
1009 {
1010  return d->m_doc;
1011 }
1012 
1013 QString KHTMLPart::documentSource() const
1014 {
1015  QString sourceStr;
1016  if ( !( url().isLocalFile() ) && KHTMLPageCache::self()->isComplete( d->m_cacheId ) )
1017  {
1018  QByteArray sourceArray;
1019  QDataStream dataStream( &sourceArray, QIODevice::WriteOnly );
1020  KHTMLPageCache::self()->saveData( d->m_cacheId, &dataStream );
1021  QTextStream stream( sourceArray, QIODevice::ReadOnly );
1022  stream.setCodec( QTextCodec::codecForName( encoding().toLatin1().constData() ) );
1023  sourceStr = stream.readAll();
1024  } else
1025  {
1026  QString tmpFile;
1027  if( KIO::NetAccess::download( url(), tmpFile, NULL ) )
1028  {
1029  QFile f( tmpFile );
1030  if ( f.open( QIODevice::ReadOnly ) )
1031  {
1032  QTextStream stream( &f );
1033  stream.setCodec( QTextCodec::codecForName( encoding().toLatin1().constData() ) );
1034  sourceStr = stream.readAll();
1035  f.close();
1036  }
1037  KIO::NetAccess::removeTempFile( tmpFile );
1038  }
1039  }
1040 
1041  return sourceStr;
1042 }
1043 
1044 
1045 KParts::BrowserExtension *KHTMLPart::browserExtension() const
1046 {
1047  return d->m_extension;
1048 }
1049 
1050 KParts::BrowserHostExtension *KHTMLPart::browserHostExtension() const
1051 {
1052  return d->m_hostExtension;
1053 }
1054 
1055 KHTMLView *KHTMLPart::view() const
1056 {
1057  return d->m_view;
1058 }
1059 
1060 KHTMLViewBar *KHTMLPart::pTopViewBar() const
1061 {
1062  if (const_cast<KHTMLPart*>(this)->parentPart())
1063  return const_cast<KHTMLPart*>(this)->parentPart()->pTopViewBar();
1064  return d->m_topViewBar;
1065 }
1066 
1067 KHTMLViewBar *KHTMLPart::pBottomViewBar() const
1068 {
1069  if (const_cast<KHTMLPart*>(this)->parentPart())
1070  return const_cast<KHTMLPart*>(this)->parentPart()->pBottomViewBar();
1071  return d->m_bottomViewBar;
1072 }
1073 
1074 void KHTMLPart::setStatusMessagesEnabled( bool enable )
1075 {
1076  d->m_statusMessagesEnabled = enable;
1077 }
1078 
1079 KJS::Interpreter *KHTMLPart::jScriptInterpreter()
1080 {
1081  KJSProxy *proxy = jScript();
1082  if (!proxy || proxy->paused())
1083  return 0;
1084 
1085  return proxy->interpreter();
1086 }
1087 
1088 bool KHTMLPart::statusMessagesEnabled() const
1089 {
1090  return d->m_statusMessagesEnabled;
1091 }
1092 
1093 void KHTMLPart::setJScriptEnabled( bool enable )
1094 {
1095  if ( !enable && jScriptEnabled() && d->m_frame && d->m_frame->m_jscript ) {
1096  d->m_frame->m_jscript->clear();
1097  }
1098  d->m_bJScriptForce = enable;
1099  d->m_bJScriptOverride = true;
1100 }
1101 
1102 bool KHTMLPart::jScriptEnabled() const
1103 {
1104  if(onlyLocalReferences()) return false;
1105 
1106  if ( d->m_bJScriptOverride )
1107  return d->m_bJScriptForce;
1108  return d->m_bJScriptEnabled;
1109 }
1110 
1111 void KHTMLPart::setDNSPrefetch( DNSPrefetch pmode )
1112 {
1113  d->m_bDNSPrefetch = pmode;
1114  d->m_bDNSPrefetchIsDefault = false;
1115 }
1116 
1117 KHTMLPart::DNSPrefetch KHTMLPart::dnsPrefetch() const
1118 {
1119  if (onlyLocalReferences())
1120  return DNSPrefetchDisabled;
1121  return d->m_bDNSPrefetch;
1122 }
1123 
1124 void KHTMLPart::setMetaRefreshEnabled( bool enable )
1125 {
1126  d->m_metaRefreshEnabled = enable;
1127 }
1128 
1129 bool KHTMLPart::metaRefreshEnabled() const
1130 {
1131  return d->m_metaRefreshEnabled;
1132 }
1133 
1134 KJSProxy *KHTMLPart::jScript()
1135 {
1136  if (!jScriptEnabled()) return 0;
1137 
1138  if ( !d->m_frame ) {
1139  KHTMLPart * p = parentPart();
1140  if (!p) {
1141  d->m_frame = new khtml::ChildFrame;
1142  d->m_frame->m_part = this;
1143  } else {
1144  ConstFrameIt it = p->d->m_frames.constBegin();
1145  const ConstFrameIt end = p->d->m_frames.constEnd();
1146  for (; it != end; ++it)
1147  if ((*it)->m_part.data() == this) {
1148  d->m_frame = *it;
1149  break;
1150  }
1151  }
1152  if ( !d->m_frame )
1153  return 0;
1154  }
1155  if ( !d->m_frame->m_jscript )
1156  d->m_frame->m_jscript = new KJSProxy(d->m_frame);
1157  d->m_frame->m_jscript->setDebugEnabled(d->m_bJScriptDebugEnabled);
1158 
1159  return d->m_frame->m_jscript;
1160 }
1161 
1162 QVariant KHTMLPart::crossFrameExecuteScript(const QString& target, const QString& script)
1163 {
1164  KHTMLPart* destpart = this;
1165 
1166  QString trg = target.toLower();
1167 
1168  if (target == "_top") {
1169  while (destpart->parentPart())
1170  destpart = destpart->parentPart();
1171  }
1172  else if (target == "_parent") {
1173  if (parentPart())
1174  destpart = parentPart();
1175  }
1176  else if (target == "_self" || target == "_blank") {
1177  // we always allow these
1178  }
1179  else {
1180  destpart = findFrame(target);
1181  if (!destpart)
1182  destpart = this;
1183  }
1184 
1185  // easy way out?
1186  if (destpart == this)
1187  return executeScript(DOM::Node(), script);
1188 
1189  // now compare the domains
1190  if (destpart->checkFrameAccess(this))
1191  return destpart->executeScript(DOM::Node(), script);
1192 
1193  // eww, something went wrong. better execute it in our frame
1194  return executeScript(DOM::Node(), script);
1195 }
1196 
1197 //Enable this to see all JS scripts being executed
1198 //#define KJS_VERBOSE
1199 
1200 KJSErrorDlg *KHTMLPart::jsErrorExtension() {
1201  if (!d->m_settings->jsErrorsEnabled()) {
1202  return 0L;
1203  }
1204 
1205  if (parentPart()) {
1206  return parentPart()->jsErrorExtension();
1207  }
1208 
1209  if (!d->m_statusBarJSErrorLabel) {
1210  d->m_statusBarJSErrorLabel = new KUrlLabel(d->m_statusBarExtension->statusBar());
1211  d->m_statusBarJSErrorLabel->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Minimum));
1212  d->m_statusBarJSErrorLabel->setUseCursor(false);
1213  d->m_statusBarExtension->addStatusBarItem(d->m_statusBarJSErrorLabel, 0, false);
1214  d->m_statusBarJSErrorLabel->setToolTip(i18n("This web page contains coding errors."));
1215  d->m_statusBarJSErrorLabel->setPixmap(SmallIcon("script-error"));
1216  connect(d->m_statusBarJSErrorLabel, SIGNAL(leftClickedUrl()), SLOT(launchJSErrorDialog()));
1217  connect(d->m_statusBarJSErrorLabel, SIGNAL(rightClickedUrl()), SLOT(jsErrorDialogContextMenu()));
1218  }
1219  if (!d->m_jsedlg) {
1220  d->m_jsedlg = new KJSErrorDlg;
1221  d->m_jsedlg->setURL(url().prettyUrl());
1222  if (KGlobalSettings::showIconsOnPushButtons()) {
1223  d->m_jsedlg->_clear->setIcon(KIcon("edit-clear-locationbar-ltr"));
1224  d->m_jsedlg->_close->setIcon(KIcon("window-close"));
1225  }
1226  }
1227  return d->m_jsedlg;
1228 }
1229 
1230 void KHTMLPart::removeJSErrorExtension() {
1231  if (parentPart()) {
1232  parentPart()->removeJSErrorExtension();
1233  return;
1234  }
1235  if (d->m_statusBarJSErrorLabel != 0) {
1236  d->m_statusBarExtension->removeStatusBarItem( d->m_statusBarJSErrorLabel );
1237  delete d->m_statusBarJSErrorLabel;
1238  d->m_statusBarJSErrorLabel = 0;
1239  }
1240  delete d->m_jsedlg;
1241  d->m_jsedlg = 0;
1242 }
1243 
1244 void KHTMLPart::disableJSErrorExtension() {
1245  removeJSErrorExtension();
1246  // These two lines are really kind of hacky, and it sucks to do this inside
1247  // KHTML but I don't know of anything that's reasonably easy as an alternative
1248  // right now. It makes me wonder if there should be a more clean way to
1249  // contact all running "KHTML" instance as opposed to Konqueror instances too.
1250  d->m_settings->setJSErrorsEnabled(false);
1251  emit configurationChanged();
1252 }
1253 
1254 void KHTMLPart::jsErrorDialogContextMenu() {
1255  KMenu *m = new KMenu(0L);
1256  m->addAction(i18n("&Hide Errors"), this, SLOT(removeJSErrorExtension()));
1257  m->addAction(i18n("&Disable Error Reporting"), this, SLOT(disableJSErrorExtension()));
1258  m->popup(QCursor::pos());
1259 }
1260 
1261 void KHTMLPart::launchJSErrorDialog() {
1262  KJSErrorDlg *dlg = jsErrorExtension();
1263  if (dlg) {
1264  dlg->show();
1265  dlg->raise();
1266  }
1267 }
1268 
1269 void KHTMLPart::launchJSConfigDialog() {
1270  QStringList args;
1271  args << "khtml_java_js";
1272  KToolInvocation::kdeinitExec( "kcmshell4", args );
1273 }
1274 
1275 QVariant KHTMLPart::executeScript(const QString& filename, int baseLine, const DOM::Node& n, const QString& script)
1276 {
1277 #ifdef KJS_VERBOSE
1278  // The script is now printed by KJS's Parser::parse
1279  kDebug(6070) << "executeScript: caller='" << objectName() << "' filename=" << filename << " baseLine=" << baseLine /*<< " script=" << script*/;
1280 #endif
1281  KJSProxy *proxy = jScript();
1282 
1283  if (!proxy || proxy->paused())
1284  return QVariant();
1285 
1286  KJS::Completion comp;
1287  QVariant ret = proxy->evaluate(filename, baseLine, script, n, &comp);
1288 
1289  /*
1290  * Error handling
1291  */
1292  if (comp.complType() == KJS::Throw && comp.value()) {
1293  KJSErrorDlg *dlg = jsErrorExtension();
1294  if (dlg) {
1295  QString msg = KJSDebugger::DebugWindow::exceptionToString(
1296  proxy->interpreter()->globalExec(), comp.value());
1297  dlg->addError(i18n("<qt><b>Error</b>: %1: %2</qt>",
1298  Qt::escape(filename), Qt::escape(msg)));
1299  }
1300  }
1301 
1302  // Handle immediate redirects now (e.g. location='foo')
1303  if ( !d->m_redirectURL.isEmpty() && d->m_delayRedirect == -1 )
1304  {
1305  kDebug(6070) << "executeScript done, handling immediate redirection NOW";
1306  // Must abort tokenizer, no further script must execute.
1307  khtml::Tokenizer* t = d->m_doc->tokenizer();
1308  if(t)
1309  t->abort();
1310  d->m_redirectionTimer.setSingleShot( true );
1311  d->m_redirectionTimer.start( 0 );
1312  }
1313 
1314  return ret;
1315 }
1316 
1317 QVariant KHTMLPart::executeScript( const QString &script )
1318 {
1319  return executeScript( DOM::Node(), script );
1320 }
1321 
1322 QVariant KHTMLPart::executeScript( const DOM::Node &n, const QString &script )
1323 {
1324 #ifdef KJS_VERBOSE
1325  kDebug(6070) << "caller=" << objectName() << "node=" << n.nodeName().string().toLatin1().constData() << "(" << (n.isNull() ? 0 : n.nodeType()) << ") " /* << script */;
1326 #endif
1327  KJSProxy *proxy = jScript();
1328 
1329  if (!proxy || proxy->paused())
1330  return QVariant();
1331 
1332  ++(d->m_runningScripts);
1333  KJS::Completion comp;
1334  const QVariant ret = proxy->evaluate( QString(), 1, script, n, &comp );
1335  --(d->m_runningScripts);
1336 
1337  /*
1338  * Error handling
1339  */
1340  if (comp.complType() == KJS::Throw && comp.value()) {
1341  KJSErrorDlg *dlg = jsErrorExtension();
1342  if (dlg) {
1343  QString msg = KJSDebugger::DebugWindow::exceptionToString(
1344  proxy->interpreter()->globalExec(), comp.value());
1345  dlg->addError(i18n("<qt><b>Error</b>: node %1: %2</qt>",
1346  n.nodeName().string(), Qt::escape(msg)));
1347  }
1348  }
1349 
1350  if (!d->m_runningScripts && d->m_doc && !d->m_doc->parsing() && d->m_submitForm )
1351  submitFormAgain();
1352 
1353 #ifdef KJS_VERBOSE
1354  kDebug(6070) << "done";
1355 #endif
1356  return ret;
1357 }
1358 
1359 void KHTMLPart::setJavaEnabled( bool enable )
1360 {
1361  d->m_bJavaForce = enable;
1362  d->m_bJavaOverride = true;
1363 }
1364 
1365 bool KHTMLPart::javaEnabled() const
1366 {
1367  if (onlyLocalReferences()) return false;
1368 
1369 #ifndef Q_WS_QWS
1370  if( d->m_bJavaOverride )
1371  return d->m_bJavaForce;
1372  return d->m_bJavaEnabled;
1373 #else
1374  return false;
1375 #endif
1376 }
1377 
1378 void KHTMLPart::setPluginsEnabled( bool enable )
1379 {
1380  d->m_bPluginsForce = enable;
1381  d->m_bPluginsOverride = true;
1382 }
1383 
1384 bool KHTMLPart::pluginsEnabled() const
1385 {
1386  if (onlyLocalReferences()) return false;
1387 
1388  if ( d->m_bPluginsOverride )
1389  return d->m_bPluginsForce;
1390  return d->m_bPluginsEnabled;
1391 }
1392 
1393 static int s_DOMTreeIndentLevel = 0;
1394 
1395 void KHTMLPart::slotDebugDOMTree()
1396 {
1397  if ( d->m_doc )
1398  qDebug("%s", d->m_doc->toString().string().toLatin1().constData());
1399 
1400  // Now print the contents of the frames that contain HTML
1401 
1402  const int indentLevel = s_DOMTreeIndentLevel++;
1403 
1404  ConstFrameIt it = d->m_frames.constBegin();
1405  const ConstFrameIt end = d->m_frames.constEnd();
1406  for (; it != end; ++it )
1407  if ( !( *it )->m_part.isNull() && (*it)->m_part.data()->inherits( "KHTMLPart" ) ) {
1408  KParts::ReadOnlyPart* const p = ( *it )->m_part.data();
1409  kDebug(6050) << QString().leftJustified(s_DOMTreeIndentLevel*4,' ') << "FRAME " << p->objectName() << " ";
1410  static_cast<KHTMLPart*>( p )->slotDebugDOMTree();
1411  }
1412  s_DOMTreeIndentLevel = indentLevel;
1413 }
1414 
1415 void KHTMLPart::slotDebugScript()
1416 {
1417  if (jScript())
1418  jScript()->showDebugWindow();
1419 }
1420 
1421 void KHTMLPart::slotDebugRenderTree()
1422 {
1423 #ifndef NDEBUG
1424  if ( d->m_doc ) {
1425  d->m_doc->renderer()->printTree();
1426  // dump out the contents of the rendering & DOM trees
1427 // QString dumps;
1428 // QTextStream outputStream(&dumps,QIODevice::WriteOnly);
1429 // d->m_doc->renderer()->layer()->dump( outputStream );
1430 // kDebug() << "dump output:" << "\n" + dumps;
1431 // d->m_doc->renderer()->printLineBoxTree();
1432  }
1433 #endif
1434 }
1435 
1436 void KHTMLPart::slotDebugFrameTree()
1437 {
1438  khtml::ChildFrame::dumpFrameTree(this);
1439 }
1440 
1441 void KHTMLPart::slotStopAnimations()
1442 {
1443  stopAnimations();
1444 }
1445 
1446 void KHTMLPart::setAutoloadImages( bool enable )
1447 {
1448  if ( d->m_doc && d->m_doc->docLoader()->autoloadImages() == enable )
1449  return;
1450 
1451  if ( d->m_doc )
1452  d->m_doc->docLoader()->setAutoloadImages( enable );
1453 
1454  unplugActionList( "loadImages" );
1455 
1456  if ( enable ) {
1457  delete d->m_paLoadImages;
1458  d->m_paLoadImages = 0;
1459  }
1460  else if ( !d->m_paLoadImages ) {
1461  d->m_paLoadImages = new KAction( i18n( "Display Images on Page" ), this );
1462  actionCollection()->addAction( "loadImages", d->m_paLoadImages );
1463  d->m_paLoadImages->setIcon( KIcon( "image-loading" ) );
1464  connect( d->m_paLoadImages, SIGNAL(triggered(bool)), this, SLOT(slotLoadImages()) );
1465  }
1466 
1467  if ( d->m_paLoadImages ) {
1468  QList<QAction*> lst;
1469  lst.append( d->m_paLoadImages );
1470  plugActionList( "loadImages", lst );
1471  }
1472 }
1473 
1474 bool KHTMLPart::autoloadImages() const
1475 {
1476  if ( d->m_doc )
1477  return d->m_doc->docLoader()->autoloadImages();
1478 
1479  return true;
1480 }
1481 
1482 void KHTMLPart::clear()
1483 {
1484  if ( d->m_bCleared )
1485  return;
1486 
1487  d->m_bCleared = true;
1488 
1489  d->m_bClearing = true;
1490 
1491  {
1492  ConstFrameIt it = d->m_frames.constBegin();
1493  const ConstFrameIt end = d->m_frames.constEnd();
1494  for(; it != end; ++it )
1495  {
1496  // Stop HTMLRun jobs for frames
1497  if ( (*it)->m_run )
1498  (*it)->m_run.data()->abort();
1499  }
1500  }
1501 
1502  {
1503  ConstFrameIt it = d->m_objects.constBegin();
1504  const ConstFrameIt end = d->m_objects.constEnd();
1505  for(; it != end; ++it )
1506  {
1507  // Stop HTMLRun jobs for objects
1508  if ( (*it)->m_run )
1509  (*it)->m_run.data()->abort();
1510  }
1511  }
1512 
1513 
1514  findTextBegin(); // resets d->m_findNode and d->m_findPos
1515  d->m_mousePressNode = DOM::Node();
1516 
1517 
1518  if ( d->m_doc )
1519  {
1520  if (d->m_doc->attached()) //the view may have detached it already
1521  d->m_doc->detach();
1522  }
1523 
1524  // Moving past doc so that onUnload works.
1525  if ( d->m_frame && d->m_frame->m_jscript )
1526  d->m_frame->m_jscript->clear();
1527 
1528  // stopping marquees
1529  if (d->m_doc && d->m_doc->renderer() && d->m_doc->renderer()->layer())
1530  d->m_doc->renderer()->layer()->suspendMarquees();
1531 
1532  if ( d->m_view )
1533  d->m_view->clear();
1534 
1535  // do not dereference the document before the jscript and view are cleared, as some destructors
1536  // might still try to access the document.
1537  if ( d->m_doc ) {
1538  d->m_doc->deref();
1539  }
1540  d->m_doc = 0;
1541 
1542  delete d->m_decoder;
1543  d->m_decoder = 0;
1544 
1545  // We don't want to change between parts if we are going to delete all of them anyway
1546  if (partManager()) {
1547  disconnect( partManager(), SIGNAL(activePartChanged(KParts::Part*)),
1548  this, SLOT(slotActiveFrameChanged(KParts::Part*)) );
1549  }
1550 
1551  if (d->m_frames.count())
1552  {
1553  const KHTMLFrameList frames = d->m_frames;
1554  d->m_frames.clear();
1555  ConstFrameIt it = frames.begin();
1556  const ConstFrameIt end = frames.end();
1557  for(; it != end; ++it )
1558  {
1559  if ( (*it)->m_part )
1560  {
1561  partManager()->removePart( (*it)->m_part.data() );
1562  delete (*it)->m_part.data();
1563  }
1564  delete *it;
1565  }
1566  }
1567  d->m_suppressedPopupOriginParts.clear();
1568 
1569  if (d->m_objects.count())
1570  {
1571  KHTMLFrameList objects = d->m_objects;
1572  d->m_objects.clear();
1573  ConstFrameIt oi = objects.constBegin();
1574  const ConstFrameIt oiEnd = objects.constEnd();
1575 
1576  for (; oi != oiEnd; ++oi )
1577  {
1578  delete (*oi)->m_part.data();
1579  delete *oi;
1580  }
1581  }
1582 
1583  // Listen to part changes again
1584  if (partManager()) {
1585  connect( partManager(), SIGNAL(activePartChanged(KParts::Part*)),
1586  this, SLOT(slotActiveFrameChanged(KParts::Part*)) );
1587  }
1588 
1589  d->clearRedirection();
1590  d->m_redirectLockHistory = true;
1591  d->m_bClearing = false;
1592  d->m_frameNameId = 1;
1593  d->m_bFirstData = true;
1594 
1595  d->m_bMousePressed = false;
1596 
1597  if (d->editor_context.m_caretBlinkTimer >= 0)
1598  killTimer(d->editor_context.m_caretBlinkTimer);
1599  d->editor_context.reset();
1600 #ifndef QT_NO_CLIPBOARD
1601  connect( qApp->clipboard(), SIGNAL(selectionChanged()), SLOT(slotClearSelection()));
1602 #endif
1603 
1604  d->m_jobPercent = 0;
1605 
1606  if ( !d->m_haveEncoding )
1607  d->m_encoding.clear();
1608 
1609  d->m_DNSPrefetchQueue.clear();
1610  if (d->m_DNSPrefetchTimer > 0)
1611  killTimer(d->m_DNSPrefetchTimer);
1612  d->m_DNSPrefetchTimer = -1;
1613  d->m_lookedupHosts.clear();
1614  if (d->m_DNSTTLTimer > 0)
1615  killTimer(d->m_DNSTTLTimer);
1616  d->m_DNSTTLTimer = -1;
1617  d->m_numDNSPrefetchedNames = 0;
1618 
1619 #ifdef SPEED_DEBUG
1620  d->m_parsetime.restart();
1621 #endif
1622 }
1623 
1624 bool KHTMLPart::openFile()
1625 {
1626  return true;
1627 }
1628 
1629 DOM::HTMLDocumentImpl *KHTMLPart::docImpl() const
1630 {
1631  if ( d && d->m_doc && d->m_doc->isHTMLDocument() )
1632  return static_cast<HTMLDocumentImpl*>(d->m_doc);
1633  return 0;
1634 }
1635 
1636 DOM::DocumentImpl *KHTMLPart::xmlDocImpl() const
1637 {
1638  if ( d )
1639  return d->m_doc;
1640  return 0;
1641 }
1642 
1643 void KHTMLPart::slotInfoMessage(KJob* kio_job, const QString& msg)
1644 {
1645  assert(d->m_job == kio_job);
1646  Q_ASSERT(kio_job);
1647  Q_UNUSED(kio_job);
1648 
1649  if (!parentPart())
1650  setStatusBarText(msg, BarDefaultText);
1651 }
1652 
1653 void KHTMLPart::setPageSecurity( PageSecurity sec )
1654 {
1655  emit d->m_extension->setPageSecurity( sec );
1656 }
1657 
1658 void KHTMLPart::slotData( KIO::Job* kio_job, const QByteArray &data )
1659 {
1660  assert ( d->m_job == kio_job );
1661  Q_ASSERT(kio_job);
1662  Q_UNUSED(kio_job);
1663 
1664  //kDebug( 6050 ) << "slotData: " << data.size();
1665  // The first data ?
1666  if ( !d->m_workingURL.isEmpty() )
1667  {
1668  //kDebug( 6050 ) << "begin!";
1669 
1670  // We must suspend KIO while we're inside begin() because it can cause
1671  // crashes if a window (such as kjsdebugger) goes back into the event loop,
1672  // more data arrives, and begin() gets called again (re-entered).
1673  d->m_job->suspend();
1674  begin( d->m_workingURL, arguments().xOffset(), arguments().yOffset() );
1675  d->m_job->resume();
1676 
1677  // CC_Refresh means : always send the server an If-Modified-Since conditional request.
1678  // This is the default cache setting and correspond to the KCM's "Keep cache in sync".
1679  // CC_Verify means : only send a conditional request if the cache expiry date is passed.
1680  // It doesn't have a KCM setter.
1681  // We override the first to the second, except when doing a soft-reload.
1682  if (d->m_cachePolicy == KIO::CC_Refresh && !d->m_extension->browserArguments().softReload)
1683  d->m_doc->docLoader()->setCachePolicy(KIO::CC_Verify);
1684  else
1685  d->m_doc->docLoader()->setCachePolicy(d->m_cachePolicy);
1686 
1687  d->m_workingURL = KUrl();
1688 
1689  d->m_cacheId = KHTMLPageCache::self()->createCacheEntry();
1690 
1691  // When the first data arrives, the metadata has just been made available
1692  d->m_httpHeaders = d->m_job->queryMetaData("HTTP-Headers");
1693  time_t cacheCreationDate = d->m_job->queryMetaData("cache-creation-date").toLong();
1694  d->m_doc->docLoader()->setCacheCreationDate(cacheCreationDate);
1695 
1696  d->m_pageServices = d->m_job->queryMetaData("PageServices");
1697  d->m_pageReferrer = d->m_job->queryMetaData("referrer");
1698  d->m_ssl_in_use = (d->m_job->queryMetaData("ssl_in_use") == "TRUE");
1699 
1700  {
1701  KHTMLPart *p = parentPart();
1702  if (p && p->d->m_ssl_in_use != d->m_ssl_in_use) {
1703  while (p->parentPart()) p = p->parentPart();
1704 
1705  p->setPageSecurity( NotCrypted );
1706  }
1707  }
1708 
1709  setPageSecurity( d->m_ssl_in_use ? Encrypted : NotCrypted );
1710 
1711  // Shouldn't all of this be done only if ssl_in_use == true ? (DF)
1712  d->m_ssl_parent_ip = d->m_job->queryMetaData("ssl_parent_ip");
1713  d->m_ssl_parent_cert = d->m_job->queryMetaData("ssl_parent_cert");
1714  d->m_ssl_peer_chain = d->m_job->queryMetaData("ssl_peer_chain");
1715  d->m_ssl_peer_ip = d->m_job->queryMetaData("ssl_peer_ip");
1716  d->m_ssl_cipher = d->m_job->queryMetaData("ssl_cipher");
1717  d->m_ssl_protocol_version = d->m_job->queryMetaData("ssl_protocol_version");
1718  d->m_ssl_cipher_used_bits = d->m_job->queryMetaData("ssl_cipher_used_bits");
1719  d->m_ssl_cipher_bits = d->m_job->queryMetaData("ssl_cipher_bits");
1720  d->m_ssl_cert_errors = d->m_job->queryMetaData("ssl_cert_errors");
1721 
1722  // Check for charset meta-data
1723  QString qData = d->m_job->queryMetaData("charset");
1724  if ( !qData.isEmpty() && !d->m_haveEncoding ) // only use information if the user didn't override the settings
1725  d->m_encoding = qData;
1726 
1727 
1728  // Support for http-refresh
1729  qData = d->m_job->queryMetaData("http-refresh");
1730  if( !qData.isEmpty())
1731  d->m_doc->processHttpEquiv("refresh", qData);
1732 
1733  // DISABLED: Support Content-Location per section 14.14 of RFC 2616.
1734  // See BR# 51185,BR# 82747
1735  /*
1736  QString baseURL = d->m_job->queryMetaData ("content-location");
1737  if (!baseURL.isEmpty())
1738  d->m_doc->setBaseURL(KUrl( d->m_doc->completeURL(baseURL) ));
1739  */
1740 
1741  // Support for Content-Language
1742  QString language = d->m_job->queryMetaData("content-language");
1743  if (!language.isEmpty())
1744  d->m_doc->setContentLanguage(language);
1745 
1746  if ( !url().isLocalFile() )
1747  {
1748  // Support for http last-modified
1749  d->m_lastModified = d->m_job->queryMetaData("modified");
1750  }
1751  else
1752  d->m_lastModified.clear(); // done on-demand by lastModified()
1753  }
1754 
1755  KHTMLPageCache::self()->addData(d->m_cacheId, data);
1756  write( data.data(), data.size() );
1757 }
1758 
1759 void KHTMLPart::slotRestoreData(const QByteArray &data )
1760 {
1761  // The first data ?
1762  if ( !d->m_workingURL.isEmpty() )
1763  {
1764  long saveCacheId = d->m_cacheId;
1765  QString savePageReferrer = d->m_pageReferrer;
1766  QString saveEncoding = d->m_encoding;
1767  begin( d->m_workingURL, arguments().xOffset(), arguments().yOffset() );
1768  d->m_encoding = saveEncoding;
1769  d->m_pageReferrer = savePageReferrer;
1770  d->m_cacheId = saveCacheId;
1771  d->m_workingURL = KUrl();
1772  }
1773 
1774  //kDebug( 6050 ) << data.size();
1775  write( data.data(), data.size() );
1776 
1777  if (data.size() == 0)
1778  {
1779  //kDebug( 6050 ) << "<<end of data>>";
1780  // End of data.
1781  if (d->m_doc && d->m_doc->parsing())
1782  end(); //will emit completed()
1783  }
1784 }
1785 
1786 void KHTMLPart::showError( KJob* job )
1787 {
1788  kDebug(6050) << "d->m_bParsing=" << (d->m_doc && d->m_doc->parsing()) << " d->m_bComplete=" << d->m_bComplete
1789  << " d->m_bCleared=" << d->m_bCleared;
1790 
1791  if (job->error() == KIO::ERR_NO_CONTENT)
1792  return;
1793 
1794  if ( (d->m_doc && d->m_doc->parsing()) || d->m_workingURL.isEmpty() ) // if we got any data already
1795  job->uiDelegate()->showErrorMessage();
1796  else
1797  {
1798  htmlError( job->error(), job->errorText(), d->m_workingURL );
1799  }
1800 }
1801 
1802 // This is a protected method, placed here because of it's relevance to showError
1803 void KHTMLPart::htmlError( int errorCode, const QString& text, const KUrl& reqUrl )
1804 {
1805  kDebug(6050) << "errorCode" << errorCode << "text" << text;
1806  // make sure we're not executing any embedded JS
1807  bool bJSFO = d->m_bJScriptForce;
1808  bool bJSOO = d->m_bJScriptOverride;
1809  d->m_bJScriptForce = false;
1810  d->m_bJScriptOverride = true;
1811  begin();
1812 
1813  QString errorName, techName, description;
1814  QStringList causes, solutions;
1815 
1816  QByteArray raw = KIO::rawErrorDetail( errorCode, text, &reqUrl );
1817  QDataStream stream(raw);
1818 
1819  stream >> errorName >> techName >> description >> causes >> solutions;
1820 
1821  QString url, protocol, datetime;
1822 
1823  // This is somewhat confusing, but we have to escape the externally-
1824  // controlled URL twice: once for i18n, and once for HTML.
1825  url = Qt::escape( Qt::escape( reqUrl.prettyUrl() ) );
1826  protocol = reqUrl.protocol();
1827  datetime = KGlobal::locale()->formatDateTime( QDateTime::currentDateTime(),
1828  KLocale::LongDate );
1829 
1830  QString filename( KStandardDirs::locate( "data", "khtml/error.html" ) );
1831  QFile file( filename );
1832  bool isOpened = file.open( QIODevice::ReadOnly );
1833  if ( !isOpened )
1834  kWarning(6050) << "Could not open error html template:" << filename;
1835 
1836  QString html = QString( QLatin1String( file.readAll() ) );
1837 
1838  html.replace( QLatin1String( "TITLE" ), i18n( "Error: %1 - %2", errorName, url ) );
1839  html.replace( QLatin1String( "DIRECTION" ), QApplication::isRightToLeft() ? "rtl" : "ltr" );
1840  html.replace( QLatin1String( "ICON_PATH" ), KIconLoader::global()->iconPath( "dialog-warning", -KIconLoader::SizeHuge ) );
1841 
1842  QString doc = QLatin1String( "<h1>" );
1843  doc += i18n( "The requested operation could not be completed" );
1844  doc += QLatin1String( "</h1><h2>" );
1845  doc += errorName;
1846  doc += QLatin1String( "</h2>" );
1847  if ( !techName.isNull() ) {
1848  doc += QLatin1String( "<h2>" );
1849  doc += i18n( "Technical Reason: " );
1850  doc += techName;
1851  doc += QLatin1String( "</h2>" );
1852  }
1853  doc += QLatin1String( "<br clear=\"all\">" );
1854  doc += QLatin1String( "<h3>" );
1855  doc += i18n( "Details of the Request:" );
1856  doc += QLatin1String( "</h3><ul><li>" );
1857  doc += i18n( "URL: %1" , url );
1858  doc += QLatin1String( "</li><li>" );
1859  if ( !protocol.isNull() ) {
1860  doc += i18n( "Protocol: %1", protocol );
1861  doc += QLatin1String( "</li><li>" );
1862  }
1863  doc += i18n( "Date and Time: %1" , datetime );
1864  doc += QLatin1String( "</li><li>" );
1865  doc += i18n( "Additional Information: %1" , text );
1866  doc += QLatin1String( "</li></ul><h3>" );
1867  doc += i18n( "Description:" );
1868  doc += QLatin1String( "</h3><p>" );
1869  doc += description;
1870  doc += QLatin1String( "</p>" );
1871  if ( causes.count() ) {
1872  doc += QLatin1String( "<h3>" );
1873  doc += i18n( "Possible Causes:" );
1874  doc += QLatin1String( "</h3><ul><li>" );
1875  doc += causes.join( "</li><li>" );
1876  doc += QLatin1String( "</li></ul>" );
1877  }
1878  if ( solutions.count() ) {
1879  doc += QLatin1String( "<h3>" );
1880  doc += i18n( "Possible Solutions:" );
1881  doc += QLatin1String( "</h3><ul><li>" );
1882  doc += solutions.join( "</li><li>" );
1883  doc += QLatin1String( "</li></ul>" );
1884  }
1885 
1886  html.replace( QLatin1String("TEXT"), doc );
1887 
1888  write( html );
1889  end();
1890 
1891  d->m_bJScriptForce = bJSFO;
1892  d->m_bJScriptOverride = bJSOO;
1893 
1894  // make the working url the current url, so that reload works and
1895  // emit the progress signals to advance one step in the history
1896  // (so that 'back' works)
1897  setUrl(reqUrl); // same as d->m_workingURL
1898  d->m_workingURL = KUrl();
1899  emit started( 0 );
1900  emit completed();
1901 }
1902 
1903 void KHTMLPart::slotFinished( KJob * job )
1904 {
1905  d->m_job = 0L;
1906  d->m_jobspeed = 0L;
1907 
1908  if (job->error())
1909  {
1910  KHTMLPageCache::self()->cancelEntry(d->m_cacheId);
1911 
1912  // The following catches errors that occur as a result of HTTP
1913  // to FTP redirections where the FTP URL is a directory. Since
1914  // KIO cannot change a redirection request from GET to LISTDIR,
1915  // we have to take care of it here once we know for sure it is
1916  // a directory...
1917  if (job->error() == KIO::ERR_IS_DIRECTORY)
1918  {
1919  emit canceled( job->errorString() );
1920  emit d->m_extension->openUrlRequest( d->m_workingURL );
1921  }
1922  else
1923  {
1924  emit canceled( job->errorString() );
1925  // TODO: what else ?
1926  checkCompleted();
1927  showError( job );
1928  }
1929 
1930  return;
1931  }
1932  KIO::TransferJob *tjob = ::qobject_cast<KIO::TransferJob*>(job);
1933  if (tjob && tjob->isErrorPage()) {
1934  HTMLPartContainerElementImpl *elt = d->m_frame ?
1935  d->m_frame->m_partContainerElement.data() : 0;
1936 
1937  if (!elt)
1938  return;
1939 
1940  elt->partLoadingErrorNotify();
1941  checkCompleted();
1942  if (d->m_bComplete) return;
1943  }
1944 
1945  //kDebug( 6050 ) << "slotFinished";
1946 
1947  KHTMLPageCache::self()->endData(d->m_cacheId);
1948 
1949  if ( d->m_doc && d->m_doc->docLoader()->expireDate() && url().protocol().startsWith("http"))
1950  KIO::http_update_cache(url(), false, d->m_doc->docLoader()->expireDate());
1951 
1952  d->m_workingURL = KUrl();
1953 
1954  if ( d->m_doc && d->m_doc->parsing())
1955  end(); //will emit completed()
1956 }
1957 
1958 MimeType KHTMLPartPrivate::classifyMimeType(const QString& mimeStr)
1959 {
1960  // See HTML5's "5.5.1 Navigating across documents" section.
1961  if (mimeStr == "application/xhtml+xml")
1962  return MimeXHTML;
1963  if (mimeStr == "image/svg+xml")
1964  return MimeSVG;
1965  if (mimeStr == "text/html" || mimeStr.isEmpty())
1966  return MimeHTML;
1967 
1968  KMimeType::Ptr mime = KMimeType::mimeType(mimeStr, KMimeType::ResolveAliases);
1969  if ((mime && mime->is("text/xml")) || mimeStr.endsWith("+xml"))
1970  return MimeXML;
1971 
1972  if (mime && mime->is("text/plain"))
1973  return MimeText;
1974 
1975  if (khtmlImLoad::ImageManager::loaderDatabase()->supportedMimeTypes().contains(mimeStr))
1976  return MimeImage;
1977 
1978  // Sometimes our subclasses like to handle custom mimetypes. In that case,
1979  // we want to handle them as HTML. We do that in the following cases:
1980  // 1) We're at top-level, so we were forced to open something
1981  // 2) We're an object --- this again means we were forced to open something,
1982  // as an iframe-generating-an-embed case would have us as an iframe
1983  if (!q->parentPart() || (m_frame && m_frame->m_type == khtml::ChildFrame::Object))
1984  return MimeHTML;
1985 
1986  return MimeOther;
1987 }
1988 
1989 void KHTMLPart::begin( const KUrl &url, int xOffset, int yOffset )
1990 {
1991  if ( d->m_view->underMouse() )
1992  QToolTip::hideText(); // in case a previous tooltip is still shown
1993 
1994  // No need to show this for a new page until an error is triggered
1995  if (!parentPart()) {
1996  removeJSErrorExtension();
1997  setSuppressedPopupIndicator( false );
1998  d->m_openableSuppressedPopups = 0;
1999  foreach ( KHTMLPart* part, d->m_suppressedPopupOriginParts ) {
2000  if (part) {
2001  KJS::Window *w = KJS::Window::retrieveWindow( part );
2002  if (w)
2003  w->forgetSuppressedWindows();
2004  }
2005  }
2006  }
2007 
2008  d->m_bCleared = false;
2009  d->m_cacheId = 0;
2010  d->m_bComplete = false;
2011  d->m_bLoadEventEmitted = false;
2012  clear();
2013  d->m_bCleared = false;
2014 
2015  if(url.isValid()) {
2016  QString urlString = url.url();
2017  KHTMLGlobal::vLinks()->insert( urlString );
2018  QString urlString2 = url.prettyUrl();
2019  if ( urlString != urlString2 ) {
2020  KHTMLGlobal::vLinks()->insert( urlString2 );
2021  }
2022  }
2023 
2024  // ###
2025  //stopParser();
2026 
2027  KParts::OpenUrlArguments args = arguments();
2028  args.setXOffset(xOffset);
2029  args.setYOffset(yOffset);
2030  setArguments(args);
2031 
2032  d->m_pageReferrer.clear();
2033  d->m_referrer = url.protocol().startsWith("http") ? url.url() : "";
2034 
2035  setUrl(url);
2036 
2037  // Note: by now, any special mimetype besides plaintext would have been
2038  // handled specially inside openURL, so we handle their cases the same
2039  // as HTML.
2040  MimeType type = d->classifyMimeType(args.mimeType());
2041  switch (type) {
2042  case MimeSVG:
2043  d->m_doc = DOMImplementationImpl::createSVGDocument( d->m_view );
2044  break;
2045  case MimeXML: // any XML derivative, except XHTML or SVG
2046  // ### not sure if XHTML documents served as text/xml should use DocumentImpl or HTMLDocumentImpl
2047  d->m_doc = DOMImplementationImpl::createXMLDocument( d->m_view );
2048  break;
2049  case MimeText:
2050  d->m_doc = new HTMLTextDocumentImpl( d->m_view );
2051  break;
2052  case MimeXHTML:
2053  case MimeHTML:
2054  default:
2055  d->m_doc = DOMImplementationImpl::createHTMLDocument( d->m_view );
2056  // HTML or XHTML? (#86446)
2057  static_cast<HTMLDocumentImpl *>(d->m_doc)->setHTMLRequested( type != MimeXHTML );
2058  }
2059 
2060  d->m_doc->ref();
2061  d->m_doc->setURL( url.url() );
2062  d->m_doc->open( );
2063  if (!d->m_doc->attached())
2064  d->m_doc->attach( );
2065  d->m_doc->setBaseURL( KUrl() );
2066  d->m_doc->docLoader()->setShowAnimations( KHTMLGlobal::defaultHTMLSettings()->showAnimations() );
2067  emit docCreated();
2068 
2069  d->m_paUseStylesheet->setItems(QStringList());
2070  d->m_paUseStylesheet->setEnabled( false );
2071 
2072  setAutoloadImages( KHTMLGlobal::defaultHTMLSettings()->autoLoadImages() );
2073  QString userStyleSheet = KHTMLGlobal::defaultHTMLSettings()->userStyleSheet();
2074  if ( !userStyleSheet.isEmpty() )
2075  setUserStyleSheet( KUrl( userStyleSheet ) );
2076 
2077  d->m_doc->setRestoreState(d->m_extension->browserArguments().docState);
2078  connect(d->m_doc,SIGNAL(finishedParsing()),this,SLOT(slotFinishedParsing()));
2079 
2080  emit d->m_extension->enableAction( "print", true );
2081 
2082  d->m_doc->setParsing(true);
2083 }
2084 
2085 void KHTMLPart::write( const char *data, int len )
2086 {
2087  if ( !d->m_decoder )
2088  d->m_decoder = createDecoder();
2089 
2090  if ( len == -1 )
2091  len = strlen( data );
2092 
2093  if ( len == 0 )
2094  return;
2095 
2096  QString decoded=d->m_decoder->decodeWithBuffering(data,len);
2097 
2098  if(decoded.isEmpty())
2099  return;
2100 
2101  if(d->m_bFirstData)
2102  onFirstData();
2103 
2104  khtml::Tokenizer* t = d->m_doc->tokenizer();
2105  if(t)
2106  t->write( decoded, true );
2107 }
2108 
2109 // ### KDE5: remove
2110 void KHTMLPart::setAlwaysHonourDoctype( bool b )
2111 {
2112  d->m_bStrictModeQuirk = !b;
2113 }
2114 
2115 void KHTMLPart::write( const QString &str )
2116 {
2117  if ( str.isNull() )
2118  return;
2119 
2120  if(d->m_bFirstData) {
2121  // determine the parse mode
2122  if (d->m_bStrictModeQuirk) {
2123  d->m_doc->setParseMode( DocumentImpl::Strict );
2124  d->m_bFirstData = false;
2125  } else {
2126  onFirstData();
2127  }
2128  }
2129  khtml::Tokenizer* t = d->m_doc->tokenizer();
2130  if(t)
2131  t->write( str, true );
2132 }
2133 
2134 void KHTMLPart::end()
2135 {
2136  if (d->m_doc) {
2137  if (d->m_decoder)
2138  {
2139  QString decoded=d->m_decoder->flush();
2140  if (d->m_bFirstData)
2141  onFirstData();
2142  if (!decoded.isEmpty())
2143  write(decoded);
2144  }
2145  d->m_doc->finishParsing();
2146  }
2147 }
2148 
2149 void KHTMLPart::onFirstData()
2150 {
2151  assert( d->m_bFirstData );
2152 
2153  // determine the parse mode
2154  d->m_doc->determineParseMode();
2155  d->m_bFirstData = false;
2156 
2157  // ### this is still quite hacky, but should work a lot better than the old solution
2158  // Note: decoder may be null if only write(QString) is used.
2159  if (d->m_decoder && d->m_decoder->visuallyOrdered())
2160  d->m_doc->setVisuallyOrdered();
2161  // ensure part and view shares zoom-level before styling
2162  updateZoomFactor();
2163  d->m_doc->recalcStyle( NodeImpl::Force );
2164 }
2165 
2166 bool KHTMLPart::doOpenStream( const QString& mimeType )
2167 {
2168  KMimeType::Ptr mime = KMimeType::mimeType(mimeType, KMimeType::ResolveAliases);
2169  if ( mime && ( mime->is( "text/html" ) || mime->is( "text/xml" ) ) )
2170  {
2171  begin( url() );
2172  return true;
2173  }
2174  return false;
2175 }
2176 
2177 bool KHTMLPart::doWriteStream( const QByteArray& data )
2178 {
2179  write( data.data(), data.size() );
2180  return true;
2181 }
2182 
2183 bool KHTMLPart::doCloseStream()
2184 {
2185  end();
2186  return true;
2187 }
2188 
2189 
2190 void KHTMLPart::paint(QPainter *p, const QRect &rc, int yOff, bool *more)
2191 {
2192  if (!d->m_view) return;
2193  d->m_view->paint(p, rc, yOff, more);
2194 }
2195 
2196 void KHTMLPart::stopAnimations()
2197 {
2198  if ( d->m_doc )
2199  d->m_doc->docLoader()->setShowAnimations( KHTMLSettings::KAnimationDisabled );
2200 
2201  ConstFrameIt it = d->m_frames.constBegin();
2202  const ConstFrameIt end = d->m_frames.constEnd();
2203  for (; it != end; ++it ) {
2204  if ( KHTMLPart* p = qobject_cast<KHTMLPart*>((*it)->m_part.data()) )
2205  p->stopAnimations();
2206  }
2207 }
2208 
2209 void KHTMLPart::resetFromScript()
2210 {
2211  closeUrl();
2212  d->m_bComplete = false;
2213  d->m_bLoadEventEmitted = false;
2214  disconnect(d->m_doc,SIGNAL(finishedParsing()),this,SLOT(slotFinishedParsing()));
2215  connect(d->m_doc,SIGNAL(finishedParsing()),this,SLOT(slotFinishedParsing()));
2216  d->m_doc->setParsing(true);
2217 
2218  emit started( 0L );
2219 }
2220 
2221 void KHTMLPart::slotFinishedParsing()
2222 {
2223  d->m_doc->setParsing(false);
2224  d->m_doc->dispatchHTMLEvent(EventImpl::KHTML_CONTENTLOADED_EVENT, true, false);
2225  checkEmitLoadEvent();
2226  disconnect(d->m_doc,SIGNAL(finishedParsing()),this,SLOT(slotFinishedParsing()));
2227 
2228  if (!d->m_view)
2229  return; // We are probably being destructed.
2230 
2231  checkCompleted();
2232 }
2233 
2234 void KHTMLPart::slotLoaderRequestStarted( khtml::DocLoader* dl, khtml::CachedObject *obj )
2235 {
2236  if ( obj && obj->type() == khtml::CachedObject::Image && d->m_doc && d->m_doc->docLoader() == dl ) {
2237  KHTMLPart* p = this;
2238  while ( p ) {
2239  KHTMLPart* const op = p;
2240  ++(p->d->m_totalObjectCount);
2241  p = p->parentPart();
2242  if ( !p && op->d->m_loadedObjects <= op->d->m_totalObjectCount
2243  && !op->d->m_progressUpdateTimer.isActive()) {
2244  op->d->m_progressUpdateTimer.setSingleShot( true );
2245  op->d->m_progressUpdateTimer.start( 200 );
2246  }
2247  }
2248  }
2249 }
2250 
2251 static bool isAncestorOrSamePart(KHTMLPart* p1, KHTMLPart* p2)
2252 {
2253  KHTMLPart* p = p2;
2254  do {
2255  if (p == p1)
2256  return true;
2257  } while ((p = p->parentPart()));
2258  return false;
2259 }
2260 
2261 void KHTMLPart::slotLoaderRequestDone( khtml::DocLoader* dl, khtml::CachedObject *obj )
2262 {
2263  if ( obj && obj->type() == khtml::CachedObject::Image && d->m_doc && d->m_doc->docLoader() == dl ) {
2264  KHTMLPart* p = this;
2265  while ( p ) {
2266  KHTMLPart* const op = p;
2267  ++(p->d->m_loadedObjects);
2268  p = p->parentPart();
2269  if ( !p && op->d->m_loadedObjects <= op->d->m_totalObjectCount && op->d->m_jobPercent <= 100
2270  && !op->d->m_progressUpdateTimer.isActive()) {
2271  op->d->m_progressUpdateTimer.setSingleShot( true );
2272  op->d->m_progressUpdateTimer.start( 200 );
2273  }
2274  }
2275  }
2277  // then our loading state can't possibly be affected : don't waste time checking for completion.
2278  if (!d->m_doc || !dl->doc()->part() || !isAncestorOrSamePart(this, dl->doc()->part()))
2279  return;
2280  checkCompleted();
2281 }
2282 
2283 void KHTMLPart::slotProgressUpdate()
2284 {
2285  int percent;
2286  if ( d->m_loadedObjects < d->m_totalObjectCount )
2287  percent = d->m_jobPercent / 4 + ( d->m_loadedObjects*300 ) / ( 4*d->m_totalObjectCount );
2288  else
2289  percent = d->m_jobPercent;
2290 
2291  if( d->m_bComplete )
2292  percent = 100;
2293 
2294  if (d->m_statusMessagesEnabled) {
2295  if( d->m_bComplete )
2296  emit d->m_extension->infoMessage( i18n( "Page loaded." ));
2297  else if ( d->m_loadedObjects < d->m_totalObjectCount && percent >= 75 )
2298  emit d->m_extension->infoMessage( i18np( "%1 Image of %2 loaded.", "%1 Images of %2 loaded.", d->m_loadedObjects, d->m_totalObjectCount) );
2299  }
2300 
2301  emit d->m_extension->loadingProgress( percent );
2302 }
2303 
2304 void KHTMLPart::slotJobSpeed( KJob* /*job*/, unsigned long speed )
2305 {
2306  d->m_jobspeed = speed;
2307  if (!parentPart())
2308  setStatusBarText(jsStatusBarText(), BarOverrideText);
2309 }
2310 
2311 void KHTMLPart::slotJobPercent( KJob* /*job*/, unsigned long percent )
2312 {
2313  d->m_jobPercent = percent;
2314 
2315  if ( !parentPart() ) {
2316  d->m_progressUpdateTimer.setSingleShot( true );
2317  d->m_progressUpdateTimer.start( 0 );
2318  }
2319 }
2320 
2321 void KHTMLPart::slotJobDone( KJob* /*job*/ )
2322 {
2323  d->m_jobPercent = 100;
2324 
2325  if ( !parentPart() ) {
2326  d->m_progressUpdateTimer.setSingleShot( true );
2327  d->m_progressUpdateTimer.start( 0 );
2328  }
2329 }
2330 
2331 void KHTMLPart::slotUserSheetStatDone( KJob *_job )
2332 {
2333  using namespace KIO;
2334 
2335  if ( _job->error() ) {
2336  showError( _job );
2337  return;
2338  }
2339 
2340  const UDSEntry entry = dynamic_cast<KIO::StatJob *>( _job )->statResult();
2341  const time_t lastModified = entry.numberValue( KIO::UDSEntry::UDS_MODIFICATION_TIME, -1 );
2342 
2343  // If the filesystem supports modification times, only reload the
2344  // user-defined stylesheet if necessary - otherwise always reload.
2345  if ( lastModified != static_cast<time_t>(-1) ) {
2346  if ( d->m_userStyleSheetLastModified >= lastModified ) {
2347  return;
2348  }
2349  d->m_userStyleSheetLastModified = lastModified;
2350  }
2351 
2352  setUserStyleSheet( KUrl( settings()->userStyleSheet() ) );
2353 }
2354 
2355 bool KHTMLPartPrivate::isFullyLoaded(bool* pendingRedirections) const
2356 {
2357  *pendingRedirections = false;
2358 
2359  // Any frame that hasn't completed yet ?
2360  ConstFrameIt it = m_frames.constBegin();
2361  const ConstFrameIt end = m_frames.constEnd();
2362  for (; it != end; ++it ) {
2363  if ( !(*it)->m_bCompleted || (*it)->m_run )
2364  {
2365  //kDebug( 6050 ) << this << " is waiting for " << (*it)->m_part;
2366  return false;
2367  }
2368  // Check for frames with pending redirections
2369  if ( (*it)->m_bPendingRedirection )
2370  *pendingRedirections = true;
2371  }
2372 
2373  // Any object that hasn't completed yet ?
2374  {
2375  ConstFrameIt oi = m_objects.constBegin();
2376  const ConstFrameIt oiEnd = m_objects.constEnd();
2377 
2378  for (; oi != oiEnd; ++oi )
2379  if ( !(*oi)->m_bCompleted )
2380  return false;
2381  }
2382 
2383  // Are we still parsing
2384  if ( m_doc && m_doc->parsing() )
2385  return false;
2386 
2387  // Still waiting for images/scripts from the loader ?
2388  int requests = 0;
2389  if ( m_doc && m_doc->docLoader() )
2390  requests = khtml::Cache::loader()->numRequests( m_doc->docLoader() );
2391 
2392  if ( requests > 0 )
2393  {
2394  //kDebug(6050) << "still waiting for images/scripts from the loader - requests:" << requests;
2395  return false;
2396  }
2397 
2398  return true;
2399 }
2400 
2401 void KHTMLPart::checkCompleted()
2402 {
2403 // kDebug( 6050 ) << this;
2404 // kDebug( 6050 ) << " parsing: " << (d->m_doc && d->m_doc->parsing());
2405 // kDebug( 6050 ) << " complete: " << d->m_bComplete;
2406 
2407  // restore the cursor position
2408  if (d->m_doc && !d->m_doc->parsing() && !d->m_focusNodeRestored)
2409  {
2410  if (d->m_focusNodeNumber >= 0)
2411  d->m_doc->setFocusNode(d->m_doc->nodeWithAbsIndex(d->m_focusNodeNumber));
2412 
2413  d->m_focusNodeRestored = true;
2414  }
2415 
2416  bool fullyLoaded, pendingChildRedirections;
2417  fullyLoaded = d->isFullyLoaded(&pendingChildRedirections);
2418 
2419  // Are we still loading, or already have done the relevant work?
2420  if (!fullyLoaded || d->m_bComplete)
2421  return;
2422 
2423  // OK, completed.
2424  // Now do what should be done when we are really completed.
2425  d->m_bComplete = true;
2426  d->m_cachePolicy = KProtocolManager::cacheControl(); // reset cache policy
2427  d->m_totalObjectCount = 0;
2428  d->m_loadedObjects = 0;
2429 
2430  KHTMLPart* p = this;
2431  while ( p ) {
2432  KHTMLPart* op = p;
2433  p = p->parentPart();
2434  if ( !p && !op->d->m_progressUpdateTimer.isActive()) {
2435  op->d->m_progressUpdateTimer.setSingleShot( true );
2436  op->d->m_progressUpdateTimer.start( 0 );
2437  }
2438  }
2439 
2440  checkEmitLoadEvent(); // if we didn't do it before
2441 
2442  bool pendingAction = false;
2443 
2444  if ( !d->m_redirectURL.isEmpty() )
2445  {
2446  // DA: Do not start redirection for frames here! That action is
2447  // deferred until the parent emits a completed signal.
2448  if ( parentPart() == 0 ) {
2449  //kDebug(6050) << this << " starting redirection timer";
2450  d->m_redirectionTimer.setSingleShot( true );
2451  d->m_redirectionTimer.start( qMax(0, 1000 * d->m_delayRedirect) );
2452  } else {
2453  //kDebug(6050) << this << " not toplevel -> not starting redirection timer. Waiting for slotParentCompleted.";
2454  }
2455 
2456  pendingAction = true;
2457  }
2458  else if ( pendingChildRedirections )
2459  {
2460  pendingAction = true;
2461  }
2462 
2463  // the view will emit completed on our behalf,
2464  // either now or at next repaint if one is pending
2465 
2466  //kDebug(6050) << this << " asks the view to emit completed. pendingAction=" << pendingAction;
2467  d->m_view->complete( pendingAction );
2468 
2469  // find the alternate stylesheets
2470  QStringList sheets;
2471  if (d->m_doc)
2472  sheets = d->m_doc->availableStyleSheets();
2473  sheets.prepend( i18n( "Automatic Detection" ) );
2474  d->m_paUseStylesheet->setItems( sheets );
2475 
2476  d->m_paUseStylesheet->setEnabled( sheets.count() > 2);
2477  if (sheets.count() > 2)
2478  {
2479  d->m_paUseStylesheet->setCurrentItem(qMax(sheets.indexOf(d->m_sheetUsed), 0));
2480  slotUseStylesheet();
2481  }
2482 
2483  setJSDefaultStatusBarText(QString());
2484 
2485 #ifdef SPEED_DEBUG
2486  if (!parentPart())
2487  kDebug(6080) << "DONE:" <<d->m_parsetime.elapsed();
2488 #endif
2489 }
2490 
2491 void KHTMLPart::checkEmitLoadEvent()
2492 {
2493  bool fullyLoaded, pendingChildRedirections;
2494  fullyLoaded = d->isFullyLoaded(&pendingChildRedirections);
2495 
2496  // ### might want to wait on pendingChildRedirections here, too
2497  if ( d->m_bLoadEventEmitted || !d->m_doc || !fullyLoaded ) return;
2498 
2499  d->m_bLoadEventEmitted = true;
2500  if (d->m_doc)
2501  d->m_doc->close();
2502 }
2503 
2504 const KHTMLSettings *KHTMLPart::settings() const
2505 {
2506  return d->m_settings;
2507 }
2508 
2509 #ifndef KDE_NO_COMPAT // KDE5: remove this ifndef, keep the method (renamed to baseUrl)
2510 KUrl KHTMLPart::baseURL() const
2511 {
2512  if ( !d->m_doc ) return KUrl();
2513 
2514  return d->m_doc->baseURL();
2515 }
2516 #endif
2517 
2518 KUrl KHTMLPart::completeURL( const QString &url )
2519 {
2520  if ( !d->m_doc ) return KUrl( url );
2521 
2522 #if 0
2523  if (d->m_decoder)
2524  return KUrl(d->m_doc->completeURL(url), d->m_decoder->codec()->mibEnum());
2525 #endif
2526 
2527  return KUrl( d->m_doc->completeURL( url ) );
2528 }
2529 
2530 QString KHTMLPartPrivate::codeForJavaScriptURL(const QString &u)
2531 {
2532  return KUrl::fromPercentEncoding( u.right( u.length() - 11 ).toUtf8() );
2533 }
2534 
2535 void KHTMLPartPrivate::executeJavascriptURL(const QString &u)
2536 {
2537  QString script = codeForJavaScriptURL(u);
2538  kDebug( 6050 ) << "script=" << script;
2539  QVariant res = q->executeScript( DOM::Node(), script );
2540  if ( res.type() == QVariant::String ) {
2541  q->begin( q->url() );
2542  q->setAlwaysHonourDoctype(); // Disable public API compat; it messes with doctype
2543  q->write( res.toString() );
2544  q->end();
2545  }
2546  emit q->completed();
2547 }
2548 
2549 bool KHTMLPartPrivate::isJavaScriptURL(const QString& url)
2550 {
2551  return url.indexOf( QLatin1String( "javascript:" ), 0, Qt::CaseInsensitive ) == 0;
2552 }
2553 
2554 // Called by ecma/kjs_window in case of redirections from Javascript,
2555 // and by xml/dom_docimpl.cpp in case of http-equiv meta refresh.
2556 void KHTMLPart::scheduleRedirection( int delay, const QString &url, bool doLockHistory )
2557 {
2558  kDebug(6050) << "delay=" << delay << " url=" << url << " from=" << this->url() << "parent=" << parentPart();
2559  kDebug(6050) << "current redirectURL=" << d->m_redirectURL << " with delay " << d->m_delayRedirect;
2560 
2561  // In case of JS redirections, some, such as jump to anchors, and javascript:
2562  // evaluation should actually be handled immediately, and not waiting until
2563  // the end of the script. (Besides, we don't want to abort the tokenizer for those)
2564  if ( delay == -1 && d->isInPageURL(url) ) {
2565  d->executeInPageURL(url, doLockHistory);
2566  return;
2567  }
2568 
2569  if( delay < 24*60*60 &&
2570  ( d->m_redirectURL.isEmpty() || delay <= d->m_delayRedirect) ) {
2571  d->m_delayRedirect = delay;
2572  d->m_redirectURL = url;
2573  d->m_redirectLockHistory = doLockHistory;
2574  kDebug(6050) << " d->m_bComplete=" << d->m_bComplete;
2575 
2576  if ( d->m_bComplete ) {
2577  d->m_redirectionTimer.stop();
2578  d->m_redirectionTimer.setSingleShot( true );
2579  d->m_redirectionTimer.start( qMax(0, 1000 * d->m_delayRedirect) );
2580  }
2581  }
2582 }
2583 
2584 void KHTMLPartPrivate::clearRedirection()
2585 {
2586  m_delayRedirect = 0;
2587  m_redirectURL.clear();
2588  m_redirectionTimer.stop();
2589 }
2590 
2591 void KHTMLPart::slotRedirect()
2592 {
2593  kDebug(6050) << this;
2594  QString u = d->m_redirectURL;
2595  KUrl url( u );
2596  d->clearRedirection();
2597 
2598  if ( d->isInPageURL(u) )
2599  {
2600  d->executeInPageURL(u, d->m_redirectLockHistory);
2601  return;
2602  }
2603 
2604  KParts::OpenUrlArguments args;
2605  KUrl cUrl( this->url() );
2606 
2607  // handle windows opened by JS
2608  if ( openedByJS() && d->m_opener )
2609  cUrl = d->m_opener->url();
2610 
2611  if (!KAuthorized::authorizeUrlAction("redirect", cUrl, url))
2612  {
2613  kWarning(6050) << "KHTMLPart::scheduleRedirection: Redirection from " << cUrl << " to " << url << " REJECTED!";
2614  emit completed();
2615  return;
2616  }
2617 
2618  if ( url.equals(this->url(),
2619  KUrl::CompareWithoutTrailingSlash | KUrl::CompareWithoutFragment | KUrl::AllowEmptyPath) )
2620  {
2621  args.metaData().insert("referrer", d->m_pageReferrer);
2622  }
2623 
2624  // For javascript and META-tag based redirections:
2625  // - We don't take cross-domain-ness in consideration if we are the
2626  // toplevel frame because the new URL may be in a different domain as the current URL
2627  // but that's ok.
2628  // - If we are not the toplevel frame then we check against the toplevelURL()
2629  if (parentPart())
2630  args.metaData().insert("cross-domain", toplevelURL().url());
2631 
2632  KParts::BrowserArguments browserArgs;
2633  browserArgs.setLockHistory( d->m_redirectLockHistory );
2634  // _self: make sure we don't use any <base target=>'s
2635 
2636  if ( !urlSelected( u, 0, 0, "_self", args, browserArgs ) ) {
2637  // urlSelected didn't open a url, so emit completed ourselves
2638  emit completed();
2639  }
2640 }
2641 
2642 void KHTMLPart::slotRedirection(KIO::Job*, const KUrl& url)
2643 {
2644  // the slave told us that we got redirected
2645  //kDebug( 6050 ) << "redirection by KIO to" << url;
2646  emit d->m_extension->setLocationBarUrl( url.prettyUrl() );
2647  d->m_workingURL = url;
2648 }
2649 
2650 bool KHTMLPart::setEncoding( const QString &name, bool override )
2651 {
2652  d->m_encoding = name;
2653  d->m_haveEncoding = override;
2654 
2655  if( !url().isEmpty() ) {
2656  // reload document
2657  closeUrl();
2658  KUrl oldUrl = url();
2659  setUrl(KUrl());
2660  d->m_restored = true;
2661  openUrl(oldUrl);
2662  d->m_restored = false;
2663  }
2664 
2665  return true;
2666 }
2667 
2668 QString KHTMLPart::encoding() const
2669 {
2670  if(d->m_haveEncoding && !d->m_encoding.isEmpty())
2671  return d->m_encoding;
2672 
2673  if(d->m_decoder && d->m_decoder->encoding())
2674  return QString(d->m_decoder->encoding());
2675 
2676  return defaultEncoding();
2677 }
2678 
2679 QString KHTMLPart::defaultEncoding() const
2680 {
2681  QString encoding = settings()->encoding();
2682  if ( !encoding.isEmpty() )
2683  return encoding;
2684  // HTTP requires the default encoding to be latin1, when neither
2685  // the user nor the page requested a particular encoding.
2686  if ( url().protocol().startsWith( "http" ) )
2687  return "iso-8859-1";
2688  else
2689  return KGlobal::locale()->encoding();
2690 }
2691 
2692 void KHTMLPart::setUserStyleSheet(const KUrl &url)
2693 {
2694  if ( d->m_doc && d->m_doc->docLoader() )
2695  (void) new khtml::PartStyleSheetLoader(this, url.url(), d->m_doc->docLoader());
2696 }
2697 
2698 void KHTMLPart::setUserStyleSheet(const QString &styleSheet)
2699 {
2700  if ( d->m_doc )
2701  d->m_doc->setUserStyleSheet( styleSheet );
2702 }
2703 
2704 bool KHTMLPart::gotoAnchor( const QString &name )
2705 {
2706  if (!d->m_doc)
2707  return false;
2708 
2709  HTMLCollectionImpl *anchors =
2710  new HTMLCollectionImpl( d->m_doc, HTMLCollectionImpl::DOC_ANCHORS);
2711  anchors->ref();
2712  NodeImpl *n = anchors->namedItem(name);
2713  anchors->deref();
2714 
2715  if(!n) {
2716  n = d->m_doc->getElementById( name );
2717  }
2718 
2719  d->m_doc->setCSSTarget(n); // Setting to null will clear the current target.
2720 
2721  // Implement the rule that "" and "top" both mean top of page as in other browsers.
2722  bool quirkyName = !n && !d->m_doc->inStrictMode() && (name.isEmpty() || name.toLower() == "top");
2723 
2724  if (quirkyName) {
2725  d->m_view->setContentsPos( d->m_view->contentsX(), 0);
2726  return true;
2727  } else if (!n) {
2728  kDebug(6050) << name << "not found";
2729  return false;
2730  }
2731 
2732  int x = 0, y = 0;
2733  int gox, dummy;
2734  HTMLElementImpl *a = static_cast<HTMLElementImpl *>(n);
2735 
2736  a->getUpperLeftCorner(x, y);
2737  if (x <= d->m_view->contentsX())
2738  gox = x - 10;
2739  else {
2740  gox = d->m_view->contentsX();
2741  if ( x + 10 > d->m_view->contentsX()+d->m_view->visibleWidth()) {
2742  a->getLowerRightCorner(x, dummy);
2743  gox = x - d->m_view->visibleWidth() + 10;
2744  }
2745  }
2746 
2747  d->m_view->setContentsPos(gox, y);
2748 
2749  return true;
2750 }
2751 
2752 bool KHTMLPart::nextAnchor()
2753 {
2754  if (!d->m_doc)
2755  return false;
2756  d->m_view->focusNextPrevNode ( true );
2757 
2758  return true;
2759 }
2760 
2761 bool KHTMLPart::prevAnchor()
2762 {
2763  if (!d->m_doc)
2764  return false;
2765  d->m_view->focusNextPrevNode ( false );
2766 
2767  return true;
2768 }
2769 
2770 void KHTMLPart::setStandardFont( const QString &name )
2771 {
2772  d->m_settings->setStdFontName(name);
2773 }
2774 
2775 void KHTMLPart::setFixedFont( const QString &name )
2776 {
2777  d->m_settings->setFixedFontName(name);
2778 }
2779 
2780 void KHTMLPart::setURLCursor( const QCursor &c )
2781 {
2782  d->m_linkCursor = c;
2783 }
2784 
2785 QCursor KHTMLPart::urlCursor() const
2786 {
2787  return d->m_linkCursor;
2788 }
2789 
2790 bool KHTMLPart::onlyLocalReferences() const
2791 {
2792  return d->m_onlyLocalReferences;
2793 }
2794 
2795 void KHTMLPart::setOnlyLocalReferences(bool enable)
2796 {
2797  d->m_onlyLocalReferences = enable;
2798 }
2799 
2800 bool KHTMLPart::forcePermitLocalImages() const
2801 {
2802  return d->m_forcePermitLocalImages;
2803 }
2804 
2805 void KHTMLPart::setForcePermitLocalImages(bool enable)
2806 {
2807  d->m_forcePermitLocalImages = enable;
2808 }
2809 
2810 void KHTMLPartPrivate::setFlagRecursively(
2811  bool KHTMLPartPrivate::*flag, bool value)
2812 {
2813  // first set it on the current one
2814  this->*flag = value;
2815 
2816  // descend into child frames recursively
2817  {
2818  QList<khtml::ChildFrame*>::Iterator it = m_frames.begin();
2819  const QList<khtml::ChildFrame*>::Iterator itEnd = m_frames.end();
2820  for (; it != itEnd; ++it) {
2821  KHTMLPart* const part = qobject_cast<KHTMLPart *>( (*it)->m_part.data() );
2822  if (part)
2823  part->d->setFlagRecursively(flag, value);
2824  }/*next it*/
2825  }
2826  // do the same again for objects
2827  {
2828  QList<khtml::ChildFrame*>::Iterator it = m_objects.begin();
2829  const QList<khtml::ChildFrame*>::Iterator itEnd = m_objects.end();
2830  for (; it != itEnd; ++it) {
2831  KHTMLPart* const part = qobject_cast<KHTMLPart *>( (*it)->m_part.data() );
2832  if (part)
2833  part->d->setFlagRecursively(flag, value);
2834  }/*next it*/
2835  }
2836 }
2837 
2838 void KHTMLPart::initCaret()
2839 {
2840  // initialize caret if not used yet
2841  if (d->editor_context.m_selection.state() == Selection::NONE) {
2842  if (d->m_doc) {
2843  NodeImpl *node;
2844  if (d->m_doc->isHTMLDocument()) {
2845  HTMLDocumentImpl* htmlDoc = static_cast<HTMLDocumentImpl*>(d->m_doc);
2846  node = htmlDoc->body();
2847  } else
2848  node = d->m_doc;
2849  if (!node) return;
2850  d->editor_context.m_selection.moveTo(Position(node, 0));
2851  d->editor_context.m_selection.setNeedsLayout();
2852  d->editor_context.m_selection.needsCaretRepaint();
2853  }
2854  }
2855 }
2856 
2857 static void setCaretInvisibleIfNeeded(KHTMLPart *part)
2858 {
2859  // On contenteditable nodes, don't hide the caret
2860  if (!khtml::KHTMLPartAccessor::caret(part).caretPos().node()->isContentEditable())
2861  part->setCaretVisible(false);
2862 }
2863 
2864 void KHTMLPart::setCaretMode(bool enable)
2865 {
2866  kDebug(6200) << enable;
2867  if (isCaretMode() == enable) return;
2868  d->setFlagRecursively(&KHTMLPartPrivate::m_caretMode, enable);
2869  // FIXME: this won't work on frames as expected
2870  if (!isEditable()) {
2871  if (enable) {
2872  initCaret();
2873  setCaretVisible(true);
2874 // view()->ensureCaretVisible();
2875  } else {
2876  setCaretInvisibleIfNeeded(this);
2877  }
2878  }
2879 }
2880 
2881 bool KHTMLPart::isCaretMode() const
2882 {
2883  return d->m_caretMode;
2884 }
2885 
2886 void KHTMLPart::setEditable(bool enable)
2887 {
2888  if (isEditable() == enable) return;
2889  d->setFlagRecursively(&KHTMLPartPrivate::m_designMode, enable);
2890  // FIXME: this won't work on frames as expected
2891  if (!isCaretMode()) {
2892  if (enable) {
2893  initCaret();
2894  setCaretVisible(true);
2895 // view()->ensureCaretVisible();
2896  } else
2897  setCaretInvisibleIfNeeded(this);
2898  }
2899 }
2900 
2901 bool KHTMLPart::isEditable() const
2902 {
2903  return d->m_designMode;
2904 }
2905 
2906 khtml::EditorContext *KHTMLPart::editorContext() const {
2907  return &d->editor_context;
2908 }
2909 
2910 void KHTMLPart::setCaretPosition(DOM::Node node, long offset, bool extendSelection)
2911 {
2912  Q_UNUSED(node);
2913  Q_UNUSED(offset);
2914  Q_UNUSED(extendSelection);
2915 #ifndef KHTML_NO_CARET
2916 #if 0
2917  kDebug(6200) << "node: " << node.handle() << " nodeName: "
2918  << node.nodeName().string() << " offset: " << offset
2919  << " extendSelection " << extendSelection;
2920  if (view()->moveCaretTo(node.handle(), offset, !extendSelection))
2921  emitSelectionChanged();
2922  view()->ensureCaretVisible();
2923 #endif
2924 #endif // KHTML_NO_CARET
2925 }
2926 
2927 KHTMLPart::CaretDisplayPolicy KHTMLPart::caretDisplayPolicyNonFocused() const
2928 {
2929 #if 0
2930 #ifndef KHTML_NO_CARET
2931  return (CaretDisplayPolicy)view()->caretDisplayPolicyNonFocused();
2932 #else // KHTML_NO_CARET
2933  return CaretInvisible;
2934 #endif // KHTML_NO_CARET
2935 #endif
2936  return CaretInvisible;
2937 }
2938 
2939 void KHTMLPart::setCaretDisplayPolicyNonFocused(CaretDisplayPolicy policy)
2940 {
2941  Q_UNUSED(policy);
2942 #if 0
2943 #ifndef KHTML_NO_CARET
2944  view()->setCaretDisplayPolicyNonFocused(policy);
2945 #endif // KHTML_NO_CARET
2946 #endif
2947 }
2948 
2949 void KHTMLPart::setCaretVisible(bool show)
2950 {
2951  if (show) {
2952  NodeImpl *caretNode = d->editor_context.m_selection.caretPos().node();
2953  if (isCaretMode() || (caretNode && caretNode->isContentEditable())) {
2954  invalidateSelection();
2955  enableFindAheadActions(false);
2956  }
2957  } else {
2958 
2959  if (d->editor_context.m_caretBlinkTimer >= 0)
2960  killTimer(d->editor_context.m_caretBlinkTimer);
2961  clearCaretRectIfNeeded();
2962 
2963  }
2964 }
2965 
2966 void KHTMLPart::findTextBegin()
2967 {
2968  d->m_find.findTextBegin();
2969 }
2970 
2971 bool KHTMLPart::initFindNode( bool selection, bool reverse, bool fromCursor )
2972 {
2973  return d->m_find.initFindNode(selection, reverse, fromCursor);
2974 }
2975 
2976 void KHTMLPart::slotFind()
2977 {
2978  KParts::ReadOnlyPart *part = currentFrame();
2979  if (!part)
2980  return;
2981  if (!part->inherits("KHTMLPart") )
2982  {
2983  kError(6000) << "part is a" << part->metaObject()->className() << ", can't do a search into it";
2984  return;
2985  }
2986  static_cast<KHTMLPart *>( part )->findText();
2987 }
2988 
2989 void KHTMLPart::slotFindNext()
2990 {
2991  KParts::ReadOnlyPart *part = currentFrame();
2992  if (!part)
2993  return;
2994  if (!part->inherits("KHTMLPart") )
2995  {
2996  kError(6000) << "part is a" << part->metaObject()->className() << ", can't do a search into it";
2997  return;
2998  }
2999  static_cast<KHTMLPart *>( part )->findTextNext();
3000 }
3001 
3002 void KHTMLPart::slotFindPrev()
3003 {
3004  KParts::ReadOnlyPart *part = currentFrame();
3005  if (!part)
3006  return;
3007  if (!part->inherits("KHTMLPart") )
3008  {
3009  kError(6000) << "part is a" << part->metaObject()->className() << ", can't do a search into it";
3010  return;
3011  }
3012  static_cast<KHTMLPart *>( part )->findTextNext( true ); // reverse
3013 }
3014 
3015 void KHTMLPart::slotFindDone()
3016 {
3017  // ### remove me
3018 }
3019 
3020 void KHTMLPart::slotFindAheadText()
3021 {
3022  KHTMLPart *part = qobject_cast<KHTMLPart*>(currentFrame());
3023  if (!part)
3024  return;
3025  part->findText();
3026  KHTMLFindBar* findBar = part->d->m_find.findBar();
3027  findBar->setOptions(findBar->options() & ~FindLinksOnly);
3028 }
3029 
3030 void KHTMLPart::slotFindAheadLink()
3031 {
3032  KHTMLPart *part = qobject_cast<KHTMLPart*>(currentFrame());
3033  if (!part)
3034  return;
3035  part->findText();
3036  KHTMLFindBar* findBar = part->d->m_find.findBar();
3037  findBar->setOptions(findBar->options() | FindLinksOnly);
3038 }
3039 
3040 void KHTMLPart::enableFindAheadActions( bool )
3041 {
3042  // ### remove me
3043 }
3044 
3045 void KHTMLPart::slotFindDialogDestroyed()
3046 {
3047  // ### remove me
3048 }
3049 
3050 void KHTMLPart::findText()
3051 {
3052  if (parentPart())
3053  return parentPart()->findText();
3054  d->m_find.activate();
3055 }
3056 
3057 void KHTMLPart::findText( const QString &str, long options, QWidget *parent, KFindDialog *findDialog )
3058 {
3059  if (parentPart())
3060  return parentPart()->findText(str, options, parent, findDialog);
3061  d->m_find.createNewKFind(str, options, parent, findDialog );
3062 }
3063 
3064 // New method
3065 bool KHTMLPart::findTextNext( bool reverse )
3066 {
3067  if (parentPart())
3068  return parentPart()->findTextNext( reverse );
3069  return d->m_find.findTextNext( reverse );
3070 }
3071 
3072 bool KHTMLPart::pFindTextNextInThisFrame( bool reverse )
3073 {
3074  return d->m_find.findTextNext( reverse );
3075 }
3076 
3077 QString KHTMLPart::selectedTextAsHTML() const
3078 {
3079  const Selection &sel = d->editor_context.m_selection;
3080  if(!hasSelection()) {
3081  kDebug() << "Selection is not valid. Returning empty selection";
3082  return QString();
3083  }
3084  if(sel.start().offset() < 0 || sel.end().offset() < 0) {
3085  kDebug() << "invalid values for end/startOffset " << sel.start().offset() << " " << sel.end().offset();
3086  return QString();
3087  }
3088  DOM::Range r = selection();
3089  if(r.isNull() || r.isDetached())
3090  return QString();
3091  int exceptioncode = 0; //ignore the result
3092  return r.handle()->toHTML(exceptioncode).string();
3093 }
3094 
3095 QString KHTMLPart::selectedText() const
3096 {
3097  bool hasNewLine = true;
3098  bool seenTDTag = false;
3099  QString text;
3100  const Selection &sel = d->editor_context.m_selection;
3101  DOM::Node n = sel.start().node();
3102  while(!n.isNull()) {
3103  if(n.nodeType() == DOM::Node::TEXT_NODE && n.handle()->renderer()) {
3104  DOM::DOMStringImpl *dstr = static_cast<DOM::TextImpl*>(n.handle())->renderString();
3105  QString str(dstr->s, dstr->l);
3106  if(!str.isEmpty()) {
3107  if(seenTDTag) {
3108  text += " ";
3109  seenTDTag = false;
3110  }
3111  hasNewLine = false;
3112  if(n == sel.start().node() && n == sel.end().node()) {
3113  int s = khtml::RenderPosition::fromDOMPosition(sel.start()).renderedOffset();
3114  int e = khtml::RenderPosition::fromDOMPosition(sel.end()).renderedOffset();
3115  text = str.mid(s, e-s);
3116  } else if(n == sel.start().node()) {
3117  text = str.mid(khtml::RenderPosition::fromDOMPosition(sel.start()).renderedOffset());
3118  } else if(n == sel.end().node()) {
3119  text += str.left(khtml::RenderPosition::fromDOMPosition(sel.end()).renderedOffset());
3120  } else
3121  text += str;
3122  }
3123  }
3124  else {
3125  // This is our simple HTML -> ASCII transformation:
3126  unsigned short id = n.elementId();
3127  switch(id) {
3128  case ID_TEXTAREA:
3129  text += static_cast<HTMLTextAreaElementImpl*>(n.handle())->value().string();
3130  break;
3131  case ID_INPUT:
3132  if (static_cast<HTMLInputElementImpl*>(n.handle())->inputType() != HTMLInputElementImpl::PASSWORD)
3133  text += static_cast<HTMLInputElementImpl*>(n.handle())->value().string();
3134  break;
3135  case ID_SELECT:
3136  text += static_cast<HTMLSelectElementImpl*>(n.handle())->value().string();
3137  break;
3138  case ID_BR:
3139  text += "\n";
3140  hasNewLine = true;
3141  break;
3142  case ID_IMG:
3143  text += static_cast<HTMLImageElementImpl*>(n.handle())->altText().string();
3144  break;
3145  case ID_TD:
3146  break;
3147  case ID_TH:
3148  case ID_HR:
3149  case ID_OL:
3150  case ID_UL:
3151  case ID_LI:
3152  case ID_DD:
3153  case ID_DL:
3154  case ID_DT:
3155  case ID_PRE:
3156  case ID_LISTING:
3157  case ID_BLOCKQUOTE:
3158  case ID_DIV:
3159  if (!hasNewLine)
3160  text += "\n";
3161  hasNewLine = true;
3162  break;
3163  case ID_P:
3164  case ID_TR:
3165  case ID_H1:
3166  case ID_H2:
3167  case ID_H3:
3168  case ID_H4:
3169  case ID_H5:
3170  case ID_H6:
3171  if (!hasNewLine)
3172  text += "\n";
3173  hasNewLine = true;
3174  break;
3175  }
3176  }
3177  if(n == sel.end().node()) break;
3178  DOM::Node next = n.firstChild();
3179  if(next.isNull()) next = n.nextSibling();
3180  while( next.isNull() && !n.parentNode().isNull() ) {
3181  n = n.parentNode();
3182  next = n.nextSibling();
3183  unsigned short id = n.elementId();
3184  switch(id) {
3185  case ID_TD:
3186  seenTDTag = true; //Add two spaces after a td if then followed by text.
3187  break;
3188  case ID_TH:
3189  case ID_HR:
3190  case ID_OL:
3191  case ID_UL:
3192  case ID_LI:
3193  case ID_DD:
3194  case ID_DL:
3195  case ID_DT:
3196  case ID_PRE:
3197  case ID_LISTING:
3198  case ID_BLOCKQUOTE:
3199  case ID_DIV:
3200  seenTDTag = false;
3201  if (!hasNewLine)
3202  text += "\n";
3203  hasNewLine = true;
3204  break;
3205  case ID_P:
3206  case ID_TR:
3207  case ID_H1:
3208  case ID_H2:
3209  case ID_H3:
3210  case ID_H4:
3211  case ID_H5:
3212  case ID_H6:
3213  if (!hasNewLine)
3214  text += "\n";
3215 // text += "\n";
3216  hasNewLine = true;
3217  break;
3218  }
3219  }
3220 
3221  n = next;
3222  }
3223 
3224  if(text.isEmpty())
3225  return QString();
3226 
3227  int start = 0;
3228  int end = text.length();
3229 
3230  // Strip leading LFs
3231  while ((start < end) && (text[start] == '\n'))
3232  ++start;
3233 
3234  // Strip excessive trailing LFs
3235  while ((start < (end-1)) && (text[end-1] == '\n') && (text[end-2] == '\n'))
3236  --end;
3237 
3238  return text.mid(start, end-start);
3239 }
3240 
3241 QString KHTMLPart::simplifiedSelectedText() const
3242 {
3243  QString text = selectedText();
3244  text.replace(QChar(0xa0), ' ');
3245  // remove leading and trailing whitespace
3246  while (!text.isEmpty() && text[0].isSpace())
3247  text = text.mid(1);
3248  while (!text.isEmpty() && text[text.length()-1].isSpace())
3249  text.truncate(text.length()-1);
3250  return text;
3251 }
3252 
3253 bool KHTMLPart::hasSelection() const
3254 {
3255  return !d->editor_context.m_selection.isEmpty() && !d->editor_context.m_selection.isCollapsed();
3256 }
3257 
3258 DOM::Range KHTMLPart::selection() const
3259 {
3260  return d->editor_context.m_selection.toRange();
3261 }
3262 
3263 void KHTMLPart::selection(DOM::Node &s, long &so, DOM::Node &e, long &eo) const
3264 {
3265  DOM::Range r = d->editor_context.m_selection.toRange();
3266  s = r.startContainer();
3267  so = r.startOffset();
3268  e = r.endContainer();
3269  eo = r.endOffset();
3270 }
3271 
3272 void KHTMLPart::setSelection( const DOM::Range &r )
3273 {
3274  setCaret(r);
3275 }
3276 
3277 const Selection &KHTMLPart::caret() const
3278 {
3279  return d->editor_context.m_selection;
3280 }
3281 
3282 const Selection &KHTMLPart::dragCaret() const
3283 {
3284  return d->editor_context.m_dragCaret;
3285 }
3286 
3287 void KHTMLPart::setCaret(const Selection &s, bool closeTyping)
3288 {
3289  if (d->editor_context.m_selection != s) {
3290  clearCaretRectIfNeeded();
3291  setFocusNodeIfNeeded(s);
3292  d->editor_context.m_selection = s;
3293  notifySelectionChanged(closeTyping);
3294  }
3295 }
3296 
3297 void KHTMLPart::setDragCaret(const DOM::Selection &dragCaret)
3298 {
3299  if (d->editor_context.m_dragCaret != dragCaret) {
3300  d->editor_context.m_dragCaret.needsCaretRepaint();
3301  d->editor_context.m_dragCaret = dragCaret;
3302  d->editor_context.m_dragCaret.needsCaretRepaint();
3303  }
3304 }
3305 
3306 void KHTMLPart::clearSelection()
3307 {
3308  clearCaretRectIfNeeded();
3309  setFocusNodeIfNeeded(d->editor_context.m_selection);
3310 #ifdef APPLE_CHANGES
3311  d->editor_context.m_selection.clear();
3312 #else
3313  d->editor_context.m_selection.collapse();
3314 #endif
3315  notifySelectionChanged();
3316 }
3317 
3318 void KHTMLPart::invalidateSelection()
3319 {
3320  clearCaretRectIfNeeded();
3321  d->editor_context.m_selection.setNeedsLayout();
3322  selectionLayoutChanged();
3323 }
3324 
3325 void KHTMLPart::setSelectionVisible(bool flag)
3326 {
3327  if (d->editor_context.m_caretVisible == flag)
3328  return;
3329 
3330  clearCaretRectIfNeeded();
3331  setFocusNodeIfNeeded(d->editor_context.m_selection);
3332  d->editor_context.m_caretVisible = flag;
3333 // notifySelectionChanged();
3334 }
3335 
3336 #if 1
3337 void KHTMLPart::slotClearSelection()
3338 {
3339  if (!isCaretMode()
3340  && d->editor_context.m_selection.state() != Selection::NONE
3341  && !d->editor_context.m_selection.caretPos().node()->isContentEditable())
3342  clearCaretRectIfNeeded();
3343  bool hadSelection = hasSelection();
3344 #ifdef APPLE_CHANGES
3345  d->editor_context.m_selection.clear();
3346 #else
3347  d->editor_context.m_selection.collapse();
3348 #endif
3349  if (hadSelection)
3350  notifySelectionChanged();
3351 }
3352 #endif
3353 
3354 void KHTMLPart::clearCaretRectIfNeeded()
3355 {
3356  if (d->editor_context.m_caretPaint) {
3357  d->editor_context.m_caretPaint = false;
3358  d->editor_context.m_selection.needsCaretRepaint();
3359  }
3360 }
3361 
3362 void KHTMLPart::setFocusNodeIfNeeded(const Selection &s)
3363 {
3364  if (!xmlDocImpl() || s.state() == Selection::NONE)
3365  return;
3366 
3367  NodeImpl *n = s.start().node();
3368  NodeImpl *target = (n && n->isContentEditable()) ? n : 0;
3369  if (!target) {
3370  while (n && n != s.end().node()) {
3371  if (n->isContentEditable()) {
3372  target = n;
3373  break;
3374  }
3375  n = n->traverseNextNode();
3376  }
3377  }
3378  assert(target == 0 || target->isContentEditable());
3379 
3380  if (target) {
3381  for ( ; target && !target->isFocusable(); target = target->parentNode())
3382  {}
3383  if (target && target->isMouseFocusable())
3384  xmlDocImpl()->setFocusNode(target);
3385  else if (!target || !target->focused())
3386  xmlDocImpl()->setFocusNode(0);
3387  }
3388 }
3389 
3390 void KHTMLPart::selectionLayoutChanged()
3391 {
3392  // kill any caret blink timer now running
3393  if (d->editor_context.m_caretBlinkTimer >= 0) {
3394  killTimer(d->editor_context.m_caretBlinkTimer);
3395  d->editor_context.m_caretBlinkTimer = -1;
3396  }
3397 
3398  // see if a new caret blink timer needs to be started
3399  if (d->editor_context.m_caretVisible
3400  && d->editor_context.m_selection.state() != Selection::NONE) {
3401  d->editor_context.m_caretPaint = isCaretMode()
3402  || d->editor_context.m_selection.caretPos().node()->isContentEditable();
3403  if (d->editor_context.m_caretBlinks && d->editor_context.m_caretPaint)
3404  d->editor_context.m_caretBlinkTimer = startTimer(qApp->cursorFlashTime() / 2);
3405  d->editor_context.m_selection.needsCaretRepaint();
3406  // make sure that caret is visible
3407  QRect r(d->editor_context.m_selection.getRepaintRect());
3408  if (d->editor_context.m_caretPaint)
3409  d->m_view->ensureVisible(r.x(), r.y());
3410  }
3411 
3412  if (d->m_doc)
3413  d->m_doc->updateSelection();
3414 
3415  // Always clear the x position used for vertical arrow navigation.
3416  // It will be restored by the vertical arrow navigation code if necessary.
3417  d->editor_context.m_xPosForVerticalArrowNavigation = d->editor_context.NoXPosForVerticalArrowNavigation;
3418 }
3419 
3420 void KHTMLPart::notifySelectionChanged(bool closeTyping)
3421 {
3422  Editor *ed = d->editor_context.m_editor;
3423  selectionLayoutChanged();
3424  if (ed) {
3425  ed->clearTypingStyle();
3426 
3427  if (closeTyping)
3428  ed->closeTyping();
3429  }
3430 
3431  emitSelectionChanged();
3432 }
3433 
3434 void KHTMLPart::timerEvent(QTimerEvent *e)
3435 {
3436  if (e->timerId() == d->editor_context.m_caretBlinkTimer) {
3437  if (d->editor_context.m_caretBlinks &&
3438  d->editor_context.m_selection.state() != Selection::NONE) {
3439  d->editor_context.m_caretPaint = !d->editor_context.m_caretPaint;
3440  d->editor_context.m_selection.needsCaretRepaint();
3441  }
3442  } else if (e->timerId() == d->m_DNSPrefetchTimer) {
3443  // kDebug( 6050 ) << "will lookup " << d->m_DNSPrefetchQueue.head() << d->m_numDNSPrefetchedNames;
3444  KIO::HostInfo::prefetchHost( d->m_DNSPrefetchQueue.dequeue() );
3445  if (d->m_DNSPrefetchQueue.isEmpty()) {
3446  killTimer( d->m_DNSPrefetchTimer );
3447  d->m_DNSPrefetchTimer = -1;
3448  }
3449  } else if (e->timerId() == d->m_DNSTTLTimer) {
3450  foreach (const QString &name, d->m_lookedupHosts)
3451  d->m_DNSPrefetchQueue.enqueue(name);
3452  if (d->m_DNSPrefetchTimer <= 0)
3453  d->m_DNSPrefetchTimer = startTimer( sDNSPrefetchTimerDelay );
3454  }
3455 }
3456 
3457 bool KHTMLPart::mayPrefetchHostname( const QString& name )
3458 {
3459  if (d->m_bDNSPrefetch == DNSPrefetchDisabled)
3460  return false;
3461 
3462  if (d->m_numDNSPrefetchedNames >= sMaxDNSPrefetchPerPage)
3463  return false;
3464 
3465  if (d->m_bDNSPrefetch == DNSPrefetchOnlyWWWAndSLD) {
3466  int dots = name.count('.');
3467  if (dots > 2 || (dots == 2 && !name.startsWith("www.")))
3468  return false;
3469  }
3470 
3471  if ( d->m_lookedupHosts.contains( name ) )
3472  return false;
3473 
3474  d->m_DNSPrefetchQueue.enqueue( name );
3475  d->m_lookedupHosts.insert( name );
3476  d->m_numDNSPrefetchedNames++;
3477 
3478  if (d->m_DNSPrefetchTimer < 1)
3479  d->m_DNSPrefetchTimer = startTimer( sDNSPrefetchTimerDelay );
3480  if (d->m_DNSTTLTimer < 1)
3481  d->m_DNSTTLTimer = startTimer( sDNSTTLSeconds*1000 + 1 );
3482 
3483  return true;
3484 }
3485 
3486 void KHTMLPart::paintCaret(QPainter *p, const QRect &rect) const
3487 {
3488  if (d->editor_context.m_caretPaint)
3489  d->editor_context.m_selection.paintCaret(p, rect);
3490 }
3491 
3492 void KHTMLPart::paintDragCaret(QPainter *p, const QRect &rect) const
3493 {
3494  d->editor_context.m_dragCaret.paintCaret(p, rect);
3495 }
3496 
3497 DOM::Editor *KHTMLPart::editor() const {
3498  if (!d->editor_context.m_editor)
3499  const_cast<KHTMLPart *>(this)->d->editor_context.m_editor = new DOM::Editor(const_cast<KHTMLPart *>(this));
3500  return d->editor_context.m_editor;
3501 }
3502 
3503 void KHTMLPart::resetHoverText()
3504 {
3505  if( !d->m_overURL.isEmpty() ) // Only if we were showing a link
3506  {
3507  d->m_overURL.clear();
3508  d->m_overURLTarget.clear();
3509  emit onURL( QString() );
3510  // revert to default statusbar text
3511  setStatusBarText(QString(), BarHoverText);
3512  emit d->m_extension->mouseOverInfo(KFileItem());
3513  }
3514 }
3515 
3516 void KHTMLPart::overURL( const QString &url, const QString &target, bool /*shiftPressed*/ )
3517 {
3518  KUrl u = completeURL(url);
3519 
3520  // special case for <a href="">
3521  if ( url.isEmpty() )
3522  u.setFileName( url );
3523 
3524  emit onURL( url );
3525 
3526  if ( url.isEmpty() ) {
3527  setStatusBarText(Qt::escape(u.prettyUrl()), BarHoverText);
3528  return;
3529  }
3530 
3531  if ( d->isJavaScriptURL(url) ) {
3532  QString jscode = d->codeForJavaScriptURL( url );
3533  jscode = KStringHandler::rsqueeze( jscode, 80 ); // truncate if too long
3534  if (url.startsWith("javascript:window.open"))
3535  jscode += i18n(" (In new window)");
3536  setStatusBarText( Qt::escape( jscode ), BarHoverText );
3537  return;
3538  }
3539 
3540  KFileItem item(u, QString(), KFileItem::Unknown);
3541  emit d->m_extension->mouseOverInfo(item);
3542 
3543  QString com;
3544 
3545  KMimeType::Ptr typ = KMimeType::findByUrl( u );
3546 
3547  if ( typ )
3548  com = typ->comment( u );
3549 
3550  if ( !u.isValid() ) {
3551  setStatusBarText(Qt::escape(u.prettyUrl()), BarHoverText);
3552  return;
3553  }
3554 
3555  if ( u.isLocalFile() )
3556  {
3557  // TODO : use KIO::stat() and create a KFileItem out of its result,
3558  // to use KFileItem::statusBarText()
3559  const QString path = QFile::encodeName( u.toLocalFile() );
3560 
3561  KDE_struct_stat buff;
3562  bool ok = !KDE::stat( path, &buff );
3563 
3564  KDE_struct_stat lbuff;
3565  if (ok) ok = !KDE::lstat( path, &lbuff );
3566 
3567  QString text = Qt::escape(u.prettyUrl());
3568  QString text2 = text;
3569 
3570  if (ok && S_ISLNK( lbuff.st_mode ) )
3571  {
3572  QString tmp;
3573  if ( com.isNull() )
3574  tmp = i18n( "Symbolic Link");
3575  else
3576  tmp = i18n("%1 (Link)", com);
3577  char buff_two[1024];
3578  text += " -> ";
3579  int n = readlink ( path.toLocal8Bit().data(), buff_two, 1022);
3580  if (n == -1)
3581  {
3582  text2 += " ";
3583  text2 += tmp;
3584  setStatusBarText(text2, BarHoverText);
3585  return;
3586  }
3587  buff_two[n] = 0;
3588 
3589  text += buff_two;
3590  text += " ";
3591  text += tmp;
3592  }
3593  else if ( ok && S_ISREG( buff.st_mode ) )
3594  {
3595  if (buff.st_size < 1024)
3596  text = i18np("%2 (%1 byte)", "%2 (%1 bytes)", (long) buff.st_size, text2); // always put the URL last, in case it contains '%'
3597  else
3598  {
3599  float d = (float) buff.st_size/1024.0;
3600  text = i18n("%2 (%1 K)", KGlobal::locale()->formatNumber(d, 2), text2); // was %.2f
3601  }
3602  text += " ";
3603  text += com;
3604  }
3605  else if ( ok && S_ISDIR( buff.st_mode ) )
3606  {
3607  text += " ";
3608  text += com;
3609  }
3610  else
3611  {
3612  text += " ";
3613  text += com;
3614  }
3615  setStatusBarText(text, BarHoverText);
3616  }
3617  else
3618  {
3619  QString extra;
3620  if (target.toLower() == "_blank")
3621  {
3622  extra = i18n(" (In new window)");
3623  }
3624  else if (!target.isEmpty() &&
3625  (target.toLower() != "_top") &&
3626  (target.toLower() != "_self") &&
3627  (target.toLower() != "_parent"))
3628  {
3629  KHTMLPart *p = this;
3630  while (p->parentPart())
3631  p = p->parentPart();
3632  if (!p->frameExists(target))
3633  extra = i18n(" (In new window)");
3634  else
3635  extra = i18n(" (In other frame)");
3636  }
3637 
3638  if (u.protocol() == QLatin1String("mailto")) {
3639  QString mailtoMsg /* = QString::fromLatin1("<img src=%1>").arg(locate("icon", QString::fromLatin1("locolor/16x16/actions/mail_send.png")))*/;
3640  mailtoMsg += i18n("Email to: ") + KUrl::fromPercentEncoding(u.path().toLatin1());
3641  const QStringList queries = u.query().mid(1).split('&');
3642  QStringList::ConstIterator it = queries.begin();
3643  const QStringList::ConstIterator itEnd = queries.end();
3644  for (; it != itEnd; ++it)
3645  if ((*it).startsWith(QLatin1String("subject=")))
3646  mailtoMsg += i18n(" - Subject: ") + KUrl::fromPercentEncoding((*it).mid(8).toLatin1());
3647  else if ((*it).startsWith(QLatin1String("cc=")))
3648  mailtoMsg += i18n(" - CC: ") + KUrl::fromPercentEncoding((*it).mid(3).toLatin1());
3649  else if ((*it).startsWith(QLatin1String("bcc=")))
3650  mailtoMsg += i18n(" - BCC: ") + KUrl::fromPercentEncoding((*it).mid(4).toLatin1());
3651  mailtoMsg = Qt::escape(mailtoMsg);
3652  mailtoMsg.replace(QRegExp("([\n\r\t]|[ ]{10})"), QString());
3653  setStatusBarText("<qt>"+mailtoMsg, BarHoverText);
3654  return;
3655  }
3656  // Is this check necessary at all? (Frerich)
3657 #if 0
3658  else if (u.protocol() == QLatin1String("http")) {
3659  DOM::Node hrefNode = nodeUnderMouse().parentNode();
3660  while (hrefNode.nodeName().string() != QLatin1String("A") && !hrefNode.isNull())
3661  hrefNode = hrefNode.parentNode();
3662 
3663  if (!hrefNode.isNull()) {
3664  DOM::Node hreflangNode = hrefNode.attributes().getNamedItem("HREFLANG");
3665  if (!hreflangNode.isNull()) {
3666  QString countryCode = hreflangNode.nodeValue().string().toLower();
3667  // Map the language code to an appropriate country code.
3668  if (countryCode == QLatin1String("en"))
3669  countryCode = QLatin1String("gb");
3670  QString flagImg = QLatin1String("<img src=%1>").arg(
3671  locate("locale", QLatin1String("l10n/")
3672  + countryCode
3673  + QLatin1String("/flag.png")));
3674  emit setStatusBarText(flagImg + u.prettyUrl() + extra);
3675  }
3676  }
3677  }
3678 #endif
3679  setStatusBarText(Qt::escape(u.prettyUrl()) + extra, BarHoverText);
3680  }
3681 }
3682 
3683 //
3684 // This executes in the active part on a click or other url selection action in
3685 // that active part.
3686 //
3687 bool KHTMLPart::urlSelected( const QString &url, int button, int state, const QString &_target, const KParts::OpenUrlArguments& _args, const KParts::BrowserArguments& _browserArgs )
3688 {
3689  KParts::OpenUrlArguments args = _args;
3690  KParts::BrowserArguments browserArgs = _browserArgs;
3691  bool hasTarget = false;
3692 
3693  QString target = _target;
3694  if ( target.isEmpty() && d->m_doc )
3695  target = d->m_doc->baseTarget();
3696  if ( !target.isEmpty() )
3697  hasTarget = true;
3698 
3699  if ( d->isJavaScriptURL(url) )
3700  {
3701  crossFrameExecuteScript( target, d->codeForJavaScriptURL(url) );
3702  return false;
3703  }
3704 
3705  KUrl cURL = completeURL(url);
3706  // special case for <a href=""> (IE removes filename, mozilla doesn't)
3707  if ( url.isEmpty() )
3708  cURL.setFileName( url ); // removes filename
3709 
3710  if ( !cURL.isValid() )
3711  // ### ERROR HANDLING
3712  return false;
3713 
3714  kDebug(6050) << this << "complete URL:" << cURL.url() << "target=" << target;
3715 
3716  if ( state & Qt::ControlModifier )
3717  {
3718  emit d->m_extension->createNewWindow( cURL, args, browserArgs );
3719  return true;
3720  }
3721 
3722  if ( button == Qt::LeftButton && ( state & Qt::ShiftModifier ) )
3723  {
3724  KIO::MetaData metaData;
3725  metaData.insert( "referrer", d->m_referrer );
3726  KHTMLPopupGUIClient::saveURL( d->m_view, i18n( "Save As" ), cURL, metaData );
3727  return false;
3728  }
3729 
3730  if (!checkLinkSecurity(cURL,
3731  ki18n( "<qt>This untrusted page links to<br /><b>%1</b>.<br />Do you want to follow the link?</qt>" ),
3732  i18n( "Follow" )))
3733  return false;
3734 
3735  browserArgs.frameName = target;
3736 
3737  args.metaData().insert("main_frame_request",
3738  parentPart() == 0 ? "TRUE":"FALSE");
3739  args.metaData().insert("ssl_parent_ip", d->m_ssl_parent_ip);
3740  args.metaData().insert("ssl_parent_cert", d->m_ssl_parent_cert);
3741  args.metaData().insert("PropagateHttpHeader", "true");
3742  args.metaData().insert("ssl_was_in_use", d->m_ssl_in_use ? "TRUE":"FALSE");
3743  args.metaData().insert("ssl_activate_warnings", "TRUE");
3744 
3745  if ( hasTarget && target != "_self" && target != "_top" && target != "_blank" && target != "_parent" )
3746  {
3747  // unknown frame names should open in a new window.
3748  khtml::ChildFrame *frame = recursiveFrameRequest( this, cURL, args, browserArgs, false );
3749  if ( frame )
3750  {
3751  args.metaData()["referrer"] = d->m_referrer;
3752  requestObject( frame, cURL, args, browserArgs );
3753  return true;
3754  }
3755  }
3756 
3757  if (!d->m_referrer.isEmpty() && !args.metaData().contains("referrer"))
3758  args.metaData()["referrer"] = d->m_referrer;
3759 
3760  if ( button == Qt::NoButton && (state & Qt::ShiftModifier) && (state & Qt::ControlModifier) )
3761  {
3762  emit d->m_extension->createNewWindow( cURL, args, browserArgs );
3763  return true;
3764  }
3765 
3766  if ( state & Qt::ShiftModifier)
3767  {
3768  KParts::WindowArgs winArgs;
3769  winArgs.setLowerWindow(true);
3770  emit d->m_extension->createNewWindow( cURL, args, browserArgs, winArgs );
3771  return true;
3772  }
3773 
3774  //If we're asked to open up an anchor in the current URL, in current window,
3775  //merely gotoanchor, and do not reload the new page. Note that this does
3776  //not apply if the URL is the same page, but without a ref
3777  if (cURL.hasRef() && (!hasTarget || target == "_self"))
3778  {
3779  if (d->isLocalAnchorJump(cURL))
3780  {
3781  d->executeAnchorJump(cURL, browserArgs.lockHistory() );
3782  return false; // we jumped, but we didn't open a URL
3783  }
3784  }
3785 
3786  if ( !d->m_bComplete && !hasTarget )
3787  closeUrl();
3788 
3789  view()->viewport()->unsetCursor();
3790  emit d->m_extension->openUrlRequest( cURL, args, browserArgs );
3791  return true;
3792 }
3793 
3794 void KHTMLPart::slotViewDocumentSource()
3795 {
3796  KUrl currentUrl(this->url());
3797  bool isTempFile = false;
3798  if (!(currentUrl.isLocalFile()) && KHTMLPageCache::self()->isComplete(d->m_cacheId))
3799  {
3800  KTemporaryFile sourceFile;
3801  sourceFile.setSuffix(defaultExtension());
3802  sourceFile.setAutoRemove(false);
3803  if (sourceFile.open())
3804  {
3805  QDataStream stream ( &sourceFile );
3806  KHTMLPageCache::self()->saveData(d->m_cacheId, &stream);
3807  currentUrl = KUrl();
3808  currentUrl.setPath(sourceFile.fileName());
3809  isTempFile = true;
3810  }
3811  }
3812 
3813  (void) KRun::runUrl( currentUrl, QLatin1String("text/plain"), view(), isTempFile );
3814 }
3815 
3816 void KHTMLPart::slotViewPageInfo()
3817 {
3818  Ui_KHTMLInfoDlg ui;
3819 
3820  QDialog *dlg = new QDialog(0);
3821  dlg->setAttribute(Qt::WA_DeleteOnClose);
3822  dlg->setObjectName("KHTML Page Info Dialog");
3823  ui.setupUi(dlg);
3824 
3825  ui._close->setGuiItem(KStandardGuiItem::close());
3826  connect(ui._close, SIGNAL(clicked()), dlg, SLOT(accept()));
3827 
3828  if (d->m_doc)
3829  ui._title->setText(d->m_doc->title().string().trimmed());
3830 
3831  // If it's a frame, set the caption to "Frame Information"
3832  if ( parentPart() && d->m_doc && d->m_doc->isHTMLDocument() ) {
3833  dlg->setWindowTitle(i18n("Frame Information"));
3834  }
3835 
3836  QString editStr;
3837 
3838  if (!d->m_pageServices.isEmpty())
3839  editStr = i18n(" <a href=\"%1\">[Properties]</a>", d->m_pageServices);
3840 
3841  QString squeezedURL = KStringHandler::csqueeze( url().prettyUrl(), 80 );
3842  ui._url->setText("<a href=\"" + url().url() + "\">" + squeezedURL + "</a>" + editStr);
3843  if (lastModified().isEmpty())
3844  {
3845  ui._lastModified->hide();
3846  ui._lmLabel->hide();
3847  }
3848  else
3849  ui._lastModified->setText(lastModified());
3850 
3851  const QString& enc = encoding();
3852  if (enc.isEmpty()) {
3853  ui._eLabel->hide();
3854  ui._encoding->hide();
3855  } else {
3856  ui._encoding->setText(enc);
3857  }
3858 
3859  if (!xmlDocImpl() || xmlDocImpl()->parseMode() == DOM::DocumentImpl::Unknown) {
3860  ui._mode->hide();
3861  ui._modeLabel->hide();
3862  } else {
3863  switch (xmlDocImpl()->parseMode()) {
3864  case DOM::DocumentImpl::Compat:
3865  ui._mode->setText(i18nc("HTML rendering mode (see http://en.wikipedia.org/wiki/Quirks_mode)", "Quirks"));
3866  break;
3867  case DOM::DocumentImpl::Transitional:
3868  ui._mode->setText(i18nc("HTML rendering mode (see http://en.wikipedia.org/wiki/Quirks_mode)", "Almost standards"));
3869  break;
3870  case DOM::DocumentImpl::Strict:
3871  default: // others handled above
3872  ui._mode->setText(i18nc("HTML rendering mode (see http://en.wikipedia.org/wiki/Quirks_mode)", "Strict"));
3873  break;
3874  }
3875  }
3876 
3877  /* populate the list view now */
3878  const QStringList headers = d->m_httpHeaders.split("\n");
3879 
3880  QStringList::ConstIterator it = headers.begin();
3881  const QStringList::ConstIterator itEnd = headers.end();
3882 
3883  for (; it != itEnd; ++it) {
3884  const QStringList header = (*it).split(QRegExp(":[ ]+"));
3885  if (header.count() != 2)
3886  continue;
3887  QTreeWidgetItem *item = new QTreeWidgetItem(ui._headers);
3888  item->setText(0, header[0]);
3889  item->setText(1, header[1]);
3890  }
3891 
3892  dlg->show();
3893  /* put no code here */
3894 }
3895 
3896 
3897 void KHTMLPart::slotViewFrameSource()
3898 {
3899  KParts::ReadOnlyPart *frame = currentFrame();
3900  if ( !frame )
3901  return;
3902 
3903  KUrl url = frame->url();
3904  bool isTempFile = false;
3905  if (!(url.isLocalFile()) && frame->inherits("KHTMLPart"))
3906  {
3907  long cacheId = static_cast<KHTMLPart *>(frame)->d->m_cacheId;
3908 
3909  if (KHTMLPageCache::self()->isComplete(cacheId))
3910  {
3911  KTemporaryFile sourceFile;
3912  sourceFile.setSuffix(defaultExtension());
3913  sourceFile.setAutoRemove(false);
3914  if (sourceFile.open())
3915  {
3916  QDataStream stream ( &sourceFile );
3917  KHTMLPageCache::self()->saveData(cacheId, &stream);
3918  url = KUrl();
3919  url.setPath(sourceFile.fileName());
3920  isTempFile = true;
3921  }
3922  }
3923  }
3924 
3925  (void) KRun::runUrl( url, QLatin1String("text/plain"), view(), isTempFile );
3926 }
3927 
3928 KUrl KHTMLPart::backgroundURL() const
3929 {
3930  // ### what about XML documents? get from CSS?
3931  if (!d->m_doc || !d->m_doc->isHTMLDocument())
3932  return KUrl();
3933 
3934  QString relURL = static_cast<HTMLDocumentImpl*>(d->m_doc)->body()->getAttribute( ATTR_BACKGROUND ).string();
3935 
3936  return KUrl( url(), relURL );
3937 }
3938 
3939 void KHTMLPart::slotSaveBackground()
3940 {
3941  KIO::MetaData metaData;
3942  metaData["referrer"] = d->m_referrer;
3943  KHTMLPopupGUIClient::saveURL( d->m_view, i18n("Save Background Image As"), backgroundURL(), metaData );
3944 }
3945 
3946 void KHTMLPart::slotSaveDocument()
3947 {
3948  KUrl srcURL( url() );
3949 
3950  if ( srcURL.fileName(KUrl::ObeyTrailingSlash).isEmpty() )
3951  srcURL.setFileName( "index" + defaultExtension() );
3952 
3953  KIO::MetaData metaData;
3954  // Referre unknown?
3955  KHTMLPopupGUIClient::saveURL( d->m_view, i18n( "Save As" ), srcURL, metaData, "text/html", d->m_cacheId );
3956 }
3957 
3958 void KHTMLPart::slotSecurity()
3959 {
3960 // kDebug( 6050 ) << "Meta Data:" << endl
3961 // << d->m_ssl_peer_cert_subject
3962 // << endl
3963 // << d->m_ssl_peer_cert_issuer
3964 // << endl
3965 // << d->m_ssl_cipher
3966 // << endl
3967 // << d->m_ssl_cipher_desc
3968 // << endl
3969 // << d->m_ssl_cipher_version
3970 // << endl
3971 // << d->m_ssl_good_from
3972 // << endl
3973 // << d->m_ssl_good_until
3974 // << endl
3975 // << d->m_ssl_cert_state
3976 // << endl;
3977 
3978  //### reenable with new signature
3979 #if 0
3980  KSslInfoDialog *kid = new KSslInfoDialog(d->m_ssl_in_use, widget(), "kssl_info_dlg", true );
3981 
3982  const QStringList sl = d->m_ssl_peer_chain.split('\n', QString::SkipEmptyParts);
3983  QList<QSslCertificate> certChain;
3984  bool certChainOk = d->m_ssl_in_use;
3985  if (certChainOk) {
3986  foreach (const QString &s, sl) {
3987  certChain.append(QSslCertificate(s.toLatin1())); //or is it toLocal8Bit or whatever?
3988  if (certChain.last().isNull()) {
3989  certChainOk = false;
3990  break;
3991  }
3992  }
3993  }
3994  if (certChainOk) {
3995  kid->setup(certChain,
3996  d->m_ssl_peer_ip,
3997  url().url(),
3998  d->m_ssl_cipher,
3999  d->m_ssl_cipher_desc,
4000  d->m_ssl_cipher_version,
4001  d->m_ssl_cipher_used_bits.toInt(),
4002  d->m_ssl_cipher_bits.toInt(),
4003  (KSSLCertificate::KSSLValidation) d->m_ssl_cert_state.toInt());
4004  }
4005  kid->exec();
4006  //the dialog deletes itself on close
4007 #endif
4008 
4009  KSslInfoDialog *kid = new KSslInfoDialog(0);
4010  //### This is boilerplate code and it's copied from SlaveInterface.
4011  QStringList sl = d->m_ssl_peer_chain.split('\x01', QString::SkipEmptyParts);
4012  QList<QSslCertificate> certChain;
4013  bool decodedOk = true;
4014  foreach (const QString &s, sl) {
4015  certChain.append(QSslCertificate(s.toLatin1())); //or is it toLocal8Bit or whatever?
4016  if (certChain.last().isNull()) {
4017  decodedOk = false;
4018  break;
4019  }
4020  }
4021 
4022  if (decodedOk || true /*H4X*/) {
4023  kid->setSslInfo(certChain,
4024  d->m_ssl_peer_ip,
4025  url().host(),
4026  d->m_ssl_protocol_version,
4027  d->m_ssl_cipher,
4028  d->m_ssl_cipher_used_bits.toInt(),
4029  d->m_ssl_cipher_bits.toInt(),
4030  KSslInfoDialog::errorsFromString(d->m_ssl_cert_errors));
4031  kDebug(7024) << "Showing SSL Info dialog";
4032  kid->exec();
4033  kDebug(7024) << "SSL Info dialog closed";
4034  } else {
4035  KMessageBox::information(0, i18n("The peer SSL certificate chain "
4036  "appears to be corrupt."),
4037  i18n("SSL"));
4038  }
4039 }
4040 
4041 void KHTMLPart::slotSaveFrame()
4042 {
4043  KParts::ReadOnlyPart *frame = currentFrame();
4044  if ( !frame )
4045  return;
4046 
4047  KUrl srcURL( frame->url() );
4048 
4049  if ( srcURL.fileName(KUrl::ObeyTrailingSlash).isEmpty() )
4050  srcURL.setFileName( "index" + defaultExtension() );
4051 
4052  KIO::MetaData metaData;
4053  // Referrer unknown?
4054  KHTMLPopupGUIClient::saveURL( d->m_view, i18n( "Save Frame As" ), srcURL, metaData, "text/html" );
4055 }
4056 
4057 void KHTMLPart::slotSetEncoding(const QString &enc)
4058 {
4059  d->m_autoDetectLanguage=KEncodingDetector::None;
4060  setEncoding( enc, true);
4061 }
4062 
4063 void KHTMLPart::slotAutomaticDetectionLanguage(KEncodingDetector::AutoDetectScript scri)
4064 {
4065  d->m_autoDetectLanguage=scri;
4066  setEncoding( QString(), false );
4067 }
4068 
4069 void KHTMLPart::slotUseStylesheet()
4070 {
4071  if (d->m_doc)
4072  {
4073  bool autoselect = (d->m_paUseStylesheet->currentItem() == 0);
4074  d->m_sheetUsed = autoselect ? QString() : d->m_paUseStylesheet->currentText();
4075  d->m_doc->updateStyleSelector();
4076  }
4077 }
4078 
4079 void KHTMLPart::updateActions()
4080 {
4081  bool frames = false;
4082 
4083  QList<khtml::ChildFrame*>::ConstIterator it = d->m_frames.constBegin();
4084  const QList<khtml::ChildFrame*>::ConstIterator end = d->m_frames.constEnd();
4085  for (; it != end; ++it )
4086  if ( (*it)->m_type == khtml::ChildFrame::Frame )
4087  {
4088  frames = true;
4089  break;
4090  }
4091 
4092  if (d->m_paViewFrame)
4093  d->m_paViewFrame->setEnabled( frames );
4094  if (d->m_paSaveFrame)
4095  d->m_paSaveFrame->setEnabled( frames );
4096 
4097  if ( frames )
4098  d->m_paFind->setText( i18n( "&Find in Frame..." ) );
4099  else
4100  d->m_paFind->setText( i18n( "&Find..." ) );
4101 
4102  KParts::Part *frame = 0;
4103 
4104  if ( frames )
4105  frame = currentFrame();
4106 
4107  bool enableFindAndSelectAll = true;
4108 
4109  if ( frame )
4110  enableFindAndSelectAll = frame->inherits( "KHTMLPart" );
4111 
4112  d->m_paFind->setEnabled( enableFindAndSelectAll );
4113  d->m_paSelectAll->setEnabled( enableFindAndSelectAll );
4114 
4115  bool enablePrintFrame = false;
4116 
4117  if ( frame )
4118  {
4119  QObject *ext = KParts::BrowserExtension::childObject( frame );
4120  if ( ext )
4121  enablePrintFrame = ext->metaObject()->indexOfSlot( "print()" ) != -1;
4122  }
4123 
4124  d->m_paPrintFrame->setEnabled( enablePrintFrame );
4125 
4126  QString bgURL;
4127 
4128  // ### frames
4129  if ( d->m_doc && d->m_doc->isHTMLDocument() && static_cast<HTMLDocumentImpl*>(d->m_doc)->body() && !d->m_bClearing )
4130  bgURL = static_cast<HTMLDocumentImpl*>(d->m_doc)->body()->getAttribute( ATTR_BACKGROUND ).string();
4131 
4132  if (d->m_paSaveBackground)
4133  d->m_paSaveBackground->setEnabled( !bgURL.isEmpty() );
4134 
4135  if ( d->m_paDebugScript )
4136  d->m_paDebugScript->setEnabled( d->m_frame ? d->m_frame->m_jscript : 0L );
4137 }
4138 
4139 KParts::ScriptableExtension *KHTMLPart::scriptableExtension( const DOM::NodeImpl *frame) {
4140  const ConstFrameIt end = d->m_objects.constEnd();
4141  for(ConstFrameIt it = d->m_objects.constBegin(); it != end; ++it )
4142  if ((*it)->m_partContainerElement.data() == frame)
4143  return (*it)->m_scriptable.data();
4144  return 0L;
4145 }
4146 
4147 void KHTMLPart::loadFrameElement( DOM::HTMLPartContainerElementImpl *frame, const QString &url,
4148  const QString &frameName, const QStringList &params, bool isIFrame )
4149 {
4150  //kDebug( 6050 ) << this << " requestFrame( ..., " << url << ", " << frameName << " )";
4151  khtml::ChildFrame* child;
4152 
4153  FrameIt it = d->m_frames.find( frameName );
4154  if ( it == d->m_frames.end() ) {
4155  child = new khtml::ChildFrame;
4156  //kDebug( 6050 ) << "inserting new frame into frame map " << frameName;
4157  child->m_name = frameName;
4158  d->m_frames.insert( d->m_frames.end(), child );
4159  } else {
4160  child = *it;
4161  }
4162 
4163  child->m_type = isIFrame ? khtml::ChildFrame::IFrame : khtml::ChildFrame::Frame;
4164  child->m_partContainerElement = frame;
4165  child->m_params = params;
4166 
4167  // If we do not have a part, make sure we create one.
4168  if (!child->m_part) {
4169  QStringList dummy; // the list of servicetypes handled by the part is now unused.
4170  QString khtml = QString::fromLatin1("khtml");
4171  KParts::ReadOnlyPart* part = createPart(d->m_view->viewport(), this,
4172  QString::fromLatin1("text/html"),
4173  khtml, dummy, QStringList());
4174  // We navigate it to about:blank to setup an empty one, but we do it
4175  // before hooking up the signals and extensions, so that any sync emit
4176  // of completed by the kid doesn't cause us to be marked as completed.
4177  // (async ones are discovered by the presence of the KHTMLRun)
4178  // ### load event on the kid?
4179  navigateLocalProtocol(child, part, KUrl("about:blank"));
4180  connectToChildPart(child, part, "text/html" /* mimetype of the part, not what's being loaded */);
4181  }
4182 
4183  KUrl u = url.isEmpty() ? KUrl() : completeURL( url );
4184 
4185  // Since we don't specify args here a KHTMLRun will be used to determine the
4186  // mimetype, which will then be passed down at the bottom of processObjectRequest
4187  // inside URLArgs to the part. In our particular case, this means that we can
4188  // use that inside KHTMLPart::openUrl to route things appropriately.
4189  child->m_bCompleted = false;
4190  if (!requestObject( child, u ) && !child->m_run) {
4191  child->m_bCompleted = true;
4192  }
4193 }
4194 
4195 QString KHTMLPart::requestFrameName()
4196 {
4197  return QString::fromLatin1("<!--frame %1-->").arg(d->m_frameNameId++);
4198 }
4199 
4200 bool KHTMLPart::loadObjectElement( DOM::HTMLPartContainerElementImpl *frame, const QString &url,
4201  const QString &serviceType, const QStringList &params )
4202 {
4203  //kDebug( 6031 ) << this << "frame=" << frame;
4204  khtml::ChildFrame *child = new khtml::ChildFrame;
4205  FrameIt it = d->m_objects.insert( d->m_objects.end(), child );
4206  (*it)->m_partContainerElement = frame;
4207  (*it)->m_type = khtml::ChildFrame::Object;
4208  (*it)->m_params = params;
4209 
4210  KParts::OpenUrlArguments args;
4211  args.setMimeType(serviceType);
4212  if (!requestObject( *it, completeURL( url ), args ) && !(*it)->m_run) {
4213  (*it)->m_bCompleted = true;
4214  return false;
4215  }
4216  return true;
4217 }
4218 
4219 bool KHTMLPart::requestObject( khtml::ChildFrame *child, const KUrl &url, const KParts::OpenUrlArguments &_args,
4220  const KParts::BrowserArguments& browserArgs )
4221 {
4222  // we always permit javascript: URLs here since they're basically just
4223  // empty pages (and checkLinkSecurity/KAuthorized doesn't know what to do with them)
4224  if (!d->isJavaScriptURL(url.url()) && !checkLinkSecurity(url))
4225  {
4226  kDebug(6031) << this << "checkLinkSecurity refused";
4227  return false;
4228  }
4229 
4230  if (d->m_bClearing)
4231  {
4232  return false;
4233  }
4234 
4235  if ( child->m_bPreloaded )
4236  {
4237  if ( child->m_partContainerElement && child->m_part )
4238  child->m_partContainerElement.data()->setWidget( child->m_part.data()->widget() );
4239 
4240  child->m_bPreloaded = false;
4241  return true;
4242  }
4243 
4244  //kDebug(6031) << "child=" << child << "child->m_part=" << child->m_part;
4245 
4246  KParts::OpenUrlArguments args( _args );
4247 
4248  if ( child->m_run ) {
4249  kDebug(6031) << "navigating ChildFrame while mimetype resolution was in progress...";
4250  child->m_run.data()->abort();
4251  }
4252 
4253  // ### Dubious -- the whole dir/ vs. img thing
4254  if ( child->m_part && !args.reload() && child->m_part.data()->url().equals( url,
4255  KUrl::CompareWithoutTrailingSlash | KUrl::CompareWithoutFragment | KUrl::AllowEmptyPath ) )
4256  args.setMimeType(child->m_serviceType);
4257 
4258  child->m_browserArgs = browserArgs;
4259  child->m_args = args;
4260 
4261  // reload/soft-reload arguments are always inherited from parent
4262  child->m_args.setReload( arguments().reload() );
4263  child->m_browserArgs.softReload = d->m_extension->browserArguments().softReload;
4264 
4265  child->m_serviceName.clear();
4266  if (!d->m_referrer.isEmpty() && !child->m_args.metaData().contains( "referrer" ))
4267  child->m_args.metaData()["referrer"] = d->m_referrer;
4268 
4269  child->m_args.metaData().insert("PropagateHttpHeader", "true");
4270  child->m_args.metaData().insert("ssl_parent_ip", d->m_ssl_parent_ip);
4271  child->m_args.metaData().insert("ssl_parent_cert", d->m_ssl_parent_cert);
4272  child->m_args.metaData().insert("main_frame_request",
4273  parentPart() == 0 ? "TRUE":"FALSE");
4274  child->m_args.metaData().insert("ssl_was_in_use",
4275  d->m_ssl_in_use ? "TRUE":"FALSE");
4276  child->m_args.metaData().insert("ssl_activate_warnings", "TRUE");
4277  child->m_args.metaData().insert("cross-domain", toplevelURL().url());
4278 
4279  // We know the frame will be text/html if the HTML says <frame src=""> or <frame src="about:blank">,
4280  // no need to KHTMLRun to figure out the mimetype"
4281  // ### What if we're inside an XML document?
4282  if ((url.isEmpty() || url.url() == "about:blank" || url.protocol() == "javascript") && args.mimeType().isEmpty())
4283  args.setMimeType(QLatin1String("text/html"));
4284 
4285  if ( args.mimeType().isEmpty() ) {
4286  kDebug(6031) << "Running new KHTMLRun for" << this << "and child=" << child;
4287  child->m_run = new KHTMLRun( this, child, url, child->m_args, child->m_browserArgs, true );
4288  d->m_bComplete = false; // ensures we stop it in checkCompleted...
4289  return false;
4290  } else {
4291  return processObjectRequest( child, url, args.mimeType() );
4292  }
4293 }
4294 
4295 void KHTMLPart::childLoadFailure( khtml::ChildFrame *child )
4296 {
4297  child->m_bCompleted = true;
4298  if ( child->m_partContainerElement )
4299  child->m_partContainerElement.data()->partLoadingErrorNotify();
4300 
4301  checkCompleted();
4302 }
4303 
4304 bool KHTMLPart::processObjectRequest( khtml::ChildFrame *child, const KUrl &_url, const QString &mimetype )
4305 {
4306  kDebug( 6031 ) << "trying to create part for" << mimetype << _url;
4307 
4308  // IMPORTANT: create a copy of the url here, because it is just a reference, which was likely to be given
4309  // by an emitting frame part (emit openUrlRequest( blahurl, ... ) . A few lines below we delete the part
4310  // though -> the reference becomes invalid -> crash is likely
4311  KUrl url( _url );
4312 
4313  // khtmlrun called us with empty url + mimetype to indicate a loading error,
4314  // we obviosuly failed; but we can return true here since we don't want it
4315  // doing anything more, while childLoadFailure is enough to notify our kid.
4316  if ( d->m_onlyLocalReferences || ( url.isEmpty() && mimetype.isEmpty() ) ) {
4317  childLoadFailure(child);
4318  return true;
4319  }
4320 
4321  // we also want to ignore any spurious requests due to closing when parser is being cleared. These should be
4322  // ignored entirely --- the tail end of ::clear will clean things up.
4323  if (d->m_bClearing)
4324  return false;
4325 
4326  if (child->m_bNotify) {
4327  child->m_bNotify = false;
4328  if ( !child->m_browserArgs.lockHistory() )
4329  emit d->m_extension->openUrlNotify();
4330  }
4331 
4332  // Now, depending on mimetype and current state of the world, we may have
4333  // to create a new part or ask the user to save things, etc.
4334  //
4335  // We need a new part if there isn't one at all (doh) or the one that's there
4336  // is not for the mimetype we're loading.
4337  //
4338  // For these new types, we may have to ask the user to save it or not
4339  // (we don't if it's navigating the same type).
4340  // Further, we will want to ask if content-disposition suggests we ask for
4341  // saving, even if we're re-navigating.
4342  if ( !child->m_part || child->m_serviceType != mimetype ||
4343  (child->m_run && child->m_run.data()->serverSuggestsSave())) {
4344  // We often get here if we didn't know the mimetype in advance, and had to rely
4345  // on KRun to figure it out. In this case, we let the element check if it wants to
4346  // handle this mimetype itself, for e.g. objects containing images.
4347  if ( child->m_partContainerElement &&
4348  child->m_partContainerElement.data()->mimetypeHandledInternally(mimetype) ) {
4349  child->m_bCompleted = true;
4350  checkCompleted();
4351  return true;
4352  }
4353 
4354  // Before attempting to load a part, check if the user wants that.
4355  // Many don't like getting ZIP files embedded.
4356  // However we don't want to ask for flash and other plugin things.
4357  //
4358  // Note: this is fine for frames, since we will merely effectively ignore
4359  // the navigation if this happens
4360  if ( child->m_type != khtml::ChildFrame::Object && child->m_type != khtml::ChildFrame::IFrame ) {
4361  QString suggestedFileName;
4362  int disposition = 0;
4363  if ( KHTMLRun* run = child->m_run.data() ) {
4364  suggestedFileName = run->suggestedFileName();
4365  disposition = run->serverSuggestsSave() ?
4366  KParts::BrowserRun::AttachmentDisposition :
4367  KParts::BrowserRun::InlineDisposition;
4368  }
4369 
4370  KParts::BrowserOpenOrSaveQuestion dlg( widget(), url, mimetype );
4371  dlg.setSuggestedFileName( suggestedFileName );
4372  const KParts::BrowserOpenOrSaveQuestion::Result res = dlg.askEmbedOrSave( disposition );
4373 
4374  switch( res ) {
4375  case KParts::BrowserOpenOrSaveQuestion::Save:
4376  KHTMLPopupGUIClient::saveURL( widget(), i18n( "Save As" ), url, child->m_args.metaData(), QString(), 0, suggestedFileName );
4377  // fall-through
4378  case KParts::BrowserOpenOrSaveQuestion::Cancel:
4379  child->m_bCompleted = true;
4380  checkCompleted();
4381  return true; // done
4382  default: // Embed
4383  break;
4384  }
4385  }
4386 
4387  // Now, for frames and iframes, we always create a KHTMLPart anyway,
4388  // doing it in advance when registering the frame. So we want the
4389  // actual creation only for objects here.
4390  if ( child->m_type == khtml::ChildFrame::Object ) {
4391  KMimeType::Ptr mime = KMimeType::mimeType(mimetype);
4392  if (mime) {
4393  // Even for objects, however, we want to force a KHTMLPart for
4394  // html & xml, even if the normally preferred part is another one,
4395  // so that we can script the target natively via contentDocument method.
4396  if (mime->is("text/html")
4397  || mime->is("application/xml")) { // this includes xhtml and svg
4398  child->m_serviceName = "khtml";
4399  } else {
4400  if (!pluginsEnabled()) {
4401  childLoadFailure(child);
4402  return false;
4403  }
4404  }
4405  }
4406 
4407  QStringList dummy; // the list of servicetypes handled by the part is now unused.
4408  KParts::ReadOnlyPart *part = createPart( d->m_view->viewport(), this, mimetype, child->m_serviceName, dummy, child->m_params );
4409 
4410  if ( !part ) {
4411  childLoadFailure(child);
4412  return false;
4413  }
4414 
4415  connectToChildPart( child, part, mimetype );
4416  }
4417  }
4418 
4419  checkEmitLoadEvent();
4420 
4421  // Some JS code in the load event may have destroyed the part
4422  // In that case, abort
4423  if ( !child->m_part )
4424  return false;
4425 
4426  if ( child->m_bPreloaded ) {
4427  if ( child->m_partContainerElement && child->m_part )
4428  child->m_partContainerElement.data()->setWidget( child->m_part.data()->widget() );
4429 
4430  child->m_bPreloaded = false;
4431  return true;
4432  }
4433 
4434  // reload/soft-reload arguments are always inherited from parent
4435  child->m_args.setReload( arguments().reload() );
4436  child->m_browserArgs.softReload = d->m_extension->browserArguments().softReload;
4437 
4438  // make sure the part has a way to find out about the mimetype.
4439  // we actually set it in child->m_args in requestObject already,
4440  // but it's useless if we had to use a KHTMLRun instance, as the
4441  // point the run object is to find out exactly the mimetype.
4442  child->m_args.setMimeType(mimetype);
4443  child->m_part.data()->setArguments( child->m_args );
4444 
4445  // if not a frame set child as completed
4446  // ### dubious.
4447  child->m_bCompleted = child->m_type == khtml::ChildFrame::Object;
4448 
4449  if ( child->m_extension )
4450  child->m_extension.data()->setBrowserArguments( child->m_browserArgs );
4451 
4452  return navigateChild( child, url );
4453 }
4454 
4455 bool KHTMLPart::navigateLocalProtocol( khtml::ChildFrame* /*child*/, KParts::ReadOnlyPart *inPart,
4456  const KUrl& url )
4457 {
4458  if (!qobject_cast<KHTMLPart*>(inPart))
4459  return false;
4460 
4461  KHTMLPart* p = static_cast<KHTMLPart*>(static_cast<KParts::ReadOnlyPart *>(inPart));
4462 
4463  p->begin();
4464 
4465  // We may have to re-propagate the domain here if we go here due to navigation
4466  d->propagateInitialDomainAndBaseTo(p);
4467 
4468  // Support for javascript: sources
4469  if (d->isJavaScriptURL(url.url())) {
4470  // See if we want to replace content with javascript: output..
4471  QVariant res = p->executeScript( DOM::Node(),
4472  d->codeForJavaScriptURL(url.url()));
4473  if (res.type() == QVariant::String && p->d->m_redirectURL.isEmpty()) {
4474  p->begin();
4475  p->setAlwaysHonourDoctype(); // Disable public API compat; it messes with doctype
4476  // We recreated the document, so propagate domain again.
4477  d->propagateInitialDomainAndBaseTo(p);
4478  p->write( res.toString() );
4479  p->end();
4480  }
4481  } else {
4482  p->setUrl(url);
4483  // we need a body element. testcase: <iframe id="a"></iframe><script>alert(a.document.body);</script>
4484  p->write("<HTML><TITLE></TITLE><BODY></BODY></HTML>");
4485  }
4486  p->end();
4487  // we don't need to worry about child completion explicitly for KHTMLPart...
4488  // or do we?
4489  return true;
4490 }
4491 
4492 bool KHTMLPart::navigateChild( khtml::ChildFrame *child, const KUrl& url )
4493 {
4494  if (url.protocol() == "javascript" || url.url() == "about:blank") {
4495  return navigateLocalProtocol(child, child->m_part.data(), url);
4496  } else if ( !url.isEmpty() ) {
4497  kDebug( 6031 ) << "opening" << url << "in frame" << child->m_part;
4498  bool b = child->m_part.data()->openUrl( url );
4499  if (child->m_bCompleted)
4500  checkCompleted();
4501  return b;
4502  } else {
4503  // empty URL -> no need to navigate
4504  child->m_bCompleted = true;
4505  checkCompleted();
4506  return true;
4507  }
4508 }
4509 
4510 void KHTMLPart::connectToChildPart( khtml::ChildFrame *child, KParts::ReadOnlyPart *part,
4511  const QString& mimetype)
4512 {
4513  kDebug(6031) << "we:" << this << "kid:" << child << part << mimetype;
4514 
4515  part->setObjectName( child->m_name );
4516 
4517  // Cleanup any previous part for this childframe and its connections
4518  if ( KParts::ReadOnlyPart* p = child->m_part.data() ) {
4519  if (!qobject_cast<KHTMLPart*>(p) && child->m_jscript)
4520  child->m_jscript->clear();
4521  partManager()->removePart( p );
4522  delete p;
4523  child->m_scriptable.clear();
4524  }
4525 
4526  child->m_part = part;
4527 
4528  child->m_serviceType = mimetype;
4529  if ( child->m_partContainerElement && part->widget() )
4530  child->m_partContainerElement.data()->setWidget( part->widget() );
4531 
4532  if ( child->m_type != khtml::ChildFrame::Object )
4533  partManager()->addPart( part, false );
4534 // else
4535 // kDebug(6031) << "AH! NO FRAME!!!!!";
4536 
4537  if (qobject_cast<KHTMLPart*>(part)) {
4538  static_cast<KHTMLPart*>(part)->d->m_frame = child;
4539  } else if (child->m_partContainerElement) {
4540  // See if this can be scripted..
4541  KParts::ScriptableExtension* scriptExt = KParts::ScriptableExtension::childObject(part);
4542  if (!scriptExt) {
4543  // Try to fall back to LiveConnectExtension compat
4544  KParts::LiveConnectExtension* lc = KParts::LiveConnectExtension::childObject(part);
4545  if (lc)
4546  scriptExt = KParts::ScriptableExtension::adapterFromLiveConnect(part, lc);
4547  }
4548 
4549  if (scriptExt)
4550  scriptExt->setHost(d->m_scriptableExtension);
4551  child->m_scriptable = scriptExt;
4552  }
4553  KParts::StatusBarExtension *sb = KParts::StatusBarExtension::childObject(part);
4554  if (sb)
4555  sb->setStatusBar( d->m_statusBarExtension->statusBar() );
4556 
4557  connect( part, SIGNAL(started(KIO::Job*)),
4558  this, SLOT(slotChildStarted(KIO::Job*)) );
4559  connect( part, SIGNAL(completed()),
4560  this, SLOT(slotChildCompleted()) );
4561  connect( part, SIGNAL(completed(bool)),
4562  this, SLOT(slotChildCompleted(bool)) );
4563  connect( part, SIGNAL(setStatusBarText(QString)),
4564  this, SIGNAL(setStatusBarText(QString)) );
4565  if ( part->inherits( "KHTMLPart" ) )
4566  {
4567  connect( this, SIGNAL(completed()),
4568  part, SLOT(slotParentCompleted()) );
4569  connect( this, SIGNAL(completed(bool)),
4570  part, SLOT(slotParentCompleted()) );
4571  // As soon as the child's document is created, we need to set its domain
4572  // (but we do so only once, so it can't be simply done in the child)
4573  connect( part, SIGNAL(docCreated()),
4574  this, SLOT(slotChildDocCreated()) );
4575  }
4576 
4577  child->m_extension = KParts::BrowserExtension::childObject( part );
4578 
4579  if ( KParts::BrowserExtension* kidBrowserExt = child->m_extension.data() )
4580  {
4581  connect( kidBrowserExt, SIGNAL(openUrlNotify()),
4582  d->m_extension, SIGNAL(openUrlNotify()) );
4583 
4584  connect( kidBrowserExt, SIGNAL(openUrlRequestDelayed(KUrl,KParts::OpenUrlArguments,KParts::BrowserArguments)),
4585  this, SLOT(slotChildURLRequest(KUrl,KParts::OpenUrlArguments,KParts::BrowserArguments)) );
4586 
4587  connect( kidBrowserExt, SIGNAL(createNewWindow(KUrl,KParts::OpenUrlArguments,KParts::BrowserArguments,KParts::WindowArgs,KParts::ReadOnlyPart**)),
4588  d->m_extension, SIGNAL(createNewWindow(KUrl,KParts::OpenUrlArguments,KParts::BrowserArguments,KParts::WindowArgs,KParts::ReadOnlyPart**)) );
4589 
4590  connect( kidBrowserExt, SIGNAL(popupMenu(QPoint,KFileItemList,KParts::OpenUrlArguments,KParts::BrowserArguments,KParts::BrowserExtension::PopupFlags,KParts::BrowserExtension::ActionGroupMap)),
4591  d->m_extension, SIGNAL(popupMenu(QPoint,KFileItemList,KParts::OpenUrlArguments,KParts::BrowserArguments,KParts::BrowserExtension::PopupFlags,KParts::BrowserExtension::ActionGroupMap)) );
4592  connect( kidBrowserExt, SIGNAL(popupMenu(QPoint,KUrl,mode_t,KParts::OpenUrlArguments,KParts::BrowserArguments,KParts::BrowserExtension::PopupFlags,KParts::BrowserExtension::ActionGroupMap)),
4593  d->m_extension, SIGNAL(popupMenu(QPoint,KUrl,mode_t,KParts::OpenUrlArguments,KParts::BrowserArguments,KParts::BrowserExtension::PopupFlags,KParts::BrowserExtension::ActionGroupMap)) );
4594 
4595  connect( kidBrowserExt, SIGNAL(infoMessage(QString)),
4596  d->m_extension, SIGNAL(infoMessage(QString)) );
4597 
4598  connect( kidBrowserExt, SIGNAL(requestFocus(KParts::ReadOnlyPart*)),
4599  this, SLOT(slotRequestFocus(KParts::ReadOnlyPart*)) );
4600 
4601  kidBrowserExt->setBrowserInterface( d->m_extension->browserInterface() );
4602  }
4603 }
4604 
4605 KParts::ReadOnlyPart *KHTMLPart::createPart( QWidget *parentWidget,
4606  QObject *parent, const QString &mimetype,
4607  QString &serviceName, QStringList &serviceTypes,
4608  const QStringList &params )
4609 {
4610  QString constr;
4611  if ( !serviceName.isEmpty() )
4612  constr.append( QString::fromLatin1( "DesktopEntryName == '%1'" ).arg( serviceName ) );
4613 
4614  KService::List offers = KMimeTypeTrader::self()->query( mimetype, "KParts/ReadOnlyPart", constr );
4615 
4616  if ( offers.isEmpty() ) {
4617  int pos = mimetype.indexOf( "-plugin" );
4618  if (pos < 0)
4619  return 0L;
4620  QString stripped_mime = mimetype.left( pos );
4621  offers = KMimeTypeTrader::self()->query( stripped_mime, "KParts/ReadOnlyPart", constr );
4622  if ( offers.isEmpty() )
4623  return 0L;
4624  }
4625 
4626  KService::List::ConstIterator it = offers.constBegin();
4627  const KService::List::ConstIterator itEnd = offers.constEnd();
4628  for ( ; it != itEnd; ++it )
4629  {
4630  KService::Ptr service = (*it);
4631 
4632  KPluginLoader loader( *service, KHTMLGlobal::componentData() );
4633  KPluginFactory* const factory = loader.factory();
4634  if ( factory ) {
4635  // Turn params into a QVariantList as expected by KPluginFactory
4636  QVariantList variantlist;
4637  Q_FOREACH(const QString& str, params)
4638  variantlist << QVariant(str);
4639 
4640  if ( service->serviceTypes().contains( "Browser/View" ) )
4641  variantlist << QString("Browser/View");
4642 
4643  KParts::ReadOnlyPart* part = factory->create<KParts::ReadOnlyPart>(parentWidget, parent, QString(), variantlist);
4644  if ( part ) {
4645  serviceTypes = service->serviceTypes();
4646  serviceName = service->name();
4647  return part;
4648  }
4649  } else {
4650  // TODO KMessageBox::error and i18n, like in KonqFactory::createView?
4651  kWarning() << QString("There was an error loading the module %1.\nThe diagnostics is:\n%2")
4652  .arg(service->name()).arg(loader.errorString());
4653  }
4654  }
4655  return 0;
4656 }
4657 
4658 KParts::PartManager *KHTMLPart::partManager()
4659 {
4660  if ( !d->m_manager && d->m_view )
4661  {
4662  d->m_manager = new KParts::PartManager( d->m_view->topLevelWidget(), this );
4663  d->m_manager->setObjectName( "khtml part manager" );
4664  d->m_manager->setAllowNestedParts( true );
4665  connect( d->m_manager, SIGNAL(activePartChanged(KParts::Part*)),
4666  this, SLOT(slotActiveFrameChanged(KParts::Part*)) );
4667  connect( d->m_manager, SIGNAL(partRemoved(KParts::Part*)),
4668  this, SLOT(slotPartRemoved(KParts::Part*)) );
4669  }
4670 
4671  return d->m_manager;
4672 }
4673 
4674 void KHTMLPart::submitFormAgain()
4675 {
4676  disconnect(this, SIGNAL(completed()), this, SLOT(submitFormAgain()));
4677  if( d->m_doc && !d->m_doc->parsing() && d->m_submitForm)
4678  KHTMLPart::submitForm( d->m_submitForm->submitAction, d->m_submitForm->submitUrl, d->m_submitForm->submitFormData, d->m_submitForm->target, d->m_submitForm->submitContentType, d->m_submitForm->submitBoundary );
4679 
4680  delete d->m_submitForm;
4681  d->m_submitForm = 0;
4682 }
4683 
4684 void KHTMLPart::submitFormProxy( const char *action, const QString &url, const QByteArray &formData, const QString &_target, const QString& contentType, const QString& boundary )
4685 {
4686  submitForm(action, url, formData, _target, contentType, boundary);
4687 }
4688 
4689 void KHTMLPart::submitForm( const char *action, const QString &url, const QByteArray &formData, const QString &_target, const QString& contentType, const QString& boundary )
4690 {
4691  kDebug(6000) << this << "target=" << _target << "url=" << url;
4692  if (d->m_formNotification == KHTMLPart::Only) {
4693  emit formSubmitNotification(action, url, formData, _target, contentType, boundary);
4694  return;
4695  } else if (d->m_formNotification == KHTMLPart::Before) {
4696  emit formSubmitNotification(action, url, formData, _target, contentType, boundary);
4697  }
4698 
4699  KUrl u = completeURL( url );
4700 
4701  if ( !u.isValid() )
4702  {
4703  // ### ERROR HANDLING!
4704  return;
4705  }
4706 
4707  // Form security checks
4708  //
4709  /*
4710  * If these form security checks are still in this place in a month or two
4711  * I'm going to simply delete them.
4712  */
4713 
4714  /* This is separate for a reason. It has to be _before_ all script, etc,
4715  * AND I don't want to break anything that uses checkLinkSecurity() in
4716  * other places.
4717  */
4718 
4719  if (!d->m_submitForm) {
4720  if (u.protocol() != "https" && u.protocol() != "mailto") {
4721  if (d->m_ssl_in_use) { // Going from SSL -> nonSSL
4722  int rc = KMessageBox::warningContinueCancel(NULL, i18n("Warning: This is a secure form but it is attempting to send your data back unencrypted."
4723  "\nA third party may be able to intercept and view this information."
4724  "\nAre you sure you wish to continue?"),
4725  i18n("Network Transmission"),KGuiItem(i18n("&Send Unencrypted")));
4726  if (rc == KMessageBox::Cancel)
4727  return;
4728  } else { // Going from nonSSL -> nonSSL
4729  KSSLSettings kss(true);
4730  if (kss.warnOnUnencrypted()) {
4731  int rc = KMessageBox::warningContinueCancel(NULL,
4732  i18n("Warning: Your data is about to be transmitted across the network unencrypted."
4733  "\nAre you sure you wish to continue?"),
4734  i18n("Network Transmission"),
4735  KGuiItem(i18n("&Send Unencrypted")),
4736  KStandardGuiItem::cancel(),
4737  "WarnOnUnencryptedForm");
4738  // Move this setting into KSSL instead
4739  QString grpNotifMsgs = QLatin1String("Notification Messages");
4740  KConfigGroup cg( KGlobal::config(), grpNotifMsgs );
4741 
4742  if (!cg.readEntry("WarnOnUnencryptedForm", true)) {
4743  cg.deleteEntry("WarnOnUnencryptedForm");
4744  cg.sync();
4745  kss.setWarnOnUnencrypted(false);
4746  kss.save();
4747  }
4748  if (rc == KMessageBox::Cancel)
4749  return;
4750  }
4751  }
4752  }
4753 
4754  if (u.protocol() == "mailto") {
4755  int rc = KMessageBox::warningContinueCancel(NULL,
4756  i18n("This site is attempting to submit form data via email.\n"
4757  "Do you want to continue?"),
4758  i18n("Network Transmission"),
4759  KGuiItem(i18n("&Send Email")),
4760  KStandardGuiItem::cancel(),
4761  "WarnTriedEmailSubmit");
4762 
4763  if (rc == KMessageBox::Cancel) {
4764  return;
4765  }
4766  }
4767  }
4768 
4769  // End form security checks
4770  //
4771 
4772  QString urlstring = u.url();
4773 
4774  if ( d->isJavaScriptURL(urlstring) ) {
4775  crossFrameExecuteScript( _target, d->codeForJavaScriptURL(urlstring) );
4776  return;
4777  }
4778 
4779  if (!checkLinkSecurity(u,
4780  ki18n( "<qt>The form will be submitted to <br /><b>%1</b><br />on your local filesystem.<br />Do you want to submit the form?</qt>" ),
4781  i18n( "Submit" )))
4782  return;
4783 
4784  // OK. We're actually going to submit stuff. Clear any redirections,
4785  // we should win over them
4786  d->clearRedirection();
4787 
4788  KParts::OpenUrlArguments args;
4789 
4790  if (!d->m_referrer.isEmpty())
4791  args.metaData()["referrer"] = d->m_referrer;
4792 
4793  args.metaData().insert("PropagateHttpHeader", "true");
4794  args.metaData().insert("ssl_parent_ip", d->m_ssl_parent_ip);
4795  args.metaData().insert("ssl_parent_cert", d->m_ssl_parent_cert);
4796  args.metaData().insert("main_frame_request",
4797  parentPart() == 0 ? "TRUE":"FALSE");
4798  args.metaData().insert("ssl_was_in_use", d->m_ssl_in_use ? "TRUE":"FALSE");
4799  args.metaData().insert("ssl_activate_warnings", "TRUE");
4800 //WABA: When we post a form we should treat it as the main url
4801 //the request should never be considered cross-domain
4802 //args.metaData().insert("cross-domain", toplevelURL().url());
4803  KParts::BrowserArguments browserArgs;
4804  browserArgs.frameName = _target.isEmpty() ? d->m_doc->baseTarget() : _target ;
4805 
4806  // Handle mailto: forms
4807  if (u.protocol() == "mailto") {
4808  // 1) Check for attach= and strip it
4809  QString q = u.query().mid(1);
4810  QStringList nvps = q.split("&");
4811  bool triedToAttach = false;
4812 
4813  QStringList::Iterator nvp = nvps.begin();
4814  const QStringList::Iterator nvpEnd = nvps.end();
4815 
4816 // cannot be a for loop as if something is removed we don't want to do ++nvp, as
4817 // remove returns an iterator pointing to the next item
4818 
4819  while (nvp != nvpEnd) {
4820  const QStringList pair = (*nvp).split("=");
4821  if (pair.count() >= 2) {
4822  if (pair.first().toLower() == "attach") {
4823  nvp = nvps.erase(nvp);
4824  triedToAttach = true;
4825  } else {
4826  ++nvp;
4827  }
4828  } else {
4829  ++nvp;
4830  }
4831  }
4832 
4833  if (triedToAttach)
4834  KMessageBox::information(NULL, i18n("This site attempted to attach a file from your computer in the form submission. The attachment was removed for your protection."), i18n("KDE"), "WarnTriedAttach");
4835 
4836  // 2) Append body=
4837  QString bodyEnc;
4838  if (contentType.toLower() == "multipart/form-data") {
4839  // FIXME: is this correct? I suspect not
4840  bodyEnc = QLatin1String( KUrl::toPercentEncoding(QString::fromLatin1(formData.data(),
4841  formData.size())));
4842  } else if (contentType.toLower() == "text/plain") {
4843  // Convention seems to be to decode, and s/&/\n/
4844  QString tmpbody = QString::fromLatin1(formData.data(),
4845  formData.size());
4846  tmpbody.replace(QRegExp("[&]"), "\n");
4847  tmpbody.replace(QRegExp("[+]"), " ");
4848  tmpbody = KUrl::fromPercentEncoding(tmpbody.toLatin1()); // Decode the rest of it
4849  bodyEnc = QLatin1String( KUrl::toPercentEncoding(tmpbody) ); // Recode for the URL
4850  } else {
4851  bodyEnc = QLatin1String( KUrl::toPercentEncoding(QString::fromLatin1(formData.data(),
4852  formData.size())) );
4853  }
4854 
4855  nvps.append(QString("body=%1").arg(bodyEnc));
4856  q = nvps.join("&");
4857  u.setQuery(q);
4858  }
4859 
4860  if ( strcmp( action, "get" ) == 0 ) {
4861  if (u.protocol() != "mailto")
4862  u.setQuery( QString::fromLatin1( formData.data(), formData.size() ) );
4863  browserArgs.setDoPost( false );
4864  }
4865  else {
4866  browserArgs.postData = formData;
4867  browserArgs.setDoPost( true );
4868 
4869  // construct some user headers if necessary
4870  if (contentType.isNull() || contentType == "application/x-www-form-urlencoded")
4871  browserArgs.setContentType( "Content-Type: application/x-www-form-urlencoded" );
4872  else // contentType must be "multipart/form-data"
4873  browserArgs.setContentType( "Content-Type: " + contentType + "; boundary=" + boundary );
4874  }
4875 
4876  if ( d->m_doc->parsing() || d->m_runningScripts > 0 ) {
4877  if( d->m_submitForm ) {
4878  kDebug(6000) << "ABORTING!";
4879  return;
4880  }
4881  d->m_submitForm = new KHTMLPartPrivate::SubmitForm;
4882  d->m_submitForm->submitAction = action;
4883  d->m_submitForm->submitUrl = url;
4884  d->m_submitForm->submitFormData = formData;
4885  d->m_submitForm->target = _target;
4886  d->m_submitForm->submitContentType = contentType;
4887  d->m_submitForm->submitBoundary = boundary;
4888  connect(this, SIGNAL(completed()), this, SLOT(submitFormAgain()));
4889  }
4890  else
4891  {
4892  emit d->m_extension->openUrlRequest( u, args, browserArgs );
4893  }
4894 }
4895 
4896 void KHTMLPart::popupMenu( const QString &linkUrl )
4897 {
4898  KUrl popupURL;
4899  KUrl linkKUrl;
4900  KParts::OpenUrlArguments args;
4901  KParts::BrowserArguments browserArgs;
4902  QString referrer;
4903  KParts::BrowserExtension::PopupFlags itemflags=KParts::BrowserExtension::ShowBookmark | KParts::BrowserExtension::ShowReload;
4904 
4905  if ( linkUrl.isEmpty() ) { // click on background
4906  KHTMLPart* khtmlPart = this;
4907  while ( khtmlPart->parentPart() )
4908  {
4909  khtmlPart=khtmlPart->parentPart();
4910  }
4911  popupURL = khtmlPart->url();
4912  referrer = khtmlPart->pageReferrer();
4913  if (hasSelection())
4914  itemflags = KParts::BrowserExtension::ShowTextSelectionItems;
4915  else
4916  itemflags |= KParts::BrowserExtension::ShowNavigationItems;
4917  } else { // click on link
4918  popupURL = completeURL( linkUrl );
4919  linkKUrl = popupURL;
4920  referrer = this->referrer();
4921  itemflags |= KParts::BrowserExtension::IsLink;
4922 
4923  if (!(d->m_strSelectedURLTarget).isEmpty() &&
4924  (d->m_strSelectedURLTarget.toLower() != "_top") &&
4925  (d->m_strSelectedURLTarget.toLower() != "_self") &&
4926  (d->m_strSelectedURLTarget.toLower() != "_parent")) {
4927  if (d->m_strSelectedURLTarget.toLower() == "_blank")
4928  browserArgs.setForcesNewWindow(true);
4929  else {
4930  KHTMLPart *p = this;
4931  while (p->parentPart())
4932  p = p->parentPart();
4933  if (!p->frameExists(d->m_strSelectedURLTarget))
4934  browserArgs.setForcesNewWindow(true);
4935  }
4936  }
4937  }
4938 
4939  // Danger, Will Robinson. The Popup might stay around for a much
4940  // longer time than KHTMLPart. Deal with it.
4941  KHTMLPopupGUIClient* client = new KHTMLPopupGUIClient( this, linkKUrl );
4942  QPointer<QObject> guard( client );
4943 
4944  QString mimetype = QLatin1String( "text/html" );
4945  args.metaData()["referrer"] = referrer;
4946 
4947  if (!linkUrl.isEmpty()) // over a link
4948  {
4949  if (popupURL.isLocalFile()) // safe to do this
4950  {
4951  mimetype = KMimeType::findByUrl(popupURL,0,true,false)->name();
4952  }
4953  else // look at "extension" of link
4954  {
4955  const QString fname(popupURL.fileName(KUrl::ObeyTrailingSlash));
4956  if (!fname.isEmpty() && !popupURL.hasRef() && popupURL.query().isEmpty())
4957  {
4958  KMimeType::Ptr pmt = KMimeType::findByPath(fname,0,true);
4959 
4960  // Further check for mime types guessed from the extension which,
4961  // on a web page, are more likely to be a script delivering content
4962  // of undecidable type. If the mime type from the extension is one
4963  // of these, don't use it. Retain the original type 'text/html'.
4964  if (pmt->name() != KMimeType::defaultMimeType() &&
4965  !pmt->is("application/x-perl") &&
4966  !pmt->is("application/x-perl-module") &&
4967  !pmt->is("application/x-php") &&
4968  !pmt->is("application/x-python-bytecode") &&
4969  !pmt->is("application/x-python") &&
4970  !pmt->is("application/x-shellscript"))
4971  mimetype = pmt->name();
4972  }
4973  }
4974  }
4975 
4976  args.setMimeType(mimetype);
4977 
4978  emit d->m_extension->popupMenu( QCursor::pos(), popupURL, S_IFREG /*always a file*/,
4979  args, browserArgs, itemflags,
4980  client->actionGroups() );
4981 
4982  if ( !guard.isNull() ) {
4983  delete client;
4984  emit popupMenu(linkUrl, QCursor::pos());
4985  d->m_strSelectedURL.clear();
4986  d->m_strSelectedURLTarget.clear();
4987  }
4988 }
4989 
4990 void KHTMLPart::slotParentCompleted()
4991 {
4992  //kDebug(6050) << this;
4993  if ( !d->m_redirectURL.isEmpty() && !d->m_redirectionTimer.isActive() )
4994  {
4995  //kDebug(6050) << this << ": starting timer for child redirection -> " << d->m_redirectURL;
4996  d->m_redirectionTimer.setSingleShot( true );
4997  d->m_redirectionTimer.start( qMax(0, 1000 * d->m_delayRedirect) );
4998  }
4999 }
5000 
5001 void KHTMLPart::slotChildStarted( KIO::Job *job )
5002 {
5003  khtml::ChildFrame *child = frame( sender() );
5004 
5005  assert( child );
5006 
5007  child->m_bCompleted = false;
5008 
5009  if ( d->m_bComplete )
5010  {
5011 #if 0
5012  // WABA: Looks like this belongs somewhere else
5013  if ( !parentPart() ) // "toplevel" html document? if yes, then notify the hosting browser about the document (url) changes
5014  {
5015  emit d->m_extension->openURLNotify();
5016  }
5017 #endif
5018  d->m_bComplete = false;
5019  emit started( job );
5020  }
5021 }
5022 
5023 void KHTMLPart::slotChildCompleted()
5024 {
5025  slotChildCompleted( false );
5026 }
5027 
5028 void KHTMLPart::slotChildCompleted( bool pendingAction )
5029 {
5030  khtml::ChildFrame *child = frame( sender() );
5031 
5032  if ( child ) {
5033  kDebug(6031) << this << "child=" << child << "m_partContainerElement=" << child->m_partContainerElement;
5034  child->m_bCompleted = true;
5035  child->m_bPendingRedirection = pendingAction;
5036  child->m_args = KParts::OpenUrlArguments();
5037  child->m_browserArgs = KParts::BrowserArguments();
5038  // dispatch load event. We don't do that for KHTMLPart's since their internal
5039  // load will be forwarded inside NodeImpl::dispatchWindowEvent
5040  if (!qobject_cast<KHTMLPart*>(child->m_part))
5041  QTimer::singleShot(0, child->m_partContainerElement.data(), SLOT(slotEmitLoadEvent()));
5042  }
5043  checkCompleted();
5044 }
5045 
5046 void KHTMLPart::slotChildDocCreated()
5047 {
5048  // Set domain to the frameset's domain
5049  // This must only be done when loading the frameset initially (#22039),
5050  // not when following a link in a frame (#44162).
5051  if (KHTMLPart* htmlFrame = qobject_cast<KHTMLPart*>(sender()))
5052  d->propagateInitialDomainAndBaseTo(htmlFrame);
5053 
5054  // So it only happens once
5055  disconnect( sender(), SIGNAL(docCreated()), this, SLOT(slotChildDocCreated()) );
5056 }
5057 
5058 void KHTMLPartPrivate::propagateInitialDomainAndBaseTo(KHTMLPart* kid)
5059 {
5060  // This method is used to propagate our domain and base information for
5061  // child frames, to provide them for about: or JavaScript: URLs
5062  if ( m_doc && kid->d->m_doc ) {
5063  DocumentImpl* kidDoc = kid->d->m_doc;
5064  if ( kidDoc->origin()->isEmpty() ) {
5065  kidDoc->setOrigin ( m_doc->origin() );
5066  kidDoc->setBaseURL( m_doc->baseURL() );
5067  }
5068  }
5069 }
5070 
5071 void KHTMLPart::slotChildURLRequest( const KUrl &url, const KParts::OpenUrlArguments& args, const KParts::BrowserArguments &browserArgs )
5072 {
5073  khtml::ChildFrame *child = frame( sender()->parent() );
5074  KHTMLPart *callingHtmlPart = const_cast<KHTMLPart *>(dynamic_cast<const KHTMLPart *>(sender()->parent()));
5075 
5076  // TODO: handle child target correctly! currently the script are always executed for the parent
5077  QString urlStr = url.url();
5078  if ( d->isJavaScriptURL(urlStr) ) {
5079  executeScript( DOM::Node(), d->codeForJavaScriptURL(urlStr) );
5080  return;
5081  }
5082 
5083  QString frameName = browserArgs.frameName.toLower();
5084  if ( !frameName.isEmpty() ) {
5085  if ( frameName == QLatin1String( "_top" ) )
5086  {
5087  emit d->m_extension->openUrlRequest( url, args, browserArgs );
5088  return;
5089  }
5090  else if ( frameName == QLatin1String( "_blank" ) )
5091  {
5092  emit d->m_extension->createNewWindow( url, args, browserArgs );
5093  return;
5094  }
5095  else if ( frameName == QLatin1String( "_parent" ) )
5096  {
5097  KParts::BrowserArguments newBrowserArgs( browserArgs );
5098  newBrowserArgs.frameName.clear();
5099  emit d->m_extension->openUrlRequest( url, args, newBrowserArgs );
5100  return;
5101  }
5102  else if ( frameName != QLatin1String( "_self" ) )
5103  {
5104  khtml::ChildFrame *_frame = recursiveFrameRequest( callingHtmlPart, url, args, browserArgs );
5105 
5106  if ( !_frame )
5107  {
5108  emit d->m_extension->openUrlRequest( url, args, browserArgs );
5109  return;
5110  }
5111 
5112  child = _frame;
5113  }
5114  }
5115 
5116  if ( child && child->m_type != khtml::ChildFrame::Object ) {
5117  // Inform someone that we are about to show something else.
5118  child->m_bNotify = true;
5119  requestObject( child, url, args, browserArgs );
5120  } else if ( frameName== "_self" ) // this is for embedded objects (via <object>) which want to replace the current document
5121  {
5122  KParts::BrowserArguments newBrowserArgs( browserArgs );
5123  newBrowserArgs.frameName.clear();
5124  emit d->m_extension->openUrlRequest( url, args, newBrowserArgs );
5125  }
5126 }
5127 
5128 void KHTMLPart::slotRequestFocus( KParts::ReadOnlyPart * )
5129 {
5130  emit d->m_extension->requestFocus(this);
5131 }
5132 
5133 khtml::ChildFrame *KHTMLPart::frame( const QObject *obj )
5134 {
5135  assert( obj->inherits( "KParts::ReadOnlyPart" ) );
5136  const KParts::ReadOnlyPart* const part = static_cast<const KParts::ReadOnlyPart *>( obj );
5137 
5138  FrameIt it = d->m_frames.begin();
5139  const FrameIt end = d->m_frames.end();
5140  for (; it != end; ++it ) {
5141  if ((*it)->m_part.data() == part )
5142  return *it;
5143  }
5144 
5145  FrameIt oi = d->m_objects.begin();
5146  const FrameIt oiEnd = d->m_objects.end();
5147  for (; oi != oiEnd; ++oi ) {
5148  if ((*oi)->m_part.data() == part)
5149  return *oi;
5150  }
5151 
5152  return 0L;
5153 }
5154 
5155 //#define DEBUG_FINDFRAME
5156 
5157 bool KHTMLPart::checkFrameAccess(KHTMLPart *callingHtmlPart)
5158 {
5159  if (callingHtmlPart == this)
5160  return true; // trivial
5161 
5162  if (!xmlDocImpl()) {
5163 #ifdef DEBUG_FINDFRAME
5164  kDebug(6050) << "Empty part" << this << "URL = " << url();
5165 #endif
5166  return false; // we are empty?
5167  }
5168 
5169  // now compare the domains
5170  if (callingHtmlPart && callingHtmlPart->xmlDocImpl() && xmlDocImpl()) {
5171  khtml::SecurityOrigin* actDomain = callingHtmlPart->xmlDocImpl()->origin();
5172  khtml::SecurityOrigin* destDomain = xmlDocImpl()->origin();
5173 
5174  if (actDomain->canAccess(destDomain))
5175  return true;
5176  }
5177 #ifdef DEBUG_FINDFRAME
5178  else
5179  {
5180  kDebug(6050) << "Unknown part/domain" << callingHtmlPart << "tries to access part" << this;
5181  }
5182 #endif
5183  return false;
5184 }
5185 
5186 KHTMLPart *
5187 KHTMLPart::findFrameParent( KParts::ReadOnlyPart *callingPart, const QString &f, khtml::ChildFrame **childFrame )
5188 {
5189  return d->findFrameParent(callingPart, f, childFrame, false);
5190 }
5191 
5192 KHTMLPart* KHTMLPartPrivate::findFrameParent(KParts::ReadOnlyPart* callingPart,
5193  const QString& f, khtml::ChildFrame **childFrame, bool checkForNavigation)
5194 {
5195 #ifdef DEBUG_FINDFRAME
5196  kDebug(6050) << q << "URL =" << q->url() << "name =" << q->objectName() << "findFrameParent(" << f << ")";
5197 #endif
5198  // Check access
5199  KHTMLPart* const callingHtmlPart = qobject_cast<KHTMLPart *>(callingPart);
5200 
5201  if (!callingHtmlPart)
5202  return 0;
5203 
5204  if (!checkForNavigation && !q->checkFrameAccess(callingHtmlPart))
5205  return 0;
5206 
5207  if (!childFrame && !q->parentPart() && (q->objectName() == f)) {
5208  if (!checkForNavigation || callingHtmlPart->d->canNavigate(q))
5209  return q;
5210  }
5211 
5212  FrameIt it = m_frames.find( f );
5213  const FrameIt end = m_frames.end();
5214  if ( it != end )
5215  {
5216 #ifdef DEBUG_FINDFRAME
5217  kDebug(6050) << "FOUND!";
5218 #endif
5219  if (!checkForNavigation || callingHtmlPart->d->canNavigate((*it)->m_part.data())) {
5220  if (childFrame)
5221  *childFrame = *it;
5222  return q;
5223  }
5224  }
5225 
5226  it = m_frames.begin();
5227  for (; it != end; ++it )
5228  {
5229  if ( KHTMLPart* p = qobject_cast<KHTMLPart*>((*it)->m_part.data()) )
5230  {
5231  KHTMLPart* const frameParent = p->d->findFrameParent(callingPart, f, childFrame, checkForNavigation);
5232  if (frameParent)
5233  return frameParent;
5234  }
5235  }
5236  return 0;
5237 }
5238 
5239 KHTMLPart* KHTMLPartPrivate::top()
5240 {
5241  KHTMLPart* t = q;
5242  while (t->parentPart())
5243  t = t->parentPart();
5244  return t;
5245 }
5246 
5247 bool KHTMLPartPrivate::canNavigate(KParts::ReadOnlyPart* bCand)
5248 {
5249  if (!bCand) // No part here (e.g. invalid url), reuse that frame
5250  return true;
5251 
5252  KHTMLPart* b = qobject_cast<KHTMLPart*>(bCand);
5253  if (!b) // Another kind of part? Not sure what to do...
5254  return false;
5255 
5256  // HTML5 gives conditions for this (a) being able to navigate b
5257 
5258  // 1) Same domain
5259  if (q->checkFrameAccess(b))
5260  return true;
5261 
5262  // 2) A is nested, with B its top
5263  if (q->parentPart() && top() == b)
5264  return true;
5265 
5266  // 3) B is 'auxilary' -- window.open with opener,
5267  // and A can navigate B's opener
5268  if (b->opener() && canNavigate(b->opener()))
5269  return true;
5270 
5271  // 4) B is not top-level, but an ancestor of it has same origin as A
5272  for (KHTMLPart* anc = b->parentPart(); anc; anc = anc->parentPart()) {
5273  if (anc->checkFrameAccess(q))
5274  return true;
5275  }
5276 
5277  return false;
5278 }
5279 
5280 KHTMLPart *KHTMLPart::findFrame( const QString &f )
5281 {
5282  khtml::ChildFrame *childFrame;
5283  KHTMLPart *parentFrame = findFrameParent(this, f, &childFrame);
5284  if (parentFrame)
5285  return qobject_cast<KHTMLPart*>(childFrame->m_part.data());
5286 
5287  return 0;
5288 }
5289 
5290 KParts::ReadOnlyPart *KHTMLPart::findFramePart(const QString &f)
5291 {
5292  khtml::ChildFrame *childFrame;
5293  return findFrameParent(this, f, &childFrame) ? childFrame->m_part.data() : 0L;
5294 }
5295 
5296 KParts::ReadOnlyPart *KHTMLPart::currentFrame() const
5297 {
5298  KParts::ReadOnlyPart* part = (KParts::ReadOnlyPart*)(this);
5299  // Find active part in our frame manager, in case we are a frameset
5300  // and keep doing that (in case of nested framesets).
5301  // Just realized we could also do this recursively, calling part->currentFrame()...
5302  while ( part && part->inherits("KHTMLPart") &&
5303  static_cast<KHTMLPart *>(part)->d->m_frames.count() > 0 ) {
5304  KHTMLPart* frameset = static_cast<KHTMLPart *>(part);
5305  part = static_cast<KParts::ReadOnlyPart *>(frameset->partManager()->activePart());
5306  if ( !part ) return frameset;
5307  }
5308  return part;
5309 }
5310 
5311 bool KHTMLPart::frameExists( const QString &frameName )
5312 {
5313  FrameIt it = d->m_frames.find( frameName );
5314  if ( it == d->m_frames.end() )
5315  return false;
5316 
5317  // WABA: We only return true if the child actually has a frame
5318  // set. Otherwise we might find our preloaded-selve.
5319  // This happens when we restore the frameset.
5320  return (!(*it)->m_partContainerElement.isNull());
5321 }
5322 
5323 void KHTMLPartPrivate::renameFrameForContainer(DOM::HTMLPartContainerElementImpl* cont,
5324  const QString& newName)
5325 {
5326  for (int i = 0; i < m_frames.size(); ++i) {
5327  khtml::ChildFrame* f = m_frames[i];
5328  if (f->m_partContainerElement.data() == cont)
5329  f->m_name = newName;
5330  }
5331 }
5332 
5333 KJSProxy *KHTMLPart::framejScript(KParts::ReadOnlyPart *framePart)
5334 {
5335  KHTMLPart* const kp = qobject_cast<KHTMLPart*>(framePart);
5336  if (kp)
5337  return kp->jScript();
5338 
5339  FrameIt it = d->m_frames.begin();
5340  const FrameIt itEnd = d->m_frames.end();
5341 
5342  for (; it != itEnd; ++it) {
5343  khtml::ChildFrame* frame = *it;
5344  if (framePart == frame->m_part.data()) {
5345  if (!frame->m_jscript)
5346  frame->m_jscript = new KJSProxy(frame);
5347  return frame->m_jscript;
5348  }
5349  }
5350  return 0L;
5351 }
5352 
5353 KHTMLPart *KHTMLPart::parentPart()
5354 {
5355  return qobject_cast<KHTMLPart*>( parent() );
5356 }
5357 
5358 khtml::ChildFrame *KHTMLPart::recursiveFrameRequest( KHTMLPart *callingHtmlPart, const KUrl &url,
5359  const KParts::OpenUrlArguments &args,
5360  const KParts::BrowserArguments &browserArgs, bool callParent )
5361 {
5362 #ifdef DEBUG_FINDFRAME
5363  kDebug( 6050 ) << this << "frame = " << browserArgs.frameName << "url = " << url;
5364 #endif
5365  khtml::ChildFrame *childFrame;
5366  KHTMLPart *childPart = findFrameParent(callingHtmlPart, browserArgs.frameName, &childFrame);
5367  if (childPart)
5368  {
5369  if (childPart == this)
5370  return childFrame;
5371 
5372  childPart->requestObject( childFrame, url, args, browserArgs );
5373  return 0;
5374  }
5375 
5376  if ( parentPart() && callParent )
5377  {
5378  khtml::ChildFrame *res = parentPart()->recursiveFrameRequest( callingHtmlPart, url, args, browserArgs, callParent );
5379 
5380  if ( res )
5381  parentPart()->requestObject( res, url, args, browserArgs );
5382  }
5383 
5384  return 0L;
5385 }
5386 
5387 #ifdef DEBUG_SAVESTATE
5388 static int s_saveStateIndentLevel = 0;
5389 #endif
5390 
5391 void KHTMLPart::saveState( QDataStream &stream )
5392 {
5393 #ifdef DEBUG_SAVESTATE
5394  QString indent= QString().leftJustified( s_saveStateIndentLevel * 4, ' ' );
5395  const int indentLevel = s_saveStateIndentLevel++;
5396  kDebug( 6050 ) << indent << "saveState this=" << this << " '" << objectName() << "' saving URL " << url().url();
5397 #endif
5398 
5399  stream << url() << (qint32)d->m_view->contentsX() << (qint32)d->m_view->contentsY()
5400  << (qint32) d->m_view->contentsWidth() << (qint32) d->m_view->contentsHeight() << (qint32) d->m_view->marginWidth() << (qint32) d->m_view->marginHeight();
5401 
5402  // save link cursor position
5403  int focusNodeNumber;
5404  if (!d->m_focusNodeRestored)
5405  focusNodeNumber = d->m_focusNodeNumber;
5406  else if (d->m_doc && d->m_doc->focusNode())
5407  focusNodeNumber = d->m_doc->nodeAbsIndex(d->m_doc->focusNode());
5408  else
5409  focusNodeNumber = -1;
5410  stream << focusNodeNumber;
5411 
5412  // Save the doc's cache id.
5413  stream << d->m_cacheId;
5414 
5415  // Save the state of the document (Most notably the state of any forms)
5416  QStringList docState;
5417  if (d->m_doc)
5418  {
5419  docState = d->m_doc->docState();
5420  }
5421  stream << d->m_encoding << d->m_sheetUsed << docState;
5422 
5423  stream << d->m_zoomFactor;
5424  stream << d->m_fontScaleFactor;
5425 
5426  stream << d->m_httpHeaders;
5427  stream << d->m_pageServices;
5428  stream << d->m_pageReferrer;
5429 
5430  // Save ssl data
5431  stream << d->m_ssl_in_use
5432  << d->m_ssl_peer_chain
5433  << d->m_ssl_peer_ip
5434  << d->m_ssl_cipher
5435  << d->m_ssl_protocol_version
5436  << d->m_ssl_cipher_used_bits
5437  << d->m_ssl_cipher_bits
5438  << d->m_ssl_cert_errors
5439  << d->m_ssl_parent_ip
5440  << d->m_ssl_parent_cert;
5441 
5442 
5443  QStringList frameNameLst, frameServiceTypeLst, frameServiceNameLst;
5444  KUrl::List frameURLLst;
5445  QList<QByteArray> frameStateBufferLst;
5446  QList<int> frameTypeLst;
5447 
5448  ConstFrameIt it = d->m_frames.constBegin();
5449  const ConstFrameIt end = d->m_frames.constEnd();
5450  for (; it != end; ++it )
5451  {
5452  if ( !(*it)->m_part )
5453  continue;
5454 
5455  frameNameLst << (*it)->m_name;
5456  frameServiceTypeLst << (*it)->m_serviceType;
5457  frameServiceNameLst << (*it)->m_serviceName;
5458  frameURLLst << (*it)->m_part.data()->url();
5459 
5460  QByteArray state;
5461  QDataStream frameStream( &state, QIODevice::WriteOnly );
5462 
5463  if ( (*it)->m_extension )
5464  (*it)->m_extension.data()->saveState( frameStream );
5465 
5466  frameStateBufferLst << state;
5467 
5468  frameTypeLst << int( (*it)->m_type );
5469  }
5470 
5471  // Save frame data
5472  stream << (quint32) frameNameLst.count();
5473  stream << frameNameLst << frameServiceTypeLst << frameServiceNameLst << frameURLLst << frameStateBufferLst << frameTypeLst;
5474 #ifdef DEBUG_SAVESTATE
5475  s_saveStateIndentLevel = indentLevel;
5476 #endif
5477 }
5478 
5479 void KHTMLPart::restoreState( QDataStream &stream )
5480 {
5481  KUrl u;
5482  qint32 xOffset, yOffset, wContents, hContents, mWidth, mHeight;
5483  quint32 frameCount;
5484  QStringList frameNames, frameServiceTypes, docState, frameServiceNames;
5485  QList<int> frameTypes;
5486  KUrl::List frameURLs;
5487  QList<QByteArray> frameStateBuffers;
5488  QList<int> fSizes;
5489  QString encoding, sheetUsed;
5490  long old_cacheId = d->m_cacheId;
5491 
5492  stream >> u >> xOffset >> yOffset >> wContents >> hContents >> mWidth >> mHeight;
5493 
5494  d->m_view->setMarginWidth( mWidth );
5495  d->m_view->setMarginHeight( mHeight );
5496 
5497  // restore link cursor position
5498  // nth node is active. value is set in checkCompleted()
5499  stream >> d->m_focusNodeNumber;
5500  d->m_focusNodeRestored = false;
5501 
5502  stream >> d->m_cacheId;
5503 
5504  stream >> encoding >> sheetUsed >> docState;
5505 
5506  d->m_encoding = encoding;
5507  d->m_sheetUsed = sheetUsed;
5508 
5509  int zoomFactor;
5510  stream >> zoomFactor;
5511  setZoomFactor(zoomFactor);
5512 
5513  int fontScaleFactor;
5514  stream >> fontScaleFactor;
5515  setFontScaleFactor(fontScaleFactor);
5516 
5517  stream >> d->m_httpHeaders;
5518  stream >> d->m_pageServices;
5519  stream >> d->m_pageReferrer;
5520 
5521  // Restore ssl data
5522  stream >> d->m_ssl_in_use
5523  >> d->m_ssl_peer_chain
5524  >> d->m_ssl_peer_ip
5525  >> d->m_ssl_cipher
5526  >> d->m_ssl_protocol_version
5527  >> d->m_ssl_cipher_used_bits
5528  >> d->m_ssl_cipher_bits
5529  >> d->m_ssl_cert_errors
5530  >> d->m_ssl_parent_ip
5531  >> d->m_ssl_parent_cert;
5532 
5533  setPageSecurity( d->m_ssl_in_use ? Encrypted : NotCrypted );
5534 
5535  stream >> frameCount >> frameNames >> frameServiceTypes >> frameServiceNames
5536  >> frameURLs >> frameStateBuffers >> frameTypes;
5537 
5538  d->m_bComplete = false;
5539  d->m_bLoadEventEmitted = false;
5540 
5541 // kDebug( 6050 ) << "docState.count() = " << docState.count();
5542 // kDebug( 6050 ) << "m_url " << url().url() << " <-> " << u.url();
5543 // kDebug( 6050 ) << "m_frames.count() " << d->m_frames.count() << " <-> " << frameCount;
5544 
5545  if (d->m_cacheId == old_cacheId && signed(frameCount) == d->m_frames.count())
5546  {
5547  // Partial restore
5548  d->m_redirectionTimer.stop();
5549 
5550  FrameIt fIt = d->m_frames.begin();
5551  const FrameIt fEnd = d->m_frames.end();
5552 
5553  for (; fIt != fEnd; ++fIt )
5554  (*fIt)->m_bCompleted = false;
5555 
5556  fIt = d->m_frames.begin();
5557 
5558  QStringList::ConstIterator fNameIt = frameNames.constBegin();
5559  QStringList::ConstIterator fServiceTypeIt = frameServiceTypes.constBegin();
5560  QStringList::ConstIterator fServiceNameIt = frameServiceNames.constBegin();
5561  KUrl::List::ConstIterator fURLIt = frameURLs.constBegin();
5562  QList<QByteArray>::ConstIterator fBufferIt = frameStateBuffers.constBegin();
5563  QList<int>::ConstIterator fFrameTypeIt = frameTypes.constBegin();
5564 
5565  for (; fIt != fEnd; ++fIt, ++fNameIt, ++fServiceTypeIt, ++fServiceNameIt, ++fURLIt, ++fBufferIt, ++fFrameTypeIt )
5566  {
5567  khtml::ChildFrame* const child = *fIt;
5568 
5569 // kDebug( 6050 ) << *fNameIt << " ---- " << *fServiceTypeIt;
5570 
5571  if ( child->m_name != *fNameIt || child->m_serviceType != *fServiceTypeIt )
5572  {
5573  child->m_bPreloaded = true;
5574  child->m_name = *fNameIt;
5575  child->m_serviceName = *fServiceNameIt;
5576  child->m_type = static_cast<khtml::ChildFrame::Type>(*fFrameTypeIt);
5577  processObjectRequest( child, *fURLIt, *fServiceTypeIt );
5578  }
5579  if ( child->m_part )
5580  {
5581  child->m_bCompleted = false;
5582  if ( child->m_extension && !(*fBufferIt).isEmpty() )
5583  {
5584  QDataStream frameStream( *fBufferIt );
5585  child->m_extension.data()->restoreState( frameStream );
5586  }
5587  else
5588  child->m_part.data()->openUrl( *fURLIt );
5589  }
5590  }
5591 
5592  KParts::OpenUrlArguments args( arguments() );
5593  args.setXOffset(xOffset);
5594  args.setYOffset(yOffset);
5595  setArguments(args);
5596 
5597  KParts::BrowserArguments browserArgs( d->m_extension->browserArguments() );
5598  browserArgs.docState = docState;
5599  d->m_extension->setBrowserArguments(browserArgs);
5600 
5601  d->m_view->resizeContents( wContents, hContents );
5602  d->m_view->setContentsPos( xOffset, yOffset );
5603 
5604  setUrl(u);
5605  }
5606  else
5607  {
5608  // Full restore.
5609  closeUrl();
5610  // We must force a clear because we want to be sure to delete all
5611  // frames.
5612  d->m_bCleared = false;
5613  clear();
5614  d->m_encoding = encoding;
5615  d->m_sheetUsed = sheetUsed;
5616 
5617  QStringList::ConstIterator fNameIt = frameNames.constBegin();
5618  const QStringList::ConstIterator fNameEnd = frameNames.constEnd();
5619 
5620  QStringList::ConstIterator fServiceTypeIt = frameServiceTypes.constBegin();
5621  QStringList::ConstIterator fServiceNameIt = frameServiceNames.constBegin();
5622  KUrl::List::ConstIterator fURLIt = frameURLs.constBegin();
5623  QList<QByteArray>::ConstIterator fBufferIt = frameStateBuffers.constBegin();
5624  QList<int>::ConstIterator fFrameTypeIt = frameTypes.constBegin();
5625 
5626  for (; fNameIt != fNameEnd; ++fNameIt, ++fServiceTypeIt, ++fServiceNameIt, ++fURLIt, ++fBufferIt, ++fFrameTypeIt )
5627  {
5628  khtml::ChildFrame* const newChild = new khtml::ChildFrame;
5629  newChild->m_bPreloaded = true;
5630  newChild->m_name = *fNameIt;
5631  newChild->m_serviceName = *fServiceNameIt;
5632  newChild->m_type = static_cast<khtml::ChildFrame::Type>(*fFrameTypeIt);
5633 
5634 // kDebug( 6050 ) << *fNameIt << " ---- " << *fServiceTypeIt;
5635 
5636  const FrameIt childFrame = d->m_frames.insert( d->m_frames.end(), newChild );
5637 
5638  processObjectRequest( *childFrame, *fURLIt, *fServiceTypeIt );
5639 
5640  (*childFrame)->m_bPreloaded = true;
5641 
5642  if ( (*childFrame)->m_part )
5643  {
5644  if ( (*childFrame)->m_extension && !(*fBufferIt).isEmpty() )
5645  {
5646  QDataStream frameStream( *fBufferIt );
5647  (*childFrame)->m_extension.data()->restoreState( frameStream );
5648  }
5649  else
5650  (*childFrame)->m_part.data()->openUrl( *fURLIt );
5651  }
5652  }
5653 
5654  KParts::OpenUrlArguments args( arguments() );
5655  args.setXOffset(xOffset);
5656  args.setYOffset(yOffset);
5657  setArguments(args);
5658 
5659  KParts::BrowserArguments browserArgs( d->m_extension->browserArguments() );
5660  browserArgs.docState = docState;
5661  d->m_extension->setBrowserArguments(browserArgs);
5662 
5663  if (!KHTMLPageCache::self()->isComplete(d->m_cacheId))
5664  {
5665  d->m_restored = true;
5666  openUrl( u );
5667  d->m_restored = false;
5668  }
5669  else
5670  {
5671  restoreURL( u );
5672  }
5673  }
5674 
5675 }
5676 
5677 void KHTMLPart::show()
5678 {
5679  if ( widget() )
5680  widget()->show();
5681 }
5682 
5683 void KHTMLPart::hide()
5684 {
5685  if ( widget() )
5686  widget()->hide();
5687 }
5688 
5689 DOM::Node KHTMLPart::nodeUnderMouse() const
5690 {
5691  return d->m_view->nodeUnderMouse();
5692 }
5693 
5694 DOM::Node KHTMLPart::nonSharedNodeUnderMouse() const
5695 {
5696  return d->m_view->nonSharedNodeUnderMouse();
5697 }
5698 
5699 void KHTMLPart::emitSelectionChanged()
5700 {
5701  // Don't emit signals about our selection if this is a frameset;
5702  // the active frame has the selection (#187403)
5703  if (!d->m_activeFrame)
5704  {
5705  emit d->m_extension->enableAction( "copy", hasSelection() );
5706  emit d->m_extension->selectionInfo( selectedText() );
5707  emit selectionChanged();
5708  }
5709 }
5710 
5711 int KHTMLPart::zoomFactor() const
5712 {
5713  return d->m_zoomFactor;
5714 }
5715 
5716 // ### make the list configurable ?
5717 static const int zoomSizes[] = { 20, 40, 60, 80, 90, 95, 100, 105, 110, 120, 140, 160, 180, 200, 250, 300 };
5718 static const int zoomSizeCount = (sizeof(zoomSizes) / sizeof(int));
5719 static const int minZoom = 20;
5720 static const int maxZoom = 300;
5721 
5722 // My idea of useful stepping ;-) (LS)
5723 extern const int KDE_NO_EXPORT fastZoomSizes[] = { 20, 50, 75, 90, 100, 120, 150, 200, 300 };
5724 extern const int KDE_NO_EXPORT fastZoomSizeCount = sizeof fastZoomSizes / sizeof fastZoomSizes[0];
5725 
5726 void KHTMLPart::slotIncZoom()
5727 {
5728  zoomIn(zoomSizes, zoomSizeCount);
5729 }
5730 
5731 void KHTMLPart::slotDecZoom()
5732 {
5733  zoomOut(zoomSizes, zoomSizeCount);
5734 }
5735 
5736 void KHTMLPart::slotIncZoomFast()
5737 {
5738  zoomIn(fastZoomSizes, fastZoomSizeCount);
5739 }
5740 
5741 void KHTMLPart::slotDecZoomFast()
5742 {
5743  zoomOut(fastZoomSizes, fastZoomSizeCount);
5744 }
5745 
5746 void KHTMLPart::zoomIn(const int stepping[], int count)
5747 {
5748  int zoomFactor = d->m_zoomFactor;
5749 
5750  if (zoomFactor < maxZoom) {
5751  // find the entry nearest to the given zoomsizes
5752  for (int i = 0; i < count; ++i)
5753  if (stepping[i] > zoomFactor) {
5754  zoomFactor = stepping[i];
5755  break;
5756  }
5757  setZoomFactor(zoomFactor);
5758  }
5759 }
5760 
5761 void KHTMLPart::zoomOut(const int stepping[], int count)
5762 {
5763  int zoomFactor = d->m_zoomFactor;
5764  if (zoomFactor > minZoom) {
5765  // find the entry nearest to the given zoomsizes
5766  for (int i = count-1; i >= 0; --i)
5767  if (stepping[i] < zoomFactor) {
5768  zoomFactor = stepping[i];
5769  break;
5770  }
5771  setZoomFactor(zoomFactor);
5772  }
5773 }
5774 
5775 void KHTMLPart::setZoomFactor (int percent)
5776 {
5777  // ### zooming under 100% is majorly botched,
5778  // so disable that for now.
5779  if (percent < 100) percent = 100;
5780  // ### if (percent < minZoom) percent = minZoom;
5781 
5782  if (percent > maxZoom) percent = maxZoom;
5783  if (d->m_zoomFactor == percent) return;
5784  d->m_zoomFactor = percent;
5785 
5786  updateZoomFactor();
5787 }
5788 
5789 
5790 void KHTMLPart::updateZoomFactor ()
5791 {
5792  if(d->m_view) {
5793  QApplication::setOverrideCursor( Qt::WaitCursor );
5794  d->m_view->setZoomLevel( d->m_zoomFactor );
5795  QApplication::restoreOverrideCursor();
5796  }
5797 
5798  ConstFrameIt it = d->m_frames.constBegin();
5799  const ConstFrameIt end = d->m_frames.constEnd();
5800  for (; it != end; ++it ) {
5801  if ( KHTMLPart* p = qobject_cast<KHTMLPart*>((*it)->m_part.data()) )
5802  p->setZoomFactor(d->m_zoomFactor);
5803  }
5804 
5805  if ( d->m_guiProfile == BrowserViewGUI ) {
5806  d->m_paDecZoomFactor->setEnabled( d->m_zoomFactor > minZoom );
5807  d->m_paIncZoomFactor->setEnabled( d->m_zoomFactor < maxZoom );
5808  }
5809 }
5810 
5811 void KHTMLPart::slotIncFontSize()
5812 {
5813  incFontSize(zoomSizes, zoomSizeCount);
5814 }
5815 
5816 void KHTMLPart::slotDecFontSize()
5817 {
5818  decFontSize(zoomSizes, zoomSizeCount);
5819 }
5820 
5821 void KHTMLPart::slotIncFontSizeFast()
5822 {
5823  incFontSize(fastZoomSizes, fastZoomSizeCount);
5824 }
5825 
5826 void KHTMLPart::slotDecFontSizeFast()
5827 {
5828  decFontSize(fastZoomSizes, fastZoomSizeCount);
5829 }
5830 
5831 void KHTMLPart::incFontSize(const int stepping[], int count)
5832 {
5833  int zoomFactor = d->m_fontScaleFactor;
5834 
5835  if (zoomFactor < maxZoom) {
5836  // find the entry nearest to the given zoomsizes
5837  for (int i = 0; i < count; ++i)
5838  if (stepping[i] > zoomFactor) {
5839  zoomFactor = stepping[i];
5840  break;
5841  }
5842  setFontScaleFactor(zoomFactor);
5843  }
5844 }
5845 
5846 void KHTMLPart::decFontSize(const int stepping[], int count)
5847 {
5848  int zoomFactor = d->m_fontScaleFactor;
5849  if (zoomFactor > minZoom) {
5850  // find the entry nearest to the given zoomsizes
5851  for (int i = count-1; i >= 0; --i)
5852  if (stepping[i] < zoomFactor) {
5853  zoomFactor = stepping[i];
5854  break;
5855  }
5856  setFontScaleFactor(zoomFactor);
5857  }
5858 }
5859 
5860 void KHTMLPart::setFontScaleFactor(int percent)
5861 {
5862  if (percent < minZoom) percent = minZoom;
5863  if (percent > maxZoom) percent = maxZoom;
5864  if (d->m_fontScaleFactor == percent) return;
5865  d->m_fontScaleFactor = percent;
5866 
5867  if (d->m_view && d->m_doc) {
5868  QApplication::setOverrideCursor( Qt::WaitCursor );
5869  if (d->m_doc->styleSelector())
5870  d->m_doc->styleSelector()->computeFontSizes(d->m_doc->logicalDpiY(), d->m_fontScaleFactor);
5871  d->m_doc->recalcStyle( NodeImpl::Force );
5872  QApplication::restoreOverrideCursor();
5873  }
5874 
5875  ConstFrameIt it = d->m_frames.constBegin();
5876  const ConstFrameIt end = d->m_frames.constEnd();
5877  for (; it != end; ++it ) {
5878  if ( KHTMLPart* p = qobject_cast<KHTMLPart*>((*it)->m_part.data()) )
5879  p->setFontScaleFactor(d->m_fontScaleFactor);
5880  }
5881 }
5882 
5883 int KHTMLPart::fontScaleFactor() const
5884 {
5885  return d->m_fontScaleFactor;
5886 }
5887 
5888 void KHTMLPart::slotZoomView( int delta )
5889 {
5890  if ( delta < 0 )
5891  slotIncZoom();
5892  else
5893  slotDecZoom();
5894 }
5895 
5896 void KHTMLPart::setStatusBarText( const QString& text, StatusBarPriority p)
5897 {
5898  if (!d->m_statusMessagesEnabled)
5899  return;
5900 
5901  d->m_statusBarText[p] = text;
5902 
5903  // shift handling ?
5904  QString tobe = d->m_statusBarText[BarHoverText];
5905  if (tobe.isEmpty())
5906  tobe = d->m_statusBarText[BarOverrideText];
5907  if (tobe.isEmpty()) {
5908  tobe = d->m_statusBarText[BarDefaultText];
5909  if (!tobe.isEmpty() && d->m_jobspeed)
5910  tobe += " ";
5911  if (d->m_jobspeed)
5912  tobe += i18n( "(%1/s)" , KIO::convertSize( d->m_jobspeed ) );
5913  }
5914  tobe = "<qt>"+tobe;
5915 
5916  emit ReadOnlyPart::setStatusBarText(tobe);
5917 }
5918 
5919 
5920 void KHTMLPart::setJSStatusBarText( const QString &text )
5921 {
5922  setStatusBarText(text, BarOverrideText);
5923 }
5924 
5925 void KHTMLPart::setJSDefaultStatusBarText( const QString &text )
5926 {
5927  setStatusBarText(text, BarDefaultText);
5928 }
5929 
5930 QString KHTMLPart::jsStatusBarText() const
5931 {
5932  return d->m_statusBarText[BarOverrideText];
5933 }
5934 
5935 QString KHTMLPart::jsDefaultStatusBarText() const
5936 {
5937  return d->m_statusBarText[BarDefaultText];
5938 }
5939 
5940 QString KHTMLPart::referrer() const
5941 {
5942  return d->m_referrer;
5943 }
5944 
5945 QString KHTMLPart::pageReferrer() const
5946 {
5947  KUrl referrerURL = KUrl( d->m_pageReferrer );
5948  if (referrerURL.isValid())
5949  {
5950  QString protocol = referrerURL.protocol();
5951 
5952  if ((protocol == "http") ||
5953  ((protocol == "https") && (url().protocol() == "https")))
5954  {
5955  referrerURL.setRef(QString());
5956  referrerURL.setUser(QString());
5957  referrerURL.setPass(QString());
5958  return referrerURL.url();
5959  }
5960  }
5961 
5962  return QString();
5963 }
5964 
5965 
5966 QString KHTMLPart::lastModified() const
5967 {
5968  if ( d->m_lastModified.isEmpty() && url().isLocalFile() ) {
5969  // Local file: set last-modified from the file's mtime.
5970  // Done on demand to save time when this isn't needed - but can lead
5971  // to slightly wrong results if updating the file on disk w/o reloading.
5972  QDateTime lastModif = QFileInfo( url().toLocalFile() ).lastModified();
5973  d->m_lastModified = lastModif.toString( Qt::LocalDate );
5974  }
5975  //kDebug(6050) << d->m_lastModified;
5976  return d->m_lastModified;
5977 }
5978 
5979 void KHTMLPart::slotLoadImages()
5980 {
5981  if (d->m_doc )
5982  d->m_doc->docLoader()->setAutoloadImages( !d->m_doc->docLoader()->autoloadImages() );
5983 
5984  ConstFrameIt it = d->m_frames.constBegin();
5985  const ConstFrameIt end = d->m_frames.constEnd();
5986  for (; it != end; ++it ) {
5987  if ( KHTMLPart* p = qobject_cast<KHTMLPart*>((*it)->m_part.data()) )
5988  p->slotLoadImages();
5989  }
5990 }
5991 
5992 void KHTMLPart::reparseConfiguration()
5993 {
5994  KHTMLSettings *settings = KHTMLGlobal::defaultHTMLSettings();
5995  settings->init();
5996 
5997  setAutoloadImages( settings->autoLoadImages() );
5998  if (d->m_doc)
5999  d->m_doc->docLoader()->setShowAnimations( settings->showAnimations() );
6000 
6001  d->m_bOpenMiddleClick = settings->isOpenMiddleClickEnabled();
6002  d->m_bJScriptEnabled = settings->isJavaScriptEnabled(url().host());
6003  setDebugScript( settings->isJavaScriptDebugEnabled() );
6004  d->m_bJavaEnabled = settings->isJavaEnabled(url().host());
6005  d->m_bPluginsEnabled = settings->isPluginsEnabled(url().host());
6006  d->m_metaRefreshEnabled = settings->isAutoDelayedActionsEnabled ();
6007 
6008  delete d->m_settings;
6009  d->m_settings = new KHTMLSettings(*KHTMLGlobal::defaultHTMLSettings());
6010 
6011  QApplication::setOverrideCursor( Qt::WaitCursor );
6012  khtml::CSSStyleSelector::reparseConfiguration();
6013  if(d->m_doc) d->m_doc->updateStyleSelector();
6014  QApplication::restoreOverrideCursor();
6015 
6016  if (d->m_view) {
6017  KHTMLSettings::KSmoothScrollingMode ssm = d->m_settings->smoothScrolling();
6018  if (ssm == KHTMLSettings::KSmoothScrollingDisabled)
6019  d->m_view->setSmoothScrollingModeDefault(KHTMLView::SSMDisabled);
6020  else if (ssm == KHTMLSettings::KSmoothScrollingWhenEfficient)
6021  d->m_view->setSmoothScrollingModeDefault(KHTMLView::SSMWhenEfficient);
6022  else
6023  d->m_view->setSmoothScrollingModeDefault(KHTMLView::SSMEnabled);
6024  }
6025 
6026  if (KHTMLGlobal::defaultHTMLSettings()->isAdFilterEnabled())
6027  runAdFilter();
6028 }
6029 
6030 QStringList KHTMLPart::frameNames() const
6031 {
6032  QStringList res;
6033 
6034  ConstFrameIt it = d->m_frames.constBegin();
6035  const ConstFrameIt end = d->m_frames.constEnd();
6036  for (; it != end; ++it )
6037  if (!(*it)->m_bPreloaded && (*it)->m_part)
6038  res += (*it)->m_name;
6039 
6040  return res;
6041 }
6042 
6043 QList<KParts::ReadOnlyPart*> KHTMLPart::frames() const
6044 {
6045  QList<KParts::ReadOnlyPart*> res;
6046 
6047  ConstFrameIt it = d->m_frames.constBegin();
6048  const ConstFrameIt end = d->m_frames.constEnd();
6049  for (; it != end; ++it )
6050  if (!(*it)->m_bPreloaded && (*it)->m_part) // ### TODO: make sure that we always create an empty
6051  // KHTMLPart for frames so this never happens.
6052  res.append( (*it)->m_part.data() );
6053 
6054  return res;
6055 }
6056 
6057 bool KHTMLPart::openUrlInFrame( const KUrl &url, const KParts::OpenUrlArguments& args, const KParts::BrowserArguments &browserArgs)
6058 {
6059  kDebug( 6031 ) << this << url;
6060  FrameIt it = d->m_frames.find( browserArgs.frameName );
6061 
6062  if ( it == d->m_frames.end() )
6063  return false;
6064 
6065  // Inform someone that we are about to show something else.
6066  if ( !browserArgs.lockHistory() )
6067  emit d->m_extension->openUrlNotify();
6068 
6069  requestObject( *it, url, args, browserArgs );
6070 
6071  return true;
6072 }
6073 
6074 void KHTMLPart::setDNDEnabled( bool b )
6075 {
6076  d->m_bDnd = b;
6077 }
6078 
6079 bool KHTMLPart::dndEnabled() const
6080 {
6081  return d->m_bDnd;
6082 }
6083 
6084 void KHTMLPart::customEvent( QEvent *event )
6085 {
6086  if ( khtml::MousePressEvent::test( event ) )
6087  {
6088  khtmlMousePressEvent( static_cast<khtml::MousePressEvent *>( event ) );
6089  return;
6090  }
6091 
6092  if ( khtml::MouseDoubleClickEvent::test( event ) )
6093  {
6094  khtmlMouseDoubleClickEvent( static_cast<khtml::MouseDoubleClickEvent *>( event ) );
6095  return;
6096  }
6097 
6098  if ( khtml::MouseMoveEvent::test( event ) )
6099  {
6100  khtmlMouseMoveEvent( static_cast<khtml::MouseMoveEvent *>( event ) );
6101  return;
6102  }
6103 
6104  if ( khtml::MouseReleaseEvent::test( event ) )
6105  {
6106  khtmlMouseReleaseEvent( static_cast<khtml::MouseReleaseEvent *>( event ) );
6107  return;
6108  }
6109 
6110  if ( khtml::DrawContentsEvent::test( event ) )
6111  {
6112  khtmlDrawContentsEvent( static_cast<khtml::DrawContentsEvent *>( event ) );
6113  return;
6114  }
6115 
6116  KParts::ReadOnlyPart::customEvent( event );
6117 }
6118 
6119 bool KHTMLPart::isPointInsideSelection(int x, int y)
6120 {
6121  // Treat a collapsed selection like no selection.
6122  if (d->editor_context.m_selection.state() == Selection::CARET)
6123  return false;
6124  if (!xmlDocImpl()->renderer())
6125  return false;
6126 
6127  khtml::RenderObject::NodeInfo nodeInfo(true, true);
6128  xmlDocImpl()->renderer()->layer()->nodeAtPoint(nodeInfo, x, y);
6129  NodeImpl *innerNode = nodeInfo.innerNode();
6130  if (!innerNode || !innerNode->renderer())
6131  return false;
6132 
6133  return innerNode->isPointInsideSelection(x, y, d->editor_context.m_selection);
6134 }
6135 
6141 static bool firstRunAt(khtml::RenderObject *renderNode, int y, NodeImpl *&startNode, long &startOffset)
6142 {
6143  for (khtml::RenderObject *n = renderNode; n; n = n->nextSibling()) {
6144  if (n->isText()) {
6145  khtml::RenderText* const textRenderer = static_cast<khtml::RenderText *>(n);
6146  for (khtml::InlineTextBox* box = textRenderer->firstTextBox(); box; box = box->nextTextBox()) {
6147  if (box->m_y == y && textRenderer->element()) {
6148  startNode = textRenderer->element();
6149  startOffset = box->m_start;
6150  return true;
6151  }
6152  }
6153  }
6154 
6155  if (firstRunAt(n->firstChild(), y, startNode, startOffset)) {
6156  return true;
6157  }
6158  }
6159 
6160  return false;
6161 }
6162 
6168 static bool lastRunAt(khtml::RenderObject *renderNode, int y, NodeImpl *&endNode, long &endOffset)
6169 {
6170  khtml::RenderObject *n = renderNode;
6171  if (!n) {
6172  return false;
6173  }
6174  khtml::RenderObject *next;
6175  while ((next = n->nextSibling())) {
6176  n = next;
6177  }
6178 
6179  while (1) {
6180  if (lastRunAt(n->firstChild(), y, endNode, endOffset)) {
6181  return true;
6182  }
6183 
6184  if (n->isText()) {
6185  khtml::RenderText* const textRenderer = static_cast<khtml::RenderText *>(n);
6186  for (khtml::InlineTextBox* box = textRenderer->firstTextBox(); box; box = box->nextTextBox()) {
6187  if (box->m_y == y && textRenderer->element()) {
6188  endNode = textRenderer->element();
6189  endOffset = box->m_start + box->m_len;
6190  return true;
6191  }
6192  }
6193  }
6194 
6195  if (n == renderNode) {
6196  return false;
6197  }
6198 
6199  n = n->previousSibling();
6200  }
6201 }
6202 
6203 void KHTMLPart::handleMousePressEventDoubleClick(khtml::MouseDoubleClickEvent *event)
6204 {
6205  QMouseEvent *mouse = event->qmouseEvent();
6206  DOM::Node innerNode = event->innerNode();
6207 
6208  Selection selection;
6209 
6210  if (mouse->button() == Qt::LeftButton && !innerNode.isNull() && innerNode.handle()->renderer() &&
6211  innerNode.handle()->renderer()->shouldSelect()) {
6212  Position pos(innerNode.handle()->positionForCoordinates(event->x(), event->y()).position());
6213  if (pos.node() && (pos.node()->nodeType() == Node::TEXT_NODE || pos.node()->nodeType() == Node::CDATA_SECTION_NODE)) {
6214  selection.moveTo(pos);
6215  selection.expandUsingGranularity(Selection::WORD);
6216  }
6217  }
6218 
6219  if (selection.state() != Selection::CARET) {
6220  d->editor_context.beginSelectingText(Selection::WORD);
6221  }
6222 
6223  setCaret(selection);
6224  startAutoScroll();
6225 }
6226 
6227 void KHTMLPart::handleMousePressEventTripleClick(khtml::MouseDoubleClickEvent *event)
6228 {
6229  QMouseEvent *mouse = event->qmouseEvent();
6230  DOM::Node innerNode = event->innerNode();
6231 
6232  Selection selection;
6233 
6234  if (mouse->button() == Qt::LeftButton && !innerNode.isNull() && innerNode.handle()->renderer() &&
6235  innerNode.handle()->renderer()->shouldSelect()) {
6236  Position pos(innerNode.handle()->positionForCoordinates(event->x(), event->y()).position());
6237  if (pos.node() && (pos.node()->nodeType() == Node::TEXT_NODE || pos.node()->nodeType() == Node::CDATA_SECTION_NODE)) {
6238  selection.moveTo(pos);
6239  selection.expandUsingGranularity(Selection::LINE);
6240  }
6241  }
6242 
6243  if (selection.state() != Selection::CARET) {
6244  d->editor_context.beginSelectingText(Selection::LINE);
6245  }
6246 
6247  setCaret(selection);
6248  startAutoScroll();
6249 }
6250 
6251 void KHTMLPart::handleMousePressEventSingleClick(khtml::MousePressEvent *event)
6252 {
6253  QMouseEvent *mouse = event->qmouseEvent();
6254  DOM::Node innerNode = event->innerNode();
6255 
6256  if (mouse->button() == Qt::LeftButton) {
6257  Selection sel;
6258 
6259  if (!innerNode.isNull() && innerNode.handle()->renderer() &&
6260  innerNode.handle()->renderer()->shouldSelect()) {
6261  bool extendSelection = mouse->modifiers() & Qt::ShiftModifier;
6262 
6263  // Don't restart the selection when the mouse is pressed on an
6264  // existing selection so we can allow for text dragging.
6265  if (!extendSelection && isPointInsideSelection(event->x(), event->y())) {
6266  return;
6267  }
6268  Position pos(innerNode.handle()->positionForCoordinates(event->x(), event->y()).position());
6269  if (pos.isEmpty())
6270  pos = Position(innerNode.handle(), innerNode.handle()->caretMinOffset());
6271  kDebug(6050) << event->x() << event->y() << pos << endl;
6272 
6273  sel = caret();
6274  if (extendSelection && sel.notEmpty()) {
6275  sel.clearModifyBias();
6276  sel.setExtent(pos);
6277  if (d->editor_context.m_selectionGranularity != Selection::CHARACTER) {
6278  sel.expandUsingGranularity(d->editor_context.m_selectionGranularity);
6279  }
6280  d->editor_context.m_beganSelectingText = true;
6281  } else {
6282  sel = pos;
6283  d->editor_context.m_selectionGranularity = Selection::CHARACTER;
6284  }
6285  }
6286 
6287  setCaret(sel);
6288  startAutoScroll();
6289  }
6290 }
6291 
6292 void KHTMLPart::khtmlMousePressEvent( khtml::MousePressEvent *event )
6293 {
6294  DOM::DOMString url = event->url();
6295  QMouseEvent *_mouse = event->qmouseEvent();
6296  DOM::Node innerNode = event->innerNode();
6297  d->m_mousePressNode = innerNode;
6298 
6299  d->m_dragStartPos = QPoint(event->x(), event->y());
6300 
6301  if ( !event->url().isNull() ) {
6302  d->m_strSelectedURL = event->url().string();
6303  d->m_strSelectedURLTarget = event->target().string();
6304  }
6305  else {
6306  d->m_strSelectedURL.clear();
6307  d->m_strSelectedURLTarget.clear();
6308  }
6309 
6310  if ( _mouse->button() == Qt::LeftButton ||
6311  _mouse->button() == Qt::MidButton )
6312  {
6313  d->m_bMousePressed = true;
6314 
6315 #ifdef KHTML_NO_SELECTION
6316  d->m_dragLastPos = _mouse->globalPos();
6317 #else
6318  if ( _mouse->button() == Qt::LeftButton )
6319  {
6320  if ( (!d->m_strSelectedURL.isNull() && !isEditable())
6321  || (!d->m_mousePressNode.isNull() && d->m_mousePressNode.elementId() == ID_IMG) )
6322  return;
6323 
6324  d->editor_context.m_beganSelectingText = false;
6325 
6326  handleMousePressEventSingleClick(event);
6327  }
6328 #endif
6329  }
6330 
6331  if ( _mouse->button() == Qt::RightButton )
6332  {
6333  popupMenu( d->m_strSelectedURL );
6334  // might be deleted, don't touch "this"
6335  }
6336 }
6337 
6338 void KHTMLPart::khtmlMouseDoubleClickEvent( khtml::MouseDoubleClickEvent *event )
6339 {
6340  QMouseEvent *_mouse = event->qmouseEvent();
6341  if ( _mouse->button() == Qt::LeftButton )
6342  {
6343  d->m_bMousePressed = true;
6344  d->editor_context.m_beganSelectingText = false;
6345 
6346  if (event->clickCount() == 2) {
6347  handleMousePressEventDoubleClick(event);
6348  return;
6349  }
6350 
6351  if (event->clickCount() >= 3) {
6352  handleMousePressEventTripleClick(event);
6353  return;
6354  }
6355  }
6356 }
6357 
6358 #ifndef KHTML_NO_SELECTION
6359 bool KHTMLPart::isExtendingSelection() const
6360  {
6361  // This is it, the whole detection. khtmlMousePressEvent only sets this
6362  // on LMB or MMB, but never on RMB. As text selection doesn't work for MMB,
6363  // it's sufficient to only rely on this flag to detect selection extension.
6364  return d->editor_context.m_beganSelectingText;
6365 }
6366 
6367 void KHTMLPart::extendSelectionTo(int x, int y, const DOM::Node &innerNode)
6368 {
6369  // handle making selection
6370  Position pos(innerNode.handle()->positionForCoordinates(x, y).position());
6371 
6372  // Don't modify the selection if we're not on a node.
6373  if (pos.isEmpty())
6374  return;
6375 
6376  // Restart the selection if this is the first mouse move. This work is usually
6377  // done in khtmlMousePressEvent, but not if the mouse press was on an existing selection.
6378  Selection sel = caret();
6379  sel.clearModifyBias();
6380  if (!d->editor_context.m_beganSelectingText) {
6381  // We are beginning a selection during press-drag, when the original click
6382  // wasn't appropriate for one. Make sure to set the granularity.
6383  d->editor_context.beginSelectingText(Selection::CHARACTER);
6384  sel.moveTo(pos);
6385  }
6386 
6387  sel.setExtent(pos);
6388  if (d->editor_context.m_selectionGranularity != Selection::CHARACTER) {
6389  sel.expandUsingGranularity(d->editor_context.m_selectionGranularity);
6390  }
6391  setCaret(sel);
6392 
6393 }
6394 #endif // KHTML_NO_SELECTION
6395 
6396 bool KHTMLPart::handleMouseMoveEventDrag(khtml::MouseMoveEvent *event)
6397 {
6398 #ifdef QT_NO_DRAGANDDROP
6399  return false;
6400 #else
6401  if (!dndEnabled())
6402  return false;
6403 
6404  if( (d->m_bMousePressed &&
6405  ( (!d->m_strSelectedURL.isEmpty() && !isEditable())
6406  || (!d->m_mousePressNode.isNull() && d->m_mousePressNode.elementId() == ID_IMG) ) )
6407  && ( d->m_dragStartPos - QPoint(event->x(), event->y()) ).manhattanLength() > KGlobalSettings::dndEventDelay() ) {
6408 
6409  const DOM::DOMString url = event->url();
6410  DOM::NodeImpl* innerNodeImpl = event->innerNode().handle();
6411 
6412  QPixmap pix;
6413  HTMLImageElementImpl *img = 0L;
6414  KUrl u;
6415 
6416  // qDebug("****************** Event URL: %s", url.string().toLatin1().constData());
6417  // qDebug("****************** Event Target: %s", target.string().toLatin1().constData());
6418 
6419  // Normal image...
6420  if (url.isEmpty() && innerNodeImpl && innerNodeImpl->id() == ID_IMG)
6421  {
6422  img = static_cast<HTMLImageElementImpl *>(innerNodeImpl);
6423  u = completeURL(img->getAttribute(ATTR_SRC).string().trimmed());
6424  pix = KIconLoader::global()->loadIcon("image-x-generic", KIconLoader::Desktop);
6425  }
6426  else
6427  {
6428  // Text or image link...
6429  u = completeURL( d->m_strSelectedURL );
6430  pix = KIO::pixmapForUrl(u, 0, KIconLoader::Desktop, KIconLoader::SizeMedium);
6431  }
6432 
6433  u.setPass(QString());
6434 
6435  QDrag *drag = new QDrag( d->m_view->viewport() );
6436  QMap<QString, QString> metaDataMap;
6437  if ( !d->m_referrer.isEmpty() )
6438  metaDataMap.insert( "referrer", d->m_referrer );
6439  QMimeData* mimeData = new QMimeData();
6440  u.populateMimeData( mimeData, metaDataMap );
6441  drag->setMimeData( mimeData );
6442 
6443  if( img && img->complete() )
6444  drag->mimeData()->setImageData( img->currentImage() );
6445 
6446  if ( !pix.isNull() )
6447  drag->setPixmap( pix );
6448 
6449  stopAutoScroll();
6450  drag->start();
6451 
6452  // when we finish our drag, we need to undo our mouse press
6453  d->m_bMousePressed = false;
6454  d->m_strSelectedURL.clear();
6455  d->m_strSelectedURLTarget.clear();
6456  return true;
6457  }
6458  return false;
6459 #endif // QT_NO_DRAGANDDROP
6460 }
6461 
6462 bool KHTMLPart::handleMouseMoveEventOver(khtml::MouseMoveEvent *event)
6463 {
6464  // Mouse clicked -> do nothing
6465  if ( d->m_bMousePressed ) return false;
6466 
6467  DOM::DOMString url = event->url();
6468 
6469  // The mouse is over something
6470  if ( url.length() )
6471  {
6472  DOM::DOMString target = event->target();
6473  QMouseEvent *_mouse = event->qmouseEvent();
6474  DOM::Node innerNode = event->innerNode();
6475 
6476  bool shiftPressed = ( _mouse->modifiers() & Qt::ShiftModifier );
6477 
6478  // Image map
6479  if ( !innerNode.isNull() && innerNode.elementId() == ID_IMG )
6480  {
6481  HTMLImageElementImpl *i = static_cast<HTMLImageElementImpl *>(innerNode.handle());
6482  if ( i && i->isServerMap() )
6483  {
6484  khtml::RenderObject *r = i->renderer();
6485  if(r)
6486  {
6487  int absx, absy;
6488  r->absolutePosition(absx, absy);
6489  int x(event->x() - absx), y(event->y() - absy);
6490 
6491  d->m_overURL = url.string() + QString("?%1,%2").arg(x).arg(y);
6492  d->m_overURLTarget = target.string();
6493  overURL( d->m_overURL, target.string(), shiftPressed );
6494  return true;
6495  }
6496  }
6497  }
6498 
6499  // normal link
6500  if ( d->m_overURL.isEmpty() || d->m_overURL != url || d->m_overURLTarget != target )
6501  {
6502  d->m_overURL = url.string();
6503  d->m_overURLTarget = target.string();
6504  overURL( d->m_overURL, target.string(), shiftPressed );
6505  }
6506  }
6507  else // Not over a link...
6508  {
6509  if( !d->m_overURL.isEmpty() ) // and we were over a link -> reset to "default statusbar text"
6510  {
6511  // reset to "default statusbar text"
6512  resetHoverText();
6513  }
6514  }
6515  return true;
6516 }
6517 
6518 void KHTMLPart::handleMouseMoveEventSelection(khtml::MouseMoveEvent *event)
6519 {
6520  // Mouse not pressed. Do nothing.
6521  if (!d->m_bMousePressed)
6522  return;
6523 
6524 #ifdef KHTML_NO_SELECTION
6525  if (d->m_doc && d->m_view) {
6526  QPoint diff( mouse->globalPos() - d->m_dragLastPos );
6527 
6528  if (abs(diff.x()) > 64 || abs(diff.y()) > 64) {
6529  d->m_view->scrollBy(-diff.x(), -diff.y());
6530  d->m_dragLastPos = mouse->globalPos();
6531  }
6532  }
6533 #else
6534 
6535  QMouseEvent *mouse = event->qmouseEvent();
6536  DOM::Node innerNode = event->innerNode();
6537 
6538  if ( (mouse->buttons() & Qt::LeftButton) == 0 || !innerNode.handle() || !innerNode.handle()->renderer() ||
6539  !innerNode.handle()->renderer()->shouldSelect())
6540  return;
6541 
6542  // handle making selection
6543  extendSelectionTo(event->x(), event->y(), innerNode);
6544 #endif // KHTML_NO_SELECTION
6545 }
6546 
6547 void KHTMLPart::khtmlMouseMoveEvent( khtml::MouseMoveEvent *event )
6548 {
6549  if (handleMouseMoveEventDrag(event))
6550  return;
6551 
6552  if (handleMouseMoveEventOver(event))
6553  return;
6554 
6555  handleMouseMoveEventSelection(event);
6556 }
6557 
6558 void KHTMLPart::khtmlMouseReleaseEvent( khtml::MouseReleaseEvent *event )
6559 {
6560  DOM::Node innerNode = event->innerNode();
6561  d->m_mousePressNode = DOM::Node();
6562 
6563  if ( d->m_bMousePressed ) {
6564  setStatusBarText(QString(), BarHoverText);
6565  stopAutoScroll();
6566  }
6567 
6568  // Used to prevent mouseMoveEvent from initiating a drag before
6569  // the mouse is pressed again.
6570  d->m_bMousePressed = false;
6571 
6572 #ifndef QT_NO_CLIPBOARD
6573  QMouseEvent *_mouse = event->qmouseEvent();
6574  if ((d->m_guiProfile == BrowserViewGUI) && (_mouse->button() == Qt::MidButton) && (event->url().isNull())) {
6575  kDebug( 6050 ) << "MMB shouldOpen=" << d->m_bOpenMiddleClick;
6576 
6577  if (d->m_bOpenMiddleClick) {
6578  KHTMLPart *p = this;
6579  while (p->parentPart()) p = p->parentPart();
6580  p->d->m_extension->pasteRequest();
6581  }
6582  }
6583 #endif
6584 
6585 #ifndef KHTML_NO_SELECTION
6586  {
6587 
6588  // Clear the selection if the mouse didn't move after the last mouse press.
6589  // We do this so when clicking on the selection, the selection goes away.
6590  // However, if we are editing, place the caret.
6591  if (!d->editor_context.m_beganSelectingText
6592  && d->m_dragStartPos.x() == event->x()
6593  && d->m_dragStartPos.y() == event->y()
6594  && d->editor_context.m_selection.state() == Selection::RANGE) {
6595  Selection selection;
6596 #ifdef APPLE_CHANGES
6597  if (d->editor_context.m_selection.base().node()->isContentEditable())
6598 #endif
6599  selection.moveTo(d->editor_context.m_selection.base().node()->positionForCoordinates(event->x(), event->y()).position());
6600  setCaret(selection);
6601  }
6602  // get selected text and paste to the clipboard
6603 #ifndef QT_NO_CLIPBOARD
6604  QString text = selectedText();
6605  text.replace(QChar(0xa0), ' ');
6606  if (!text.isEmpty()) {
6607  disconnect( qApp->clipboard(), SIGNAL(selectionChanged()), this, SLOT(slotClearSelection()));
6608  qApp->clipboard()->setText(text,QClipboard::Selection);
6609  connect( qApp->clipboard(), SIGNAL(selectionChanged()), SLOT(slotClearSelection()));
6610  }
6611 #endif
6612  //kDebug( 6000 ) << "selectedText = " << text;
6613  emitSelectionChanged();
6614 //kDebug(6000) << "rel2: startBefEnd " << d->m_startBeforeEnd << " extAtEnd " << d->m_extendAtEnd << " (" << d->m_startOffset << ") - (" << d->m_endOffset << "), caretOfs " << d->caretOffset();
6615  }
6616 #endif
6617 }
6618 
6619 void KHTMLPart::khtmlDrawContentsEvent( khtml::DrawContentsEvent * )
6620 {
6621 }
6622 
6623 void KHTMLPart::guiActivateEvent( KParts::GUIActivateEvent *event )
6624 {
6625  if ( event->activated() )
6626  {
6627  emitSelectionChanged();
6628  emit d->m_extension->enableAction( "print", d->m_doc != 0 );
6629 
6630  if ( !d->m_settings->autoLoadImages() && d->m_paLoadImages )
6631  {
6632  QList<QAction*> lst;
6633  lst.append( d->m_paLoadImages );
6634  plugActionList( "loadImages", lst );
6635  }
6636  }
6637 }
6638 
6639 void KHTMLPart::slotPrintFrame()
6640 {
6641  if ( d->m_frames.count() == 0 )
6642  return;
6643 
6644  KParts::ReadOnlyPart *frame = currentFrame();
6645  if (!frame)
6646  return;
6647 
6648  KParts::BrowserExtension *ext = KParts::BrowserExtension::childObject( frame );
6649 
6650  if ( !ext )
6651  return;
6652 
6653 
6654  const QMetaObject *mo = ext->metaObject();
6655 
6656 
6657  if (mo->indexOfSlot( "print()") != -1)
6658  QMetaObject::invokeMethod(ext, "print()", Qt::DirectConnection);
6659 }
6660 
6661 void KHTMLPart::slotSelectAll()
6662 {
6663  KParts::ReadOnlyPart *part = currentFrame();
6664  if (part && part->inherits("KHTMLPart"))
6665  static_cast<KHTMLPart *>(part)->selectAll();
6666 }
6667 
6668 void KHTMLPart::startAutoScroll()
6669 {
6670  connect(&d->m_scrollTimer, SIGNAL(timeout()), this, SLOT(slotAutoScroll()));
6671  d->m_scrollTimer.setSingleShot(false);
6672  d->m_scrollTimer.start(100);
6673 }
6674 
6675 void KHTMLPart::stopAutoScroll()
6676 {
6677  disconnect(&d->m_scrollTimer, SIGNAL(timeout()), this, SLOT(slotAutoScroll()));
6678  if (d->m_scrollTimer.isActive())
6679  d->m_scrollTimer.stop();
6680 }
6681 
6682 
6683 void KHTMLPart::slotAutoScroll()
6684 {
6685  if (d->m_view)
6686  d->m_view->doAutoScroll();
6687  else
6688  stopAutoScroll(); // Safety
6689 }
6690 
6691 void KHTMLPart::runAdFilter()
6692 {
6693  if ( parentPart() )
6694  parentPart()->runAdFilter();
6695 
6696  if ( !d->m_doc )
6697  return;
6698 
6699  QSetIterator<khtml::CachedObject*> it( d->m_doc->docLoader()->m_docObjects );
6700  while (it.hasNext())
6701  {
6702  khtml::CachedObject* obj = it.next();
6703  if ( obj->type() == khtml::CachedObject::Image ) {
6704  khtml::CachedImage *image = static_cast<khtml::CachedImage *>(obj);
6705  bool wasBlocked = image->m_wasBlocked;
6706  image->m_wasBlocked = KHTMLGlobal::defaultHTMLSettings()->isAdFiltered( d->m_doc->completeURL( image->url().string() ) );
6707  if ( image->m_wasBlocked != wasBlocked )
6708  image->do_notify(QRect(QPoint(0,0), image->pixmap_size()));
6709  }
6710  }
6711 
6712  if ( KHTMLGlobal::defaultHTMLSettings()->isHideAdsEnabled() ) {
6713  for ( NodeImpl *nextNode, *node = d->m_doc; node; node = nextNode ) {
6714 
6715  // We might be deleting 'node' shortly.
6716  nextNode = node->traverseNextNode();
6717 
6718  if ( node->id() == ID_IMG ||
6719  node->id() == ID_IFRAME ||
6720  (node->id() == ID_INPUT && static_cast<HTMLInputElementImpl *>(node)->inputType() == HTMLInputElementImpl::IMAGE ))
6721  {
6722  if (KHTMLGlobal::defaultHTMLSettings()->isAdFiltered(d->m_doc->completeURL(static_cast<ElementImpl *>(node)->getAttribute(ATTR_SRC).string().trimmed())))
6723  {
6724  // Since any kids of node will be deleted, too, fastforward nextNode
6725  // until we get outside of node.
6726  while (nextNode && nextNode->isAncestor(node))
6727  nextNode = nextNode->traverseNextNode();
6728 
6729  node->ref();
6730  NodeImpl *parent = node->parent();
6731  if( parent )
6732  {
6733  int exception = 0;
6734  parent->removeChild(node, exception);
6735  }
6736  node->deref();
6737  }
6738  }
6739  }
6740  }
6741 }
6742 
6743 void KHTMLPart::selectAll()
6744 {
6745  if (!d->m_doc) return;
6746 
6747  NodeImpl *first;
6748  if (d->m_doc->isHTMLDocument())
6749  first = static_cast<HTMLDocumentImpl*>(d->m_doc)->body();
6750  else
6751  first = d->m_doc;
6752  NodeImpl *next;
6753 
6754  // Look for first text/cdata node that has a renderer,
6755  // or first childless replaced element
6756  while ( first && !(first->renderer()
6757  && ((first->nodeType() == Node::TEXT_NODE || first->nodeType() == Node::CDATA_SECTION_NODE)
6758  || (first->renderer()->isReplaced() && !first->renderer()->firstChild()))))
6759  {
6760  next = first->firstChild();
6761  if ( !next ) next = first->nextSibling();
6762  while( first && !next )
6763  {
6764  first = first->parentNode();
6765  if ( first )
6766  next = first->nextSibling();
6767  }
6768  first = next;
6769  }
6770 
6771  NodeImpl *last;
6772  if (d->m_doc->isHTMLDocument())
6773  last = static_cast<HTMLDocumentImpl*>(d->m_doc)->body();
6774  else
6775  last = d->m_doc;
6776  // Look for last text/cdata node that has a renderer,
6777  // or last childless replaced element
6778  // ### Instead of changing this loop, use findLastSelectableNode
6779  // in render_table.cpp (LS)
6780  while ( last && !(last->renderer()
6781  && ((last->nodeType() == Node::TEXT_NODE || last->nodeType() == Node::CDATA_SECTION_NODE)
6782  || (last->renderer()->isReplaced() && !last->renderer()->lastChild()))))
6783  {
6784  next = last->lastChild();
6785  if ( !next ) next = last->previousSibling();
6786  while ( last && !next )
6787  {
6788  last = last->parentNode();
6789  if ( last )
6790  next = last->previousSibling();
6791  }
6792  last = next;
6793  }
6794 
6795  if ( !first || !last )
6796  return;
6797  Q_ASSERT(first->renderer());
6798  Q_ASSERT(last->renderer());
6799  d->editor_context.m_selection.moveTo(Position(first, 0), Position(last, last->nodeValue().length()));
6800  d->m_doc->updateSelection();
6801 
6802  emitSelectionChanged();
6803 }
6804 
6805 bool KHTMLPart::checkLinkSecurity(const KUrl &linkURL,const KLocalizedString &message, const QString &button)
6806 {
6807  bool linkAllowed = true;
6808 
6809  if ( d->m_doc )
6810  linkAllowed = KAuthorized::authorizeUrlAction("redirect", url(), linkURL);
6811 
6812  if ( !linkAllowed ) {
6813  khtml::Tokenizer *tokenizer = d->m_doc->tokenizer();
6814  if (tokenizer)
6815  tokenizer->setOnHold(true);
6816 
6817  int response = KMessageBox::Cancel;
6818  if (!message.isEmpty())
6819  {
6820  // Dangerous flag makes the Cancel button the default
6821  response = KMessageBox::warningContinueCancel( 0,
6822  message.subs(Qt::escape(linkURL.prettyUrl())).toString(),
6823  i18n( "Security Warning" ),
6824  KGuiItem(button),
6825  KStandardGuiItem::cancel(),
6826  QString(), // no don't ask again info
6827  KMessageBox::Notify | KMessageBox::Dangerous );
6828  }
6829  else
6830  {
6831  KMessageBox::error( 0,
6832  i18n( "<qt>Access by untrusted page to<br /><b>%1</b><br /> denied.</qt>", Qt::escape(linkURL.prettyUrl())),
6833  i18n( "Security Alert" ));
6834  }
6835 
6836  if (tokenizer)
6837  tokenizer->setOnHold(false);
6838  return (response==KMessageBox::Continue);
6839  }
6840  return true;
6841 }
6842 
6843 void KHTMLPart::slotPartRemoved( KParts::Part *part )
6844 {
6845 // kDebug(6050) << part;
6846  if ( part == d->m_activeFrame )
6847  {
6848  d->m_activeFrame = 0L;
6849  if ( !part->inherits( "KHTMLPart" ) )
6850  {
6851  if (factory()) {
6852  factory()->removeClient( part );
6853  }
6854  if (childClients().contains(part)) {
6855  removeChildClient( part );
6856  }
6857  }
6858  }
6859 }
6860 
6861 void KHTMLPart::slotActiveFrameChanged( KParts::Part *part )
6862 {
6863 // kDebug(6050) << this << "part=" << part;
6864  if ( part == this )
6865  {
6866  kError(6050) << "strange error! we activated ourselves";
6867  assert( false );
6868  return;
6869  }
6870 // kDebug(6050) << "d->m_activeFrame=" << d->m_activeFrame;
6871  if ( d->m_activeFrame && d->m_activeFrame->widget() && d->m_activeFrame->widget()->inherits( "QFrame" ) )
6872  {
6873  QFrame *frame = static_cast<QFrame *>( d->m_activeFrame->widget() );
6874  if (frame->frameStyle() != QFrame::NoFrame)
6875  {
6876  frame->setFrameStyle( QFrame::StyledPanel | QFrame::Sunken);
6877  frame->repaint();
6878  }
6879  }
6880 
6881  if( d->m_activeFrame && !d->m_activeFrame->inherits( "KHTMLPart" ) )
6882  {
6883  if (factory()) {
6884  factory()->removeClient( d->m_activeFrame );
6885  }
6886  removeChildClient( d->m_activeFrame );
6887  }
6888  if( part && !part->inherits( "KHTMLPart" ) )
6889  {
6890  if (factory()) {
6891  factory()->addClient( part );
6892  }
6893  insertChildClient( part );
6894  }
6895 
6896 
6897  d->m_activeFrame = part;
6898 
6899  if ( d->m_activeFrame && d->m_activeFrame->widget()->inherits( "QFrame" ) )
6900  {
6901  QFrame *frame = static_cast<QFrame *>( d->m_activeFrame->widget() );
6902  if (frame->frameStyle() != QFrame::NoFrame)
6903  {
6904  frame->setFrameStyle( QFrame::StyledPanel | QFrame::Plain);
6905  frame->repaint();
6906  }
6907  kDebug(6050) << "new active frame " << d->m_activeFrame;
6908  }
6909 
6910  updateActions();
6911 
6912  // (note: childObject returns 0 if the argument is 0)
6913  d->m_extension->setExtensionProxy( KParts::BrowserExtension::childObject( d->m_activeFrame ) );
6914 }
6915 
6916 void KHTMLPart::setActiveNode(const DOM::Node &node)
6917 {
6918  if (!d->m_doc || !d->m_view)
6919  return;
6920 
6921  // Set the document's active node
6922  d->m_doc->setFocusNode(node.handle());
6923 
6924  // Scroll the view if necessary to ensure that the new focus node is visible
6925  QRect rect = node.handle()->getRect();
6926  d->m_view->ensureVisible(rect.right(), rect.bottom());
6927  d->m_view->ensureVisible(rect.left(), rect.top());
6928 }
6929 
6930 DOM::Node KHTMLPart::activeNode() const
6931 {
6932  return DOM::Node(d->m_doc?d->m_doc->focusNode():0);
6933 }
6934 
6935 DOM::EventListener *KHTMLPart::createHTMLEventListener( QString code, QString name, NodeImpl* node, bool svg )
6936 {
6937  KJSProxy *proxy = jScript();
6938 
6939  if (!proxy)
6940  return 0;
6941 
6942  return proxy->createHTMLEventHandler( url().url(), name, code, node, svg );
6943 }
6944 
6945 KHTMLPart *KHTMLPart::opener()
6946 {
6947  return d->m_opener;
6948 }
6949 
6950 void KHTMLPart::setOpener(KHTMLPart *_opener)
6951 {
6952  d->m_opener = _opener;
6953 }
6954 
6955 bool KHTMLPart::openedByJS()
6956 {
6957  return d->m_openedByJS;
6958 }
6959 
6960 void KHTMLPart::setOpenedByJS(bool _openedByJS)
6961 {
6962  d->m_openedByJS = _openedByJS;
6963 }
6964 
6965 void KHTMLPart::preloadStyleSheet(const QString &url, const QString &stylesheet)
6966 {
6967  khtml::Cache::preloadStyleSheet(url, stylesheet);
6968 }
6969 
6970 void KHTMLPart::preloadScript(const QString &url, const QString &script)
6971 {
6972  khtml::Cache::preloadScript(url, script);
6973 }
6974 
6975 long KHTMLPart::cacheId() const
6976 {
6977  return d->m_cacheId;
6978 }
6979 
6980 bool KHTMLPart::restored() const
6981 {
6982  return d->m_restored;
6983 }
6984 
6985 bool KHTMLPart::pluginPageQuestionAsked(const QString& mimetype) const
6986 {
6987  // parentPart() should be const!
6988  KHTMLPart* parent = const_cast<KHTMLPart *>(this)->parentPart();
6989  if ( parent )
6990  return parent->pluginPageQuestionAsked(mimetype);
6991 
6992  return d->m_pluginPageQuestionAsked.contains(mimetype);
6993 }
6994 
6995 void KHTMLPart::setPluginPageQuestionAsked(const QString& mimetype)
6996 {
6997  if ( parentPart() )
6998  parentPart()->setPluginPageQuestionAsked(mimetype);
6999 
7000  d->m_pluginPageQuestionAsked.append(mimetype);
7001 }
7002 
7003 KEncodingDetector *KHTMLPart::createDecoder()
7004 {
7005  KEncodingDetector *dec = new KEncodingDetector();
7006  if( !d->m_encoding.isNull() )
7007  dec->setEncoding( d->m_encoding.toLatin1().constData(),
7008  d->m_haveEncoding ? KEncodingDetector::UserChosenEncoding : KEncodingDetector::EncodingFromHTTPHeader);
7009  else {
7010  // Inherit the default encoding from the parent frame if there is one.
7011  QByteArray defaultEncoding = (parentPart() && parentPart()->d->m_decoder)
7012  ? QByteArray( parentPart()->d->m_decoder->encoding() ) : settings()->encoding().toLatin1();
7013  dec->setEncoding(defaultEncoding.constData(), KEncodingDetector::DefaultEncoding);
7014  }
7015 
7016  if (d->m_doc)
7017  d->m_doc->setDecoder(dec);
7018  dec->setAutoDetectLanguage( d->m_autoDetectLanguage );
7019  return dec;
7020 }
7021 
7022 void KHTMLPart::emitCaretPositionChanged(const DOM::Position &pos) {
7023  // pos must not be already converted to range-compliant coordinates
7024  Position rng_pos = pos.equivalentRangeCompliantPosition();
7025  Node node = rng_pos.node();
7026  emit caretPositionChanged(node, rng_pos.offset());
7027 }
7028 
7029 void KHTMLPart::restoreScrollPosition()
7030 {
7031  const KParts::OpenUrlArguments args( arguments() );
7032 
7033  if ( url().hasRef() && !d->m_restoreScrollPosition && !args.reload()) {
7034  if ( !d->m_doc || !d->m_doc->parsing() )
7035  disconnect(d->m_view, SIGNAL(finishedLayout()), this, SLOT(restoreScrollPosition()));
7036  if ( !gotoAnchor(url().encodedHtmlRef()) )
7037  gotoAnchor(url().htmlRef());
7038  return;
7039  }
7040 
7041  // Check whether the viewport has become large enough to encompass the stored
7042  // offsets. If the document has been fully loaded, force the new coordinates,
7043  // even if the canvas is too short (can happen when user resizes the window
7044  // during loading).
7045  if (d->m_view->contentsHeight() - d->m_view->visibleHeight() >= args.yOffset()
7046  || d->m_bComplete) {
7047  d->m_view->setContentsPos(args.xOffset(), args.yOffset());
7048  disconnect(d->m_view, SIGNAL(finishedLayout()), this, SLOT(restoreScrollPosition()));
7049  }
7050 }
7051 
7052 
7053 void KHTMLPart::openWallet(DOM::HTMLFormElementImpl *form)
7054 {
7055 #ifndef KHTML_NO_WALLET
7056  KHTMLPart *p;
7057 
7058  for (p = parentPart(); p && p->parentPart(); p = p->parentPart()) {
7059  }
7060 
7061  if (p) {
7062  p->openWallet(form);
7063  return;
7064  }
7065 
7066  if (onlyLocalReferences()) { // avoid triggering on local apps, thumbnails
7067  return;
7068  }
7069 
7070  if (d->m_wallet) {
7071  if (d->m_bWalletOpened) {
7072  if (d->m_wallet->isOpen()) {
7073  form->walletOpened(d->m_wallet);
7074  return;
7075  }
7076  d->m_wallet->deleteLater();
7077  d->m_wallet = 0L;
7078  d->m_bWalletOpened = false;
7079  }
7080  }
7081 
7082  if (!d->m_wq) {
7083  KWallet::Wallet *wallet = KWallet::Wallet::openWallet(KWallet::Wallet::NetworkWallet(), widget() ? widget()->topLevelWidget()->winId() : 0, KWallet::Wallet::Asynchronous);
7084  d->m_wq = new KHTMLWalletQueue(this);
7085  d->m_wq->wallet = wallet;
7086  connect(wallet, SIGNAL(walletOpened(bool)), d->m_wq, SLOT(walletOpened(bool)));
7087  connect(d->m_wq, SIGNAL(walletOpened(KWallet::Wallet*)), this, SLOT(walletOpened(KWallet::Wallet*)));
7088  }
7089  assert(form);
7090  d->m_wq->callers.append(KHTMLWalletQueue::Caller(form, form->document()));
7091 #endif // KHTML_NO_WALLET
7092 }
7093 
7094 
7095 void KHTMLPart::saveToWallet(const QString& key, const QMap<QString,QString>& data)
7096 {
7097 #ifndef KHTML_NO_WALLET
7098  KHTMLPart *p;
7099 
7100  for (p = parentPart(); p && p->parentPart(); p = p->parentPart()) {
7101  }
7102 
7103  if (p) {
7104  p->saveToWallet(key, data);
7105  return;
7106  }
7107 
7108  if (d->m_wallet) {
7109  if (d->m_bWalletOpened) {
7110  if (d->m_wallet->isOpen()) {
7111  if (!d->m_wallet->hasFolder(KWallet::Wallet::FormDataFolder())) {
7112  d->m_wallet->createFolder(KWallet::Wallet::FormDataFolder());
7113  }
7114  d->m_wallet->setFolder(KWallet::Wallet::FormDataFolder());
7115  d->m_wallet->writeMap(key, data);
7116  return;
7117  }
7118  d->m_wallet->deleteLater();
7119  d->m_wallet = 0L;
7120  d->m_bWalletOpened = false;
7121  }
7122  }
7123 
7124  if (!d->m_wq) {
7125  KWallet::Wallet *wallet = KWallet::Wallet::openWallet(KWallet::Wallet::NetworkWallet(), widget() ? widget()->topLevelWidget()->winId() : 0, KWallet::Wallet::Asynchronous);
7126  d->m_wq = new KHTMLWalletQueue(this);
7127  d->m_wq->wallet = wallet;
7128  connect(wallet, SIGNAL(walletOpened(bool)), d->m_wq, SLOT(walletOpened(bool)));
7129  connect(d->m_wq, SIGNAL(walletOpened(KWallet::Wallet*)), this, SLOT(walletOpened(KWallet::Wallet*)));
7130  }
7131  d->m_wq->savers.append(qMakePair(key, data));
7132 #endif // KHTML_NO_WALLET
7133 }
7134 
7135 
7136 void KHTMLPart::dequeueWallet(DOM::HTMLFormElementImpl *form) {
7137 #ifndef KHTML_NO_WALLET
7138  KHTMLPart *p;
7139 
7140  for (p = parentPart(); p && p->parentPart(); p = p->parentPart()) {
7141  }
7142 
7143  if (p) {
7144  p->dequeueWallet(form);
7145  return;
7146  }
7147 
7148  if (d->m_wq) {
7149  d->m_wq->callers.removeAll(KHTMLWalletQueue::Caller(form, form->document()));
7150  }
7151 #endif // KHTML_NO_WALLET
7152 }
7153 
7154 
7155 void KHTMLPart::walletOpened(KWallet::Wallet *wallet) {
7156 #ifndef KHTML_NO_WALLET
7157  assert(!d->m_wallet);
7158  assert(d->m_wq);
7159 
7160  d->m_wq->deleteLater(); // safe?
7161  d->m_wq = 0L;
7162 
7163  if (!wallet) {
7164  d->m_bWalletOpened = false;
7165  return;
7166  }
7167 
7168  d->m_wallet = wallet;
7169  d->m_bWalletOpened = true;
7170  connect(d->m_wallet, SIGNAL(walletClosed()), SLOT(slotWalletClosed()));
7171  d->m_walletForms.clear();
7172  if (!d->m_statusBarWalletLabel) {
7173  d->m_statusBarWalletLabel = new KUrlLabel(d->m_statusBarExtension->statusBar());
7174  d->m_statusBarWalletLabel->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Minimum));
7175  d->m_statusBarWalletLabel->setUseCursor(false);
7176  d->m_statusBarExtension->addStatusBarItem(d->m_statusBarWalletLabel, 0, false);
7177  d->m_statusBarWalletLabel->setPixmap(SmallIcon("wallet-open"));
7178  connect(d->m_statusBarWalletLabel, SIGNAL(leftClickedUrl()), SLOT(launchWalletManager()));
7179  connect(d->m_statusBarWalletLabel, SIGNAL(rightClickedUrl()), SLOT(walletMenu()));
7180  }
7181  d->m_statusBarWalletLabel->setToolTip(i18n("The wallet '%1' is open and being used for form data and passwords.", KWallet::Wallet::NetworkWallet()));
7182 #endif // KHTML_NO_WALLET
7183 }
7184 
7185 
7186 KWallet::Wallet *KHTMLPart::wallet()
7187 {
7188 #ifndef KHTML_NO_WALLET
7189  KHTMLPart *p;
7190 
7191  for (p = parentPart(); p && p->parentPart(); p = p->parentPart())
7192  ;
7193 
7194  if (p)
7195  return p->wallet();
7196 
7197  return d->m_wallet;
7198 #else
7199  return 0;
7200 #endif // !KHTML_NO_WALLET
7201 }
7202 
7203 
7204 void KHTMLPart::slotWalletClosed()
7205 {
7206 #ifndef KHTML_NO_WALLET
7207  if (d->m_wallet) {
7208  d->m_wallet->deleteLater();
7209  d->m_wallet = 0L;
7210  }
7211  d->m_bWalletOpened = false;
7212  if (d->m_statusBarWalletLabel) {
7213  d->m_statusBarExtension->removeStatusBarItem(d->m_statusBarWalletLabel);
7214  delete d->m_statusBarWalletLabel;
7215  d->m_statusBarWalletLabel = 0L;
7216  }
7217 #endif // KHTML_NO_WALLET
7218 }
7219 
7220 void KHTMLPart::launchWalletManager()
7221 {
7222 #ifndef KHTML_NO_WALLET
7223  QDBusInterface r("org.kde.kwalletmanager", "/kwalletmanager/MainWindow_1",
7224  "org.kde.KMainWindow");
7225  if (!r.isValid()) {
7226  KToolInvocation::startServiceByDesktopName("kwalletmanager_show");
7227  } else {
7228  r.call(QDBus::NoBlock, "show");
7229  r.call(QDBus::NoBlock, "raise");
7230  }
7231 #endif // KHTML_NO_WALLET
7232 }
7233 
7234 void KHTMLPart::walletMenu()
7235 {
7236 #ifndef KHTML_NO_WALLET
7237  KMenu *menu = new KMenu(0L);
7238  QActionGroup *menuActionGroup = new QActionGroup(menu);
7239  connect( menuActionGroup, SIGNAL(triggered(QAction*)), this, SLOT(removeStoredPasswordForm(QAction*)) );
7240 
7241  menu->addAction(i18n("&Close Wallet"), this, SLOT(slotWalletClosed()));
7242 
7243  if (d->m_view && d->m_view->nonPasswordStorableSite(toplevelURL().host())) {
7244  menu->addAction(i18n("&Allow storing passwords for this site"), this, SLOT(delNonPasswordStorableSite()));
7245  }
7246 
7247  // List currently removable form passwords
7248  for ( QStringList::ConstIterator it = d->m_walletForms.constBegin(); it != d->m_walletForms.constEnd(); ++it ) {
7249  QAction* action = menu->addAction( i18n("Remove password for form %1", *it) );
7250  action->setActionGroup(menuActionGroup);
7251  QVariant var(*it);
7252  action->setData(var);
7253  }
7254 
7255  KAcceleratorManager::manage(menu);
7256  menu->popup(QCursor::pos());
7257 #endif // KHTML_NO_WALLET
7258 }
7259 
7260 void KHTMLPart::removeStoredPasswordForm(QAction* action)
7261 {
7262 #ifndef KHTML_NO_WALLET
7263  assert(action);
7264  assert(d->m_wallet);
7265  QVariant var(action->data());
7266 
7267  if(var.isNull() || !var.isValid() || var.type() != QVariant::String)
7268  return;
7269 
7270  QString key = var.toString();
7271  if (KWallet::Wallet::keyDoesNotExist(KWallet::Wallet::NetworkWallet(),
7272  KWallet::Wallet::FormDataFolder(),
7273  key))
7274  return; // failed
7275 
7276 
7277  if (!d->m_wallet->hasFolder(KWallet::Wallet::FormDataFolder()))
7278  return; // failed
7279 
7280  d->m_wallet->setFolder(KWallet::Wallet::FormDataFolder());
7281  if (d->m_wallet->removeEntry(key))
7282  return; // failed
7283 
7284  d->m_walletForms.removeAll(key);
7285 #endif // KHTML_NO_WALLET
7286 }
7287 
7288 void KHTMLPart::addWalletFormKey(const QString& walletFormKey)
7289 {
7290 #ifndef KHTML_NO_WALLET
7291 
7292  if (parentPart()) {
7293  parentPart()->addWalletFormKey(walletFormKey);
7294  return;
7295  }
7296 
7297  if(!d->m_walletForms.contains(walletFormKey))
7298  d->m_walletForms.append(walletFormKey);
7299 #endif // KHTML_NO_WALLET
7300 }
7301 
7302 void KHTMLPart::delNonPasswordStorableSite()
7303 {
7304 #ifndef KHTML_NO_WALLET
7305  if (d->m_view)
7306  d->m_view->delNonPasswordStorableSite(toplevelURL().host());
7307 #endif // KHTML_NO_WALLET
7308 }
7309 void KHTMLPart::saveLoginInformation(const QString& host, const QString& key, const QMap<QString, QString>& walletMap)
7310 {
7311 #ifndef KHTML_NO_WALLET
7312  d->m_storePass.saveLoginInformation(host, key, walletMap);
7313 #endif // KHTML_NO_WALLET
7314 }
7315 
7316 void KHTMLPart::slotToggleCaretMode()
7317 {
7318  setCaretMode(d->m_paToggleCaretMode->isChecked());
7319 }
7320 
7321 void KHTMLPart::setFormNotification(KHTMLPart::FormNotification fn) {
7322  d->m_formNotification = fn;
7323 }
7324 
7325 KHTMLPart::FormNotification KHTMLPart::formNotification() const {
7326  return d->m_formNotification;
7327 }
7328 
7329 KUrl KHTMLPart::toplevelURL()
7330 {
7331  KHTMLPart* part = this;
7332  while (part->parentPart())
7333  part = part->parentPart();
7334 
7335  if (!part)
7336  return KUrl();
7337 
7338  return part->url();
7339 }
7340 
7341 bool KHTMLPart::isModified() const
7342 {
7343  if ( !d->m_doc )
7344  return false;
7345 
7346  return d->m_doc->unsubmittedFormChanges();
7347 }
7348 
7349 void KHTMLPart::setDebugScript( bool enable )
7350 {
7351  unplugActionList( "debugScriptList" );
7352  if ( enable ) {
7353  if (!d->m_paDebugScript) {
7354  d->m_paDebugScript = new KAction( i18n( "JavaScript &Debugger" ), this );
7355  actionCollection()->addAction( "debugScript", d->m_paDebugScript );
7356  connect( d->m_paDebugScript, SIGNAL(triggered(bool)), this, SLOT(slotDebugScript()) );
7357  }
7358  d->m_paDebugScript->setEnabled( d->m_frame ? d->m_frame->m_jscript : 0L );
7359  QList<QAction*> lst;
7360  lst.append( d->m_paDebugScript );
7361  plugActionList( "debugScriptList", lst );
7362  }
7363  d->m_bJScriptDebugEnabled = enable;
7364 }
7365 
7366 void KHTMLPart::setSuppressedPopupIndicator( bool enable, KHTMLPart *originPart )
7367 {
7368  if ( parentPart() ) {
7369  parentPart()->setSuppressedPopupIndicator( enable, originPart );
7370  return;
7371  }
7372 
7373  if ( enable && originPart ) {
7374  d->m_openableSuppressedPopups++;
7375  if ( d->m_suppressedPopupOriginParts.indexOf( originPart ) == -1 )
7376  d->m_suppressedPopupOriginParts.append( originPart );
7377  }
7378 
7379  if ( enable && !d->m_statusBarPopupLabel ) {
7380  d->m_statusBarPopupLabel = new KUrlLabel( d->m_statusBarExtension->statusBar() );
7381  d->m_statusBarPopupLabel->setSizePolicy( QSizePolicy( QSizePolicy::Fixed, QSizePolicy::Minimum ));
7382  d->m_statusBarPopupLabel->setUseCursor( false );
7383  d->m_statusBarExtension->addStatusBarItem( d->m_statusBarPopupLabel, 0, false );
7384  d->m_statusBarPopupLabel->setPixmap( SmallIcon( "window-suppressed") );
7385 
7386  d->m_statusBarPopupLabel->setToolTip(i18n("This page was prevented from opening a new window via JavaScript." ) );
7387 
7388  connect(d->m_statusBarPopupLabel, SIGNAL(leftClickedUrl()), SLOT(suppressedPopupMenu()));
7389  if (d->m_settings->jsPopupBlockerPassivePopup()) {
7390  QPixmap px;
7391  px = MainBarIcon( "window-suppressed" );
7392  KPassivePopup::message(i18n("Popup Window Blocked"),i18n("This page has attempted to open a popup window but was blocked.\nYou can click on this icon in the status bar to control this behavior\nor to open the popup."),px,d->m_statusBarPopupLabel);
7393  }
7394  } else if ( !enable && d->m_statusBarPopupLabel ) {
7395  d->m_statusBarPopupLabel->setToolTip("" );
7396  d->m_statusBarExtension->removeStatusBarItem( d->m_statusBarPopupLabel );
7397  delete d->m_statusBarPopupLabel;
7398  d->m_statusBarPopupLabel = 0L;
7399  }
7400 }
7401 
7402 void KHTMLPart::suppressedPopupMenu() {
7403  KMenu *m = new KMenu(0L);
7404  if ( d->m_openableSuppressedPopups )
7405  m->addAction(i18np("&Show Blocked Popup Window","&Show %1 Blocked Popup Windows", d->m_openableSuppressedPopups), this, SLOT(showSuppressedPopups()));
7406  QAction *a = m->addAction(i18n("Show Blocked Window Passive Popup &Notification"), this, SLOT(togglePopupPassivePopup()));
7407  a->setChecked(d->m_settings->jsPopupBlockerPassivePopup());
7408  m->addAction(i18n("&Configure JavaScript New Window Policies..."), this, SLOT(launchJSConfigDialog()));
7409  m->popup(QCursor::pos());
7410 }
7411 
7412 void KHTMLPart::togglePopupPassivePopup() {
7413  // Same hack as in disableJSErrorExtension()
7414  d->m_settings->setJSPopupBlockerPassivePopup( !d->m_settings->jsPopupBlockerPassivePopup() );
7415  emit configurationChanged();
7416 }
7417 
7418 void KHTMLPart::showSuppressedPopups() {
7419  foreach ( KHTMLPart* part, d->m_suppressedPopupOriginParts ) {
7420  if (part) {
7421  KJS::Window *w = KJS::Window::retrieveWindow( part );
7422  if (w) {
7423  w->showSuppressedWindows();
7424  w->forgetSuppressedWindows();
7425  }
7426  }
7427  }
7428  setSuppressedPopupIndicator( false );
7429  d->m_openableSuppressedPopups = 0;
7430  d->m_suppressedPopupOriginParts.clear();
7431 }
7432 
7433 // Extension to use for "view document source", "save as" etc.
7434 // Using the right extension can help the viewer get into the right mode (#40496)
7435 QString KHTMLPart::defaultExtension() const
7436 {
7437  if ( !d->m_doc )
7438  return ".html";
7439  if ( !d->m_doc->isHTMLDocument() )
7440  return ".xml";
7441  return d->m_doc->htmlMode() == DOM::DocumentImpl::XHtml ? ".xhtml" : ".html";
7442 }
7443 
7444 bool KHTMLPart::inProgress() const
7445 {
7446  if (!d->m_bComplete || d->m_runningScripts || (d->m_doc && d->m_doc->parsing()))
7447  return true;
7448 
7449  // Any frame that hasn't completed yet ?
7450  ConstFrameIt it = d->m_frames.constBegin();
7451  const ConstFrameIt end = d->m_frames.constEnd();
7452  for (; it != end; ++it ) {
7453  if ((*it)->m_run || !(*it)->m_bCompleted)
7454  return true;
7455  }
7456 
7457  return d->m_submitForm || !d->m_redirectURL.isEmpty() || d->m_redirectionTimer.isActive() || d->m_job;
7458 }
7459 
7460 using namespace KParts;
7461 #include "khtml_part.moc"
7462 #include "khtmlpart_p.moc"
7463 #ifndef KHTML_NO_WALLET
7464 #include "khtml_wallet_p.moc"
7465 #endif
7466 
7467 // kate: indent-width 4; replace-tabs on; tab-width 4; space-indent on;
KHTMLPart::findTextBegin
void findTextBegin()
Initiates a text search.
Definition: khtml_part.cpp:2966
sDNSTTLSeconds
static const int sDNSTTLSeconds
Definition: khtml_part.cpp:145
KHTMLPart::findFramePart
KParts::ReadOnlyPart * findFramePart(const QString &f)
Finds a frame by name.
Definition: khtml_part.cpp:5290
KIO::JobUiDelegate::setWindow
virtual void setWindow(QWidget *window)
KHTMLPartPrivate::m_ssl_cert_errors
QString m_ssl_cert_errors
Definition: khtmlpart_p.h:291
KHTMLSettings
Settings for the HTML view.
Definition: khtml_settings.h:41
dom_string.h
KHTMLPartPrivate::m_paFind
KAction * m_paFind
Definition: khtmlpart_p.h:329
KHTMLSettings::jsErrorsEnabled
bool jsErrorsEnabled() const
Definition: khtml_settings.cpp:1154
KHTMLPartPrivate::m_bStrictModeQuirk
bool m_bStrictModeQuirk
Definition: khtmlpart_p.h:378
KParts::BrowserExtension
KHTMLPart::khtmlDrawContentsEvent
virtual void khtmlDrawContentsEvent(khtml::DrawContentsEvent *)
Eventhandler for the khtml::DrawContentsEvent.
Definition: khtml_part.cpp:6619
KStandardGuiItem::cancel
KGuiItem cancel()
KHTMLPart::hide
void hide()
Convenience method to hide the document&#39;s view.
Definition: khtml_part.cpp:5683
KHTMLPartPrivate::m_redirectionTimer
QTimer m_redirectionTimer
Definition: khtmlpart_p.h:312
khtml::MousePressEvent
Definition: khtml_events.h:63
ConstFrameIt
KHTMLFrameList::ConstIterator ConstFrameIt
Definition: khtml_childframe_p.h:86
message
void message(KMessage::MessageType messageType, const QString &text, const QString &caption=QString())
KHTMLPartPrivate::executeAnchorJump
void executeAnchorJump(const KUrl &url, bool lockHistory)
Definition: khtml_part.cpp:631
i18n
QString i18n(const char *text)
KJob::kill
bool kill(KillVerbosity verbosity=Quietly)
khtml::MouseDoubleClickEvent::clickCount
int clickCount() const
Definition: khtml_events.h:93
khtml::EditorContext
Contextual information about the caret and the built-in editor.
Definition: editing_p.h:38
KIconLoader::SizeMedium
SizeMedium
KHTMLPart::nodeUnderMouse
DOM::Node nodeUnderMouse() const
Returns the Node currently under the mouse.
Definition: khtml_part.cpp:5689
KHTMLPartPrivate::m_paUseStylesheet
KSelectAction * m_paUseStylesheet
Definition: khtmlpart_p.h:325
KHTMLPart::setSelection
void setSelection(const DOM::Range &)
Sets the current selection.
Definition: khtml_part.cpp:3272
KHTMLPart::BrowserViewGUI
Definition: khtml_part.h:272
KParts::ScriptableExtension::childObject
static ScriptableExtension * childObject(QObject *obj)
KParts::BrowserArguments::setLockHistory
void setLockHistory(bool lock)
KHTMLPartPrivate::classifyMimeType
MimeType classifyMimeType(const QString &mime)
Definition: khtml_part.cpp:1958
KFindDialog
KMimeType::ResolveAliases
ResolveAliases
KHTMLPartPrivate::m_workingURL
KUrl m_workingURL
Definition: khtmlpart_p.h:309
KHTMLPartPrivate::m_doc
DOM::DocumentImpl * m_doc
Definition: khtmlpart_p.h:242
KSharedPtr< KMimeType >
KHTMLSettings::KAnimationDisabled
Definition: khtml_settings.h:55
KHTMLPartPrivate::m_jobPercent
unsigned int m_jobPercent
Definition: khtmlpart_p.h:398
KHTMLPart::nextAnchor
bool nextAnchor()
Go to the next anchor.
Definition: khtml_part.cpp:2752
KEncodingDetector::Japanese
Japanese
KHTMLSettings::isJavaScriptEnabled
bool isJavaScriptEnabled(const QString &hostname=QString()) const
Definition: khtml_settings.cpp:911
KIO::getCacheControlString
QString getCacheControlString(KIO::CacheControl cacheControl)
KUrl::toLocalFile
QString toLocalFile(AdjustPathOption trailing=LeaveTrailingSlash) const
KHTMLPart::dnsPrefetch
DNSPrefetch dnsPrefetch() const
Returns currently set DNS prefetching mode.
sDNSPrefetchTimerDelay
static const int sDNSPrefetchTimerDelay
Definition: khtml_part.cpp:144
KHTMLPageCache::fetchData
void fetchData(long id, QObject *recvObj, const char *recvSlot)
Fetch data for cache entry id and send it to slot recvSlot in the object recvObj. ...
Definition: khtml_pagecache.cpp:206
MainBarIcon
QPixmap MainBarIcon(const QString &name, int force_size, int state, const QStringList &overlays)
KHTMLPartPrivate::setFlagRecursively
void setFlagRecursively(bool KHTMLPartPrivate::*flag, bool value)
Definition: khtml_part.cpp:2810
KHTMLPartPrivate::m_paViewDocument
KAction * m_paViewDocument
Definition: khtmlpart_p.h:317
KAction::setShortcuts
void setShortcuts(const QList< QKeySequence > &shortcuts, ShortcutTypes type=ShortcutTypes(ActiveShortcut|DefaultShortcut))
KEncodingDetector::Arabic
Arabic
header
const char header[]
KHTMLPart::caretDisplayPolicyNonFocused
CaretDisplayPolicy caretDisplayPolicyNonFocused() const
Returns the current caret policy when the view is not focused.
Definition: khtml_part.cpp:2927
netaccess.h
KHTMLPart::KJSProxy
friend class KJSProxy
Definition: khtml_part.h:234
KParts::BrowserExtension::ShowBookmark
ShowBookmark
KHTMLPart::completeURL
KUrl completeURL(const QString &url)
returns a KUrl object for the given url.
Definition: khtml_part.cpp:2518
KParts::OpenUrlArguments::xOffset
int xOffset() const
KMessageBox::Continue
Continue
KHTMLPart::docCreated
void docCreated()
KUrl::split
static List split(const QString &_url)
QCursor
KHTMLPartPrivate::m_bOpenMiddleClick
bool m_bOpenMiddleClick
Definition: khtmlpart_p.h:254
KHTMLPart::zoomFactor
int zoomFactor() const
Returns the current zoom factor.
Definition: khtml_part.cpp:5711
KHTMLPartPrivate::m_caretMode
bool m_caretMode
Definition: khtmlpart_p.h:391
KIO::Job::addMetaData
void addMetaData(const QString &key, const QString &value)
DOM::Node
The Node interface is the primary datatype for the entire Document Object Model.
Definition: dom_node.h:270
ksslinfodialog.h
KXMLGUIClient::action
QAction * action(const char *name) const
KHTMLPartPrivate::m_paStopAnimations
KAction * m_paStopAnimations
Definition: khtmlpart_p.h:339
KHTMLPart::fontScaleFactor
int fontScaleFactor() const
Returns the current font scale factor.
Definition: khtml_part.cpp:5883
KHTMLPartPrivate::m_paToggleCaretMode
KToggleAction * m_paToggleCaretMode
Definition: khtmlpart_p.h:340
khtml_pagecache.h
kdebug.h
KHTMLPart::restored
bool restored() const
Definition: khtml_part.cpp:6980
khtml::ChildFrame
Definition: khtml_childframe_p.h:40
minZoom
static const int minZoom
Definition: khtml_part.cpp:5719
KHTMLPart::browserExtension
KParts::BrowserExtension * browserExtension() const
Returns a pointer to the KParts::BrowserExtension.
Definition: khtml_part.cpp:1045
DOM::Editor
This class resembles the editing API when the associated khtml document is editable (in design mode)...
Definition: editor.h:61
KWallet::Wallet
KHTMLPart::doOpenStream
virtual bool doOpenStream(const QString &mimeType)
Implements the streaming API of KParts::ReadOnlyPart.
Definition: khtml_part.cpp:2166
KSslInfoDialog::errorsFromString
static QList< QList< KSslError::Error > > errorsFromString(const QString &s)
KHTMLPartPrivate::m_autoDetectLanguage
KEncodingDetector::AutoDetectScript m_autoDetectLanguage
Definition: khtmlpart_p.h:243
KParts::ReadOnlyPart::url
KUrl url() const
KParts::PartManager::activePart
virtual Part * activePart() const
KHTMLPartPrivate::m_walletForms
QStringList m_walletForms
Definition: khtmlpart_p.h:251
KHTMLPart::editor
DOM::Editor * editor() const
Returns the instance of the attached html editor interface.
Definition: khtml_part.cpp:3497
KHTMLPart::setUserStyleSheet
void setUserStyleSheet(const KUrl &url)
Sets a user defined style sheet to be used on top of the HTML 4 default style sheet.
Definition: khtml_part.cpp:2692
KHTMLPartPrivate::m_ssl_in_use
bool m_ssl_in_use
Definition: khtmlpart_p.h:300
khtml::ChildFrame::Frame
Definition: khtml_childframe_p.h:44
KHTMLPartPrivate::m_openableSuppressedPopups
int m_openableSuppressedPopups
Definition: khtmlpart_p.h:241
KHTMLPart::GUIProfile
GUIProfile
Definition: khtml_part.h:272
KHTMLPart::slotFinished
virtual void slotFinished(KJob *)
Called when the job downloading the page is finished.
Definition: khtml_part.cpp:1903
KStringHandler::rsqueeze
QString rsqueeze(const QString &str, int maxlen=40)
KIO::NetAccess::removeTempFile
static void removeTempFile(const QString &name)
DOM::HTMLDocument
An HTMLDocument is the root of the HTML hierarchy and holds the entire content.
Definition: html_document.h:73
KPluginFactory::create
T * create(QObject *parent=0, const QVariantList &args=QVariantList())
KHTMLPageCache::self
static KHTMLPageCache * self()
static "constructor".
Definition: khtml_pagecache.cpp:130
DOM::Range::endContainer
Node endContainer() const
Node within which the range ends.
Definition: dom2_range.cpp:136
KHTMLSettings::isHideAdsEnabled
bool isHideAdsEnabled() const
Definition: khtml_settings.cpp:828
KHTMLPart::currentFrame
KParts::ReadOnlyPart * currentFrame() const
Return the current frame (the one that has focus) Not necessarily a direct child of ours...
Definition: khtml_part.cpp:5296
KHTMLPartPrivate::editor_context
khtml::EditorContext editor_context
Definition: khtmlpart_p.h:371
KEncodingDetector
KHTMLPartPrivate::m_manager
KParts::PartManager * m_manager
Definition: khtmlpart_p.h:343
KHTMLZoomFactorAction
Definition: khtml_ext.h:161
KEncodingDetector::decodeWithBuffering
QString decodeWithBuffering(const char *data, int len)
khtml::MouseMoveEvent
Definition: khtml_events.h:100
KHTMLSettings::setJSErrorsEnabled
void setJSErrorsEnabled(bool enabled)
Definition: khtml_settings.cpp:1159
KHTMLPart::restoreState
virtual void restoreState(QDataStream &stream)
Restores the KHTMLPart&#39;s previously saved state (including child frame objects) from the provided QDa...
Definition: khtml_part.cpp:5479
QDialog
khtml::ChildFrame::m_serviceType
QString m_serviceType
Definition: khtml_childframe_p.h:59
KIconLoader::global
static KIconLoader * global()
KIO::UDSEntry
KParts::OpenUrlArguments::metaData
QMap< QString, QString > & metaData()
KHTMLPartPrivate::codeForJavaScriptURL
static QString codeForJavaScriptURL(const QString &url)
Definition: khtml_part.cpp:2530
KHTMLPartPrivate::m_totalObjectCount
unsigned long m_totalObjectCount
Definition: khtmlpart_p.h:397
KHTMLGlobal::componentData
static const KComponentData & componentData()
Definition: khtml_global.cpp:202
KService::serviceTypes
QStringList serviceTypes() const
kglobalsettings.h
khtml::ChildFrame::m_args
KParts::OpenUrlArguments m_args
Definition: khtml_childframe_p.h:63
KXMLGUIFactory::removeClient
void removeClient(KXMLGUIClient *client)
assert
#define assert(x)
Definition: editor.cpp:43
KHTMLPart::htmlDocument
DOM::HTMLDocument htmlDocument() const
Returns a reference to the DOM HTML document (for non-HTML documents, returns null) ...
Definition: khtml_part.cpp:1000
KHTMLPart::lastModified
QString lastModified() const
Last-modified date (in raw string format), if received in the [HTTP] headers.
KHTMLPart::Only
Definition: khtml_part.h:1106
KIO
KHTMLSettings::KSmoothScrollingWhenEfficient
Definition: khtml_settings.h:62
khtml::MouseDoubleClickEvent::test
static bool test(const QEvent *event)
Definition: khtml_events.h:90
KHTMLPartPrivate::m_statusBarUALabel
KUrlLabel * m_statusBarUALabel
Definition: khtmlpart_p.h:236
kauthorized.h
KHTMLSettings::userStyleSheet
QString userStyleSheet() const
Definition: khtml_settings.cpp:1079
KProtocolManager::userAgentForHost
static QString userAgentForHost(const QString &hostname)
KUrl::populateMimeData
void populateMimeData(QMimeData *mimeData, const MetaDataMap &metaData=MetaDataMap(), MimeDataFlags flags=DefaultMimeDataFlags) const
KHTMLPartPrivate::m_DNSTTLTimer
int m_DNSTTLTimer
Definition: khtmlpart_p.h:273
KXMLGUIClient::removeChildClient
void removeChildClient(KXMLGUIClient *child)
khtml::MouseEvent::url
DOM::DOMString url() const
Definition: khtml_events.h:44
khtml::MouseEvent::y
int y() const
Definition: khtml_events.h:40
ki18n
KLocalizedString ki18n(const char *msg)
KHTMLPartPrivate
Definition: khtmlpart_p.h:93
KHTMLPart::setJSStatusBarText
void setJSStatusBarText(const QString &text)
Called by KJS.
Definition: khtml_part.cpp:5920
khtml::ChildFrame::m_run
QWeakPointer< KHTMLRun > m_run
Definition: khtml_childframe_p.h:65
khtml_part.h
kfiledialog.h
i18np
QString i18np(const char *sing, const char *plur, const A1 &a1)
timeout
int timeout
khtml::ChildFrame::m_browserArgs
KParts::BrowserArguments m_browserArgs
Definition: khtml_childframe_p.h:64
KHTMLPart::view
KHTMLView * view() const
Returns a pointer to the HTML document&#39;s view.
Definition: khtml_part.cpp:1055
KHTMLPartPrivate::m_paFindNext
KAction * m_paFindNext
Definition: khtmlpart_p.h:330
zoomSizeCount
static const int zoomSizeCount
Definition: khtml_part.cpp:5718
d
#define d
Definition: khtmlfind.cpp:42
partmanager.h
KHTMLPart::isPointInsideSelection
bool isPointInsideSelection(int x, int y)
Returns whether the given point is inside the current selection.
Definition: khtml_part.cpp:6119
KHTMLPart::pluginPageQuestionAsked
bool pluginPageQuestionAsked(const QString &mimetype) const
Definition: khtml_part.cpp:6985
mimetype
MimetypeJob * mimetype(const KUrl &url, JobFlags flags=DefaultFlags)
KHTMLPart::DNSPrefetchEnabled
Definition: khtml_part.h:283
KHTMLPartPrivate::m_frameNameId
int m_frameNameId
Definition: khtmlpart_p.h:277
kactioncollection.h
KParts::ReadOnlyPart::completed
void completed()
KMenu
KEncodingDetector::visuallyOrdered
bool visuallyOrdered() const
KHTMLPopupGUIClient::saveURL
static void saveURL(QWidget *parent, const QString &caption, const KUrl &url, const QMap< QString, QString > &metaData=KIO::MetaData(), const QString &filter=QString(), long cacheId=0, const QString &suggestedFilename=QString())
Definition: khtml_ext.cpp:859
FrameIt
KHTMLFrameList::Iterator FrameIt
Definition: khtml_childframe_p.h:87
KMessageBox::information
static void information(QWidget *parent, const QString &text, const QString &caption=QString(), const QString &dontShowAgainName=QString(), Options options=Notify)
KStandardDirs::locate
static QString locate(const char *type, const QString &filename, const KComponentData &cData=KGlobal::mainComponent())
KParts::BrowserOpenOrSaveQuestion::Result
Result
khtml
KIO::HideProgressInfo
HideProgressInfo
KXMLGUIFactory::addClient
void addClient(KXMLGUIClient *client)
KUrl::equals
bool equals(const KUrl &u, const EqualsOptions &options=0) const
KHTMLPartPrivate::m_decoder
KEncodingDetector * m_decoder
Definition: khtmlpart_p.h:244
KHTMLPart::KHTMLView
friend class KHTMLView
Definition: khtml_part.h:209
DOM::Range::isNull
bool isNull() const
Definition: dom2_range.cpp:410
KHTMLPart::browserHostExtension
KParts::BrowserHostExtension * browserHostExtension() const
Definition: khtml_part.cpp:1050
KPassivePopup::message
static KPassivePopup * message(const QString &text, QWidget *parent)
KHTMLPart::dndEnabled
bool dndEnabled() const
Returns whether Dragn&#39;n&#39;Drop support is enabled or not.
KParts::BrowserArguments
KHTMLPartPrivate::m_suppressedPopupOriginParts
QList< QPointer< KHTMLPart > > m_suppressedPopupOriginParts
Definition: khtmlpart_p.h:239
KMimeType::findByPath
static Ptr findByPath(const QString &path, mode_t mode=0, bool fast_mode=false, int *accuracy=0)
khtml::ChildFrame::m_params
QStringList m_params
Definition: khtml_childframe_p.h:68
KParts::Part::loadPlugins
void loadPlugins()
KHTMLPartPrivate::m_DNSPrefetchQueue
QQueue< QString > m_DNSPrefetchQueue
Definition: khtmlpart_p.h:275
QWidget
dom2_range.h
KEncodingDetector::setAutoDetectLanguage
void setAutoDetectLanguage(AutoDetectScript)
KParts::ScriptableExtension
zoomOut
KAction * zoomOut(const QObject *recvr, const char *slot, QObject *parent)
KSycocaEntry::name
QString name() const
KEncodingDetector::DefaultEncoding
DefaultEncoding
khtml::EditorContext::reset
void reset()
Definition: editing.cpp:32
KStandardAction::SaveAs
SaveAs
KParts::BrowserOpenOrSaveQuestion::setSuggestedFileName
void setSuggestedFileName(const QString &suggestedFileName)
kstandardguiitem.h
KLocale::removeCatalog
void removeCatalog(const QString &catalog)
KLocale::encoding
const QByteArray encoding() const
KHTMLPartPrivate::m_jsedlg
KJSErrorDlg * m_jsedlg
Definition: khtmlpart_p.h:408
khtml::ChildFrame::IFrame
Definition: khtml_childframe_p.h:44
KHTMLPartPrivate::m_guiProfile
KHTMLPart::GUIProfile m_guiProfile
Definition: khtmlpart_p.h:345
KEncodingDetector::Cyrillic
Cyrillic
KHTMLPart::frameExists
bool frameExists(const QString &frameName)
Returns whether a frame with the specified name is exists or not.
Definition: khtml_part.cpp:5311
html_document.h
KParts::PartManager::removePart
virtual void removePart(Part *part)
KMimeTypeTrader::query
KService::List query(const QString &mimeType, const QString &genericServiceType=QString::fromLatin1("Application"), const QString &constraint=QString()) const
KIO::get
TransferJob * get(const KUrl &url, LoadType reload=NoReload, JobFlags flags=DefaultFlags)
KDE::stat
int stat(const QString &path, KDE_struct_stat *buf)
KHTMLPart
This class is khtml&#39;s main class.
Definition: khtml_part.h:206
name
const char * name(StandardAction id)
KUrl::setRef
void setRef(const QString &fragment)
KHTMLPart::setPluginsEnabled
void setPluginsEnabled(bool enable)
Enables or disables plugins, default is enabled.
Definition: khtml_part.cpp:1378
DOM::Range::startContainer
Node startContainer() const
Node within which the range begins.
Definition: dom2_range.cpp:113
KHTMLView::SSMEnabled
Definition: khtmlview.h:305
kError
static QDebug kError(bool cond, int area=KDE_DEFAULT_DEBUG_AREA)
KHTMLPart::CaretInvisible
caret is not displayed
Definition: khtml_part.h:588
KIO::stat
StatJob * stat(const KUrl &url, JobFlags flags=DefaultFlags)
DOM::DOMString::length
uint length() const
Definition: dom_string.cpp:185
khtml::DrawContentsEvent::test
static bool test(const QEvent *event)
Definition: khtml_events.h:142
KHTMLPartPrivate::m_statusBarJSErrorLabel
KUrlLabel * m_statusBarJSErrorLabel
Definition: khtmlpart_p.h:237
KHTMLPart::saveState
virtual void saveState(QDataStream &stream)
Saves the KHTMLPart&#39;s complete state (including child frame objects) to the provided QDataStream...
Definition: khtml_part.cpp:5391
KHTMLPartPrivate::m_paIncZoomFactor
KSelectAction * m_paIncZoomFactor
Definition: khtmlpart_p.h:326
KActionCollection::addAction
QAction * addAction(const QString &name, QAction *action)
KHTMLView
Renders and displays HTML in a QScrollArea.
Definition: khtmlview.h:92
SVGDocument.h
KConfigGroup::writeEntry
void writeEntry(const QString &key, const QVariant &value, WriteConfigFlags pFlags=Normal)
KIO::CC_Reload
CC_Reload
KParts::Part::widget
virtual QWidget * widget()
KXMLGUIClient::setXMLFile
virtual void setXMLFile(const QString &file, bool merge=false, bool setXMLDoc=true)
KIO::StatJob
kiconloader.h
KHTMLPart::KHTMLPartBrowserHostExtension
friend class KHTMLPartBrowserHostExtension
Definition: khtml_part.h:240
KHTMLView::part
KHTMLPart * part() const
Returns a pointer to the KHTMLPart that is rendering the page.
Definition: khtmlview.h:135
KParts::ReadOnlyPart::setUrl
void setUrl(const KUrl &url)
KHTMLPartPrivate::isFullyLoaded
bool isFullyLoaded(bool *pendingRedirections) const
Definition: khtml_part.cpp:2355
kacceleratormanager.h
KHTMLPartPrivate::m_redirectURL
QString m_redirectURL
Definition: khtmlpart_p.h:315
KHTMLPartPrivate::m_paSaveBackground
KAction * m_paSaveBackground
Definition: khtmlpart_p.h:320
KHTMLPartPrivate::m_paPrintFrame
KAction * m_paPrintFrame
Definition: khtmlpart_p.h:334
khtml::ChildFrame::m_bPendingRedirection
bool m_bPendingRedirection
Definition: khtml_childframe_p.h:71
KHTMLPart::inProgress
bool inProgress() const
Definition: khtml_part.cpp:7444
KIO::pixmapForUrl
QPixmap pixmapForUrl(const KUrl &_url, mode_t _mode=0, KIconLoader::Group _group=KIconLoader::Desktop, int _force_size=0, int _state=0, QString *_path=0)
KHTMLPartPrivate::SubmitForm
Definition: khtmlpart_p.h:355
KTemporaryFile
KParts::Part
KUrl::CompareWithoutTrailingSlash
CompareWithoutTrailingSlash
KHTMLPartPrivate::m_submitForm
SubmitForm * m_submitForm
Definition: khtmlpart_p.h:365
KHTMLGlobal::defaultHTMLSettings
static KHTMLSettings * defaultHTMLSettings()
Definition: khtml_global.cpp:237
DOM::Range::isDetached
bool isDetached() const
not part of the DOM true if the range is detached
Definition: dom2_range.cpp:397
KHTMLPart::urlSelected
virtual bool urlSelected(const QString &url, int button, int state, const QString &_target, const KParts::OpenUrlArguments &args=KParts::OpenUrlArguments(), const KParts::BrowserArguments &browserArgs=KParts::BrowserArguments())
Definition: khtml_part.cpp:3687
KTemporaryFile::setSuffix
void setSuffix(const QString &suffix)
KHTMLViewBar::Bottom
Definition: khtmlviewbar.h:34
KHTMLPartPrivate::m_extension
KHTMLPartBrowserExtension * m_extension
Definition: khtmlpart_p.h:230
KHTMLPartPrivate::clearRedirection
void clearRedirection()
Definition: khtml_part.cpp:2584
KHTMLPartPrivate::m_paSecurity
KAction * m_paSecurity
Definition: khtmlpart_p.h:323
isAncestorOrSamePart
static bool isAncestorOrSamePart(KHTMLPart *p1, KHTMLPart *p2)
Definition: khtml_part.cpp:2251
KParts::OpenUrlArguments::mimeType
QString mimeType() const
KHTMLPart::KHTMLPartIface
friend class KHTMLPartIface
Definition: khtml_part.h:248
KJSErrorDlg::addError
void addError(const QString &error)
Definition: kjserrordlg.cpp:13
KHTMLPart::Before
Definition: khtml_part.h:1106
kstatusbar.h
ktoolinvocation.h
QObject
kDebug
static QDebug kDebug(bool cond, int area=KDE_DEFAULT_DEBUG_AREA)
KIO::Job::queryMetaData
QString queryMetaData(const QString &key)
KParts::BrowserArguments::setDoPost
void setDoPost(bool enable)
KHTMLPartPrivate::m_bJavaEnabled
bool m_bJavaEnabled
Definition: khtmlpart_p.h:257
klocale.h
global.h
KHTMLPartPrivate::m_hostExtension
KHTMLPartBrowserHostExtension * m_hostExtension
Definition: khtmlpart_p.h:232
KHTMLPartPrivate::findFrameParent
KHTMLPart * findFrameParent(KParts::ReadOnlyPart *callingPart, const QString &f, khtml::ChildFrame **childFrame, bool checkForNavigation)
Definition: khtml_part.cpp:5192
indent
QString indent(QString text, int spaces)
khtml::MouseReleaseEvent
Definition: khtml_events.h:115
KActionCollection::associateWidget
void associateWidget(QWidget *widget) const
KHTMLPart::setCaretMode
void setCaretMode(bool enable)
Enables/disables caret mode.
Definition: khtml_part.cpp:2864
KIconLoader::Desktop
Desktop
KParts::ReadOnlyPart::started
void started(KIO::Job *)
DOM::strcmp
bool strcmp(const DOMString &a, const DOMString &b)
Definition: dom_string.h:153
KHTMLPartPrivate::s_dnsInitialised
static bool s_dnsInitialised
Definition: khtmlpart_p.h:421
KHTMLPart::selectionChanged
void selectionChanged()
This signal is emitted when the selection changes.
KIO::MetaData
khtml::MouseEvent::x
int x() const
Definition: khtml_events.h:39
KHTMLPart::setEncoding
bool setEncoding(const QString &name, bool override=false)
Sets the encoding the page uses.
Definition: khtml_part.cpp:2650
KUrl::prettyUrl
QString prettyUrl(AdjustPathOption trailing=LeaveTrailingSlash) const
KHTMLPart::khtmlMouseReleaseEvent
virtual void khtmlMouseReleaseEvent(khtml::MouseReleaseEvent *event)
Eventhandler for the khtml::MouseMouseReleaseEvent.
Definition: khtml_part.cpp:6558
kurifilter.h
run
bool run(const KUrl &_url, bool _is_local)
KHTMLPartPrivate::canNavigate
bool canNavigate(KParts::ReadOnlyPart *b)
Definition: khtml_part.cpp:5247
KWallet::Wallet::openWallet
static Wallet * openWallet(const QString &name, WId w, OpenType ot=Synchronous)
KParts::ReadOnlyPart::url
KUrl url
KHTMLPartPrivate::m_bClearing
bool m_bClearing
Definition: khtmlpart_p.h:379
KUrl
browserinterface.h
KHTMLPartPrivate::top
KHTMLPart * top()
Definition: khtml_part.cpp:5239
KUrl::setQuery
void setQuery(const QString &query)
browseropenorsavequestion.h
KHTMLFindBar::setOptions
void setOptions(long options)
Set the options which are checked.
Definition: khtmlfindbar.cpp:190
i18nc
QString i18nc(const char *ctxt, const char *text)
MimeXHTML
Definition: khtmlpart_p.h:85
KEncodingDetector::AutoDetectScript
AutoDetectScript
KHTMLPart::customEvent
virtual void customEvent(QEvent *event)
Definition: khtml_part.cpp:6084
KGlobal::config
KSharedConfigPtr config()
KHTMLPartPrivate::m_topViewBar
QPointer< KHTMLViewBar > m_topViewBar
Definition: khtmlpart_p.h:228
kprotocolmanager.h
KLocalizedString::subs
KLocalizedString subs(int a, int fieldWidth=0, int base=10, const QChar &fillChar=QLatin1Char(' ')) const
KLocale::formatNumber
QString formatNumber(double num, int precision=-1) const
KHTMLPart::setOnlyLocalReferences
void setOnlyLocalReferences(bool enable)
Security option.
Definition: khtml_part.cpp:2795
KUrl::setPath
void setPath(const QString &path)
KHTMLPartPrivate::m_paSetEncoding
KCodecAction * m_paSetEncoding
Definition: khtmlpart_p.h:324
KMessageBox::Cancel
Cancel
KHTMLPartPrivate::m_paDecZoomFactor
KSelectAction * m_paDecZoomFactor
Definition: khtmlpart_p.h:327
KHTMLPart::javaEnabled
bool javaEnabled() const
Return true if Java applet support is enabled, false if disabled.
KMimeType::comment
QString comment(const KUrl &url=KUrl()) const
KHTMLPageCache::isComplete
bool isComplete(long id)
Definition: khtml_pagecache.cpp:197
KHTMLPart::KHTMLPartBrowserExtension
friend class KHTMLPartBrowserExtension
Definition: khtml_part.h:235
editor.h
KStandardAction::FindPrev
FindPrev
KPluginLoader::errorString
QString errorString() const
KHTMLGlobal::deregisterPart
static void deregisterPart(KHTMLPart *part)
Definition: khtml_global.cpp:162
KHTMLPart::DNSPrefetchOnlyWWWAndSLD
Definition: khtml_part.h:284
khtmlviewbar.h
kpassivepopup.h
KHTMLPart::isCaretMode
bool isCaretMode() const
Returns whether caret mode is on/off.
Definition: khtml_part.cpp:2881
KHTMLSettings::isJavaEnabled
bool isJavaEnabled(const QString &hostname=QString()) const
Definition: khtml_settings.cpp:906
KUrl::setUser
void setUser(const QString &user)
KHTMLPartPrivate::m_statusBarExtension
KParts::StatusBarExtension * m_statusBarExtension
Definition: khtmlpart_p.h:231
KShortcut
firstRunAt
static bool firstRunAt(khtml::RenderObject *renderNode, int y, NodeImpl *&startNode, long &startOffset)
returns the position of the first inline text box of the line at coordinate y in renderNode ...
Definition: khtml_part.cpp:6141
KIconLoader::loadIcon
QPixmap loadIcon(const QString &name, KIconLoader::Group group, int size=0, int state=KIconLoader::DefaultState, const QStringList &overlays=QStringList(), QString *path_store=0L, bool canReturnNull=false) const
KEncodingDetector::Baltic
Baltic
KHTMLPart::formSubmitNotification
void formSubmitNotification(const char *action, const QString &url, const QByteArray &formData, const QString &target, const QString &contentType, const QString &boundary)
If form notification is on, this will be emitted either for a form submit or before the form submit a...
KHTMLPart::onURL
void onURL(const QString &url)
Emitted if the cursor is moved over an URL.
KConfigGroup::deleteEntry
void deleteEntry(const QString &pKey, WriteConfigFlags pFlags=Normal)
KParts::BrowserOpenOrSaveQuestion
KSelectAction
KFileItem::Unknown
Unknown
KParts::Part::customEvent
virtual void customEvent(QEvent *event)
KHTMLSettings::smoothScrolling
KSmoothScrollingMode smoothScrolling() const
Definition: khtml_settings.cpp:1139
KHTMLSettings::isAutoDelayedActionsEnabled
bool isAutoDelayedActionsEnabled() const
Definition: khtml_settings.cpp:1149
KHTMLPartPrivate::m_view
QPointer< KHTMLView > m_view
Definition: khtmlpart_p.h:227
KHTMLFind::findBar
KHTMLFindBar * findBar() const
Definition: khtmlfind_p.h:56
KHTMLTextExtension
Definition: khtml_ext.h:181
KHTMLPart::isModified
bool isModified() const
Checks whether the page contains unsubmitted form changes.
Definition: khtml_part.cpp:7341
KJob::suspend
bool suspend()
KHTMLRun
Definition: khtml_run.h:38
KXMLGUIClient::plugActionList
void plugActionList(const QString &name, const QList< QAction * > &actionList)
KHTMLPartPrivate::m_paViewFrame
KAction * m_paViewFrame
Definition: khtmlpart_p.h:318
KParts::BrowserArguments::docState
QStringList docState
lastRunAt
static bool lastRunAt(khtml::RenderObject *renderNode, int y, NodeImpl *&endNode, long &endOffset)
returns the position of the last inline text box of the line at coordinate y in renderNode ...
Definition: khtml_part.cpp:6168
KParts::OpenUrlArguments::setXOffset
void setXOffset(int x)
KHTMLPartPrivate::m_bPluginsForce
bool m_bPluginsForce
Definition: khtmlpart_p.h:263
KHTMLPartPrivate::m_jobspeed
unsigned long m_jobspeed
Definition: khtmlpart_p.h:284
KHTMLPart::setPageSecurity
void setPageSecurity(PageSecurity sec)
Definition: khtml_part.cpp:1653
KHTMLPartPrivate::m_encoding
QString m_encoding
Definition: khtmlpart_p.h:245
KPluginFactory
KXMLGUIClient::childClients
QList< KXMLGUIClient *> childClients()
KSslInfoDialog
khtml_iface.h
KHTMLPart::FormNotification
FormNotification
Definition: khtml_part.h:1106
fastZoomSizes
const int KDE_NO_EXPORT fastZoomSizes[]
KHTMLPartPrivate::m_haveEncoding
bool m_haveEncoding
Definition: khtmlpart_p.h:304
KHTMLPartPrivate::m_paDebugRenderTree
KAction * m_paDebugRenderTree
Definition: khtmlpart_p.h:338
KHTMLPart::setCaretVisible
void setCaretVisible(bool show)
Sets the visibility of the caret.
Definition: khtml_part.cpp:2949
khtml::ChildFrame::m_bPreloaded
bool m_bPreloaded
Definition: khtml_childframe_p.h:69
KHTMLPart::setMetaRefreshEnabled
void setMetaRefreshEnabled(bool enable)
Enable/disable automatic forwarding by <meta http-equiv="refresh" ....
Definition: khtml_part.cpp:1124
KParts::ScriptableExtension::adapterFromLiveConnect
static ScriptableExtension * adapterFromLiveConnect(QObject *parentObj, LiveConnectExtension *oldApi)
KHTMLSettings::showAnimations
KAnimationAdvice showAnimations() const
Definition: khtml_settings.cpp:1134
KParts::BrowserExtension::enableAction
void enableAction(const char *name, bool enabled)
KHTMLView::SSMWhenEfficient
Definition: khtmlview.h:305
KHTMLViewBar
Definition: khtmlviewbar.h:28
KParts::OpenUrlArguments::reload
bool reload() const
KHTMLPart::paint
void paint(QPainter *, const QRect &, int=0, bool *=0)
Paints the HTML page to a QPainter.
Definition: khtml_part.cpp:2190
KHTMLPart::framejScript
KJSProxy * framejScript(KParts::ReadOnlyPart *framePart)
Returns child frame framePart its script interpreter.
Definition: khtml_part.cpp:5333
KHTMLPartPrivate::m_metaRefreshEnabled
bool m_metaRefreshEnabled
Definition: khtmlpart_p.h:264
khtml::ChildFrame::m_name
QString m_name
Definition: khtml_childframe_p.h:62
KHTMLGlobal::registerPart
static void registerPart(KHTMLPart *part)
Definition: khtml_global.cpp:150
KHTMLPartPrivate::m_cachePolicy
KIO::CacheControl m_cachePolicy
Definition: khtmlpart_p.h:311
KPluginLoader
KEncodingDetector::EncodingFromHTTPHeader
EncodingFromHTTPHeader
KParts::StatusBarExtension::removeStatusBarItem
void removeStatusBarItem(QWidget *widget)
KUrl::ref
QString ref() const
khtml::ChildFrame::dumpFrameTree
static void dumpFrameTree(KHTMLPart *part)
Definition: khtml_childframe.cpp:83
KHTMLPart::startingJob
virtual void startingJob(KIO::Job *)
Hook for adding code before a job is started.
Definition: khtml_part.h:1404
KHTMLPartPrivate::m_bDNSPrefetch
KHTMLPart::DNSPrefetch m_bDNSPrefetch
Definition: khtmlpart_p.h:276
KHTMLPartPrivate::m_paFindAheadText
KAction * m_paFindAheadText
Definition: khtmlpart_p.h:332
KHTMLPartPrivate::m_paSaveFrame
KAction * m_paSaveFrame
Definition: khtmlpart_p.h:322
MimeImage
Definition: khtmlpart_p.h:87
KHTMLPart::PageSecurity
PageSecurity
Definition: khtml_part.h:1277
KHTMLPart::khtmlMousePressEvent
virtual void khtmlMousePressEvent(khtml::MousePressEvent *event)
Eventhandler of the khtml::MousePressEvent.
Definition: khtml_part.cpp:6292
KParts::ReadOnlyPart::canceled
void canceled(const QString &errMsg)
KHTMLPartPrivate::m_bJScriptOverride
bool m_bJScriptOverride
Definition: khtmlpart_p.h:260
KParts::LiveConnectExtension
kmenu.h
KHTMLPart::selectedTextAsHTML
QString selectedTextAsHTML() const
Return the text the user has marked.
Definition: khtml_part.cpp:3077
KHTMLPartPrivate::m_bCleared
bool m_bCleared
Definition: khtmlpart_p.h:380
KHTMLPartPrivate::m_bComplete
bool m_bComplete
Definition: khtmlpart_p.h:302
KIO::UDSEntry::numberValue
long long numberValue(uint field, long long defaultValue=0) const
KSSLCertificate::KSSLValidation
KSSLValidation
KHTMLPart::setURLCursor
void setURLCursor(const QCursor &c)
Sets the cursor to use when the cursor is on a link.
Definition: khtml_part.cpp:2780
KHTMLSettings::KDNSPrefetch
KDNSPrefetch
Definition: khtml_settings.h:66
KHTMLPart::metaRefreshEnabled
bool metaRefreshEnabled() const
Returns true if automatic forwarding is enabled.
KHTMLPart::frameNames
QStringList frameNames() const
Returns a list of names of all frame (including iframe) objects of the current document.
Definition: khtml_part.cpp:6030
KGuiItem
DOM::DOMString::isNull
bool isNull() const
Definition: dom_string.h:121
KAuthorized::authorizeUrlAction
bool authorizeUrlAction(const QString &action, const KUrl &baseUrl, const KUrl &destUrl)
KHTMLPart::Encrypted
Definition: khtml_part.h:1277
KHTMLPart::KHTMLPopupGUIClient
friend class KHTMLPopupGUIClient
Definition: khtml_part.h:250
KHTMLFrameList
Definition: khtml_childframe_p.h:81
KHTMLPart::setCaretPosition
void setCaretPosition(DOM::Node node, long offset, bool extendSelection=false)
Sets the caret to the given position.
Definition: khtml_part.cpp:2910
KHTMLHtmlExtension
Definition: khtml_ext.h:198
KHTMLPart::baseURL
KUrl baseURL() const
Definition: khtml_part.cpp:2510
KSSLSettings::setWarnOnUnencrypted
void setWarnOnUnencrypted(bool x)
KParts::BrowserExtension::childObject
static BrowserExtension * childObject(QObject *obj)
KHTMLPart::pluginsEnabled
bool pluginsEnabled() const
Returns true if plugins are enabled, false if disabled.
KSelectAction::setItems
void setItems(const QStringList &lst)
s_DOMTreeIndentLevel
static int s_DOMTreeIndentLevel
Definition: khtml_part.cpp:1393
KHTMLPart::~KHTMLPart
virtual ~KHTMLPart()
Destructor.
Definition: khtml_part.cpp:532
KMimeType::is
bool is(const QString &mimeTypeName) const
KLocale::formatDateTime
QString formatDateTime(const QDateTime &dateTime, DateFormat format=ShortDate, bool includeSecs=false) const
KHTMLPart::preloadScript
void preloadScript(const QString &url, const QString &script)
Loads a script into the script cache.
Definition: khtml_part.cpp:6970
KIO::ERR_IS_DIRECTORY
ERR_IS_DIRECTORY
KMessageBox::Notify
Notify
KJSErrorDlg
Definition: kjserrordlg.h:8
DOM::Range::handle
RangeImpl * handle() const
Definition: dom2_range.cpp:405
KStandardAction::SelectAll
SelectAll
KHTMLSettings::isOpenMiddleClickEnabled
bool isOpenMiddleClickEnabled()
Definition: khtml_settings.cpp:808
if
if(!yymsg) yymsg
khtml::EditorContext::m_caretBlinkTimer
int m_caretBlinkTimer
Definition: editing_p.h:46
KHTMLPartPrivate::m_ssl_cipher_used_bits
QString m_ssl_cipher_used_bits
Definition: khtmlpart_p.h:291
KHTMLPartPrivate::m_paFindAheadLinks
KAction * m_paFindAheadLinks
Definition: khtmlpart_p.h:333
KHTMLPartPrivate::m_bJScriptDebugEnabled
bool m_bJScriptDebugEnabled
Definition: khtmlpart_p.h:256
KHTMLPartPrivate::m_cacheId
qlonglong m_cacheId
Definition: khtmlpart_p.h:247
KUrl::CompareWithoutFragment
CompareWithoutFragment
kmimetypetrader.h
KFileItemList
KEncodingDetector::Greek
Greek
KUrl::setPass
void setPass(const QString &pass)
KIcon
KHTMLPartPrivate::m_delayRedirect
int m_delayRedirect
Definition: khtmlpart_p.h:314
KIO::HostInfo::setTTL
void setTTL(int ttl)
scriptableextension.h
KWallet::Wallet::Asynchronous
Asynchronous
clear
KAction * clear(const QObject *recvr, const char *slot, QObject *parent)
KHTMLPageCache::cancelFetch
void cancelFetch(QObject *recvObj)
Cancel sending data to recvObj.
Definition: khtml_pagecache.cpp:224
KHTMLPart::KHTMLPart
KHTMLPart(QWidget *parentWidget=0, QObject *parent=0, GUIProfile prof=DefaultGUI)
Constructs a new KHTMLPart.
Definition: khtml_part.cpp:181
KMimeTypeTrader::self
static KMimeTypeTrader * self()
KHTMLPartPrivate::m_statusBarText
QString m_statusBarText[3]
Definition: khtmlpart_p.h:283
DOM::Node::parentNode
Node parentNode() const
The parent of this node.
Definition: dom_node.cpp:199
DOM::DOMString
This class implements the basic string we use in the DOM.
Definition: dom_string.h:43
KHTMLPart::gotoAnchor
bool gotoAnchor(const QString &name)
Finds the anchor named name.
Definition: khtml_part.cpp:2704
KHTMLPart::FindLinksOnly
Definition: khtml_part.h:789
KHTMLPart::setJavaEnabled
void setJavaEnabled(bool enable)
Enables/disables Java applet support.
Definition: khtml_part.cpp:1359
KHTMLPart::partManager
KParts::PartManager * partManager()
Returns a reference to the partmanager instance which manages html frame objects. ...
Definition: khtml_part.cpp:4658
DOM::Document
The Document interface represents the entire HTML or XML document.
Definition: dom_doc.h:245
KJSErrorDlg::setURL
void setURL(const QString &url)
Definition: kjserrordlg.cpp:18
khtml::MouseDoubleClickEvent
Definition: khtml_events.h:79
KHTMLPart::doWriteStream
virtual bool doWriteStream(const QByteArray &data)
Implements the streaming API of KParts::ReadOnlyPart.
Definition: khtml_part.cpp:2177
KHTMLPart::begin
virtual void begin(const KUrl &url=KUrl(), int xOffset=0, int yOffset=0)
Clears the widget and prepares it for new content.
Definition: khtml_part.cpp:1989
KHTMLViewBar::Top
Definition: khtmlviewbar.h:33
KHTMLPart::findFrame
KHTMLPart * findFrame(const QString &f)
Finds a frame by name.
Definition: khtml_part.cpp:5280
KStandardAction::Find
Find
KLocalizedString::isEmpty
bool isEmpty() const
kactionmenu.h
dom_exception.h
KHTMLPartPrivate::m_designMode
bool m_designMode
Definition: khtmlpart_p.h:390
KHTMLPart::setFixedFont
void setFixedFont(const QString &name)
Sets the fixed font style.
Definition: khtml_part.cpp:2775
KStringHandler::csqueeze
QString csqueeze(const QString &str, int maxlen=40)
KParts::BrowserExtension::openUrlRequest
void openUrlRequest(const KUrl &url, const KParts::OpenUrlArguments &arguments=KParts::OpenUrlArguments(), const KParts::BrowserArguments &browserArguments=KParts::BrowserArguments())
KHTMLPart::frames
QList< KParts::ReadOnlyPart * > frames() const
Definition: khtml_part.cpp:6043
DOM::Node::nodeName
DOMString nodeName() const
The name of this node, depending on its type; see the table above.
Definition: dom_node.cpp:170
KHTMLPart::khtmlMouseMoveEvent
virtual void khtmlMouseMoveEvent(khtml::MouseMoveEvent *event)
Eventhandler for the khtml::MouseMouseMoveEvent.
Definition: khtml_part.cpp:6547
KHTMLPart::referrer
QString referrer() const
Referrer used for links in this page.
Definition: khtml_part.cpp:5940
fastZoomSizeCount
const int KDE_NO_EXPORT fastZoomSizeCount
kstandardaction.h
KHTMLSettings::KDNSPrefetchOnlyWWWAndSLD
Definition: khtml_settings.h:68
KCodecAction
KWallet::Wallet::FormDataFolder
static const QString FormDataFolder()
KStandardAction::FindNext
FindNext
KHTMLPartPrivate::m_bJScriptEnabled
bool m_bJScriptEnabled
Definition: khtmlpart_p.h:255
KHTMLPart::setFontScaleFactor
void setFontScaleFactor(int percent)
Sets the scale factor to be applied to fonts.
Definition: khtml_part.cpp:5860
KHTMLPart::openFile
virtual bool openFile()
Internal empty reimplementation of KParts::ReadOnlyPart::openFile .
Definition: khtml_part.cpp:1624
DOM::Node::attributes
NamedNodeMap attributes() const
A NamedNodeMap containing the attributes of this node (if it is an Element ) or null otherwise...
Definition: dom_node.cpp:235
KHTMLPart::write
virtual void write(const char *str, int len=-1)
Writes another part of the HTML code to the widget.
Definition: khtml_part.cpp:2085
KHTMLFindBar
Definition: khtmlfindbar.h:29
KEncodingDetector::encoding
const char * encoding() const
KHTMLPartPrivate::m_pageReferrer
QString m_pageReferrer
Definition: khtmlpart_p.h:353
KHTMLPartPrivate::m_ssl_cipher_bits
QString m_ssl_cipher_bits
Definition: khtmlpart_p.h:291
KHTMLPart::scheduleRedirection
void scheduleRedirection(int delay, const QString &url, bool lockHistory=true)
Schedules a redirection after delay seconds.
Definition: khtml_part.cpp:2556
KHTMLPart::updateZoomFactor
void updateZoomFactor()
Definition: khtml_part.cpp:5790
KHTMLPageCache::cancelEntry
void cancelEntry(long id)
Cancel the entry.
Definition: khtml_pagecache.cpp:180
reload
const KShortcut & reload()
KHTMLPartPrivate::m_objects
KHTMLFrameList m_objects
Definition: khtmlpart_p.h:225
DOM::NamedNodeMap::getNamedItem
Node getNamedItem(const DOMString &name) const
Retrieves a node specified by name.
Definition: dom_node.cpp:66
KHTMLPart::setActiveNode
void setActiveNode(const DOM::Node &node)
Sets the focused node of the document to the specified node.
Definition: khtml_part.cpp:6916
KParts::GUIActivateEvent
KHTMLPart::findTextNext
bool findTextNext(bool reverse=false)
Finds the next occurrence of a string set by findText()
Definition: khtml_part.cpp:3065
KHTMLPart::jsDefaultStatusBarText
QString jsDefaultStatusBarText() const
Called by KJS.
Definition: khtml_part.cpp:5935
KParts::BrowserExtension::infoMessage
void infoMessage(const QString &)
DOM::DOMString::string
QString string() const
Definition: dom_string.cpp:236
KHTMLPart::guiActivateEvent
virtual void guiActivateEvent(KParts::GUIActivateEvent *event)
Internal reimplementation of KParts::Part::guiActivateEvent .
Definition: khtml_part.cpp:6623
KHTMLPart::prevAnchor
bool prevAnchor()
Go to previous anchor.
Definition: khtml_part.cpp:2761
KParts::BrowserExtension::loadingProgress
void loadingProgress(int percent)
next
KAction * next(const QObject *recvr, const char *slot, QObject *parent)
KHTMLPart::selectedText
virtual QString selectedText() const
Returns the text the user has marked.
Definition: khtml_part.cpp:3095
KHTMLPart::activeNode
DOM::Node activeNode() const
Returns the node that has the keyboard focus.
Definition: khtml_part.cpp:6930
KJob::uiDelegate
KJobUiDelegate * uiDelegate() const
KHTMLPart::timerEvent
virtual void timerEvent(QTimerEvent *)
Definition: khtml_part.cpp:3434
KParts::OpenUrlArguments::yOffset
int yOffset() const
KHTMLPart::createPart
virtual KParts::ReadOnlyPart * createPart(QWidget *parentWidget, QObject *parent, const QString &mimetype, QString &serviceName, QStringList &serviceTypes, const QStringList &params)
This method is called when a new embedded object (include html frames) is to be created.
Definition: khtml_part.cpp:4605
KIO::UDSEntry::UDS_MODIFICATION_TIME
UDS_MODIFICATION_TIME
KHTMLPart::setPluginPageQuestionAsked
void setPluginPageQuestionAsked(const QString &mimetype)
Definition: khtml_part.cpp:6995
jobuidelegate.h
KParts::StatusBarExtension
KHTMLPartPrivate::m_bJScriptForce
bool m_bJScriptForce
Definition: khtmlpart_p.h:259
KHTMLPart::setFormNotification
void setFormNotification(FormNotification fn)
Determine if signal should be emitted before, instead or never when a submitForm() happens...
Definition: khtml_part.cpp:7321
KParts::BrowserExtension::ShowNavigationItems
ShowNavigationItems
KAction::setShortcut
void setShortcut(const KShortcut &shortcut, ShortcutTypes type=ShortcutTypes(ActiveShortcut|DefaultShortcut))
KJob::error
int error() const
MimeHTML
Definition: khtmlpart_p.h:83
KGlobalSettings::showIconsOnPushButtons
static bool showIconsOnPushButtons()
MimeSVG
Definition: khtmlpart_p.h:84
KHTMLPartPrivate::m_bPluginsEnabled
bool m_bPluginsEnabled
Definition: khtmlpart_p.h:258
KHTMLPart::documentSource
QString documentSource() const
Returns the content of the source document.
Definition: khtml_part.cpp:1013
KParts::BrowserHostExtension
khtml::ChildFrame::m_bNotify
bool m_bNotify
Definition: khtml_childframe_p.h:70
KHTMLPartPrivate::m_parsetime
QTime m_parsetime
Definition: khtmlpart_p.h:313
KHTMLPart::setStatusMessagesEnabled
void setStatusMessagesEnabled(bool enable)
Enable/disable statusbar messages.
Definition: khtml_part.cpp:1074
KHTMLPart::setStandardFont
void setStandardFont(const QString &name)
Sets the standard font style.
Definition: khtml_part.cpp:2770
KHTMLPartPrivate::m_frames
KHTMLFrameList m_frames
Definition: khtmlpart_p.h:224
KSSLSettings
KToolInvocation::startServiceByDesktopName
static int startServiceByDesktopName(const QString &_name, const QString &URL, QString *error=0, QString *serviceName=0, int *pid=0, const QByteArray &startup_id=QByteArray(), bool noWait=false)
KXMLGUIClient::factory
KXMLGUIFactory * factory() const
KHTMLPart::setSuppressedPopupIndicator
void setSuppressedPopupIndicator(bool enable, KHTMLPart *originPart=0)
Shows or hides the suppressed popup indicator.
Definition: khtml_part.cpp:7366
KParts::BrowserArguments::setForcesNewWindow
void setForcesNewWindow(bool forcesNewWindow)
KJob::resume
bool resume()
KHTMLPart::encoding
QString encoding() const
Returns the encoding the page currently uses.
khtml::MouseMoveEvent::test
static bool test(const QEvent *event)
Definition: khtml_events.h:109
KHTMLPartPrivate::m_ssl_cipher
QString m_ssl_cipher
Definition: khtmlpart_p.h:291
KHTMLPartPrivate::isJavaScriptURL
static bool isJavaScriptURL(const QString &url)
Definition: khtml_part.cpp:2549
KHTMLPartPrivate::m_bJavaOverride
bool m_bJavaOverride
Definition: khtmlpart_p.h:262
KParts::BrowserExtension::browserArguments
BrowserArguments browserArguments() const
KHTMLPart::findFrameParent
KHTMLPart * findFrameParent(KParts::ReadOnlyPart *callingPart, const QString &f, khtml::ChildFrame **childFrame=0)
Recursively finds the part containing the frame with name f and checks if it is accessible by calling...
Definition: khtml_part.cpp:5187
KHTMLPart::caretPositionChanged
void caretPositionChanged(const DOM::Node &node, long offset)
This signal is emitted whenever the caret position has been changed.
KHTMLPopupGUIClient::actionGroups
KParts::BrowserExtension::ActionGroupMap actionGroups() const
Definition: khtml_ext.cpp:688
KStandardGuiItem::close
KGuiItem close()
KHTMLPart::DefaultGUI
Definition: khtml_part.h:272
KUrl::protocol
QString protocol() const
KIO::http_update_cache
SimpleJob * http_update_cache(const KUrl &url, bool no_cache, time_t expireDate)
kstringhandler.h
KHTMLPart::autoloadImages
bool autoloadImages() const
Returns whether images contained in the document are loaded automatically or not. ...
Definition: khtml_part.cpp:1474
ok
KGuiItem ok()
KParts::Part::setWidget
virtual void setWidget(QWidget *widget)
KHTMLPart::formNotification
FormNotification formNotification() const
Determine if signal should be emitted before, instead or never when a submitForm() happens...
Definition: khtml_part.cpp:7325
KHTMLPart::backgroundURL
KUrl backgroundURL() const
Returns the URL for the background Image (used by save background)
Definition: khtml_part.cpp:3928
KIconLoader::SizeHuge
SizeHuge
KDE::lstat
int lstat(const QString &path, KDE_struct_stat *buf)
KParts::BrowserArguments::softReload
bool softReload
khtmlview.h
KParts::PartManager::addPart
virtual void addPart(Part *part, bool setActive=true)
KParts::StatusBarExtension::addStatusBarItem
void addStatusBarItem(QWidget *widget, int stretch, bool permanent)
khtml::ChildFrame::m_extension
QWeakPointer< KParts::BrowserExtension > m_extension
Definition: khtml_childframe_p.h:50
KHTMLSettings::isPluginsEnabled
bool isPluginsEnabled(const QString &hostname=QString()) const
Definition: khtml_settings.cpp:928
KHTMLPart::hasSelection
bool hasSelection() const
Has the user selected anything?
Definition: khtml_part.cpp:3253
khtml::ChildFrame::m_part
QPointer< KParts::ReadOnlyPart > m_part
Definition: khtml_childframe_p.h:56
KHTMLPart::openUrl
virtual bool openUrl(const KUrl &url)
Opens the specified URL url.
Definition: khtml_part.cpp:661
khtml::ChildFrame::m_scriptable
QWeakPointer< KParts::ScriptableExtension > m_scriptable
Definition: khtml_childframe_p.h:51
KHTMLPartPrivate::m_bDNSPrefetchIsDefault
bool m_bDNSPrefetchIsDefault
Definition: khtmlpart_p.h:271
KParts::HistoryProvider::insert
virtual void insert(const QString &item)
KGlobal::locale
KLocale * locale()
KParts::BrowserArguments::frameName
QString frameName
KEncodingDetector::SemiautomaticDetection
SemiautomaticDetection
KHTMLSettings::KSmoothScrollingDisabled
Definition: khtml_settings.h:61
KHTMLPart::preloadStyleSheet
void preloadStyleSheet(const QString &url, const QString &stylesheet)
Loads a style sheet into the stylesheet cache.
Definition: khtml_part.cpp:6965
job.h
KPluginLoader::factory
KPluginFactory * factory()
KHTMLSettings::KDNSPrefetchDisabled
Definition: khtml_settings.h:67
KHTMLPartPrivate::m_bLoadEventEmitted
bool m_bLoadEventEmitted
Definition: khtmlpart_p.h:303
DOM::EventListener
Introduced in DOM Level 2.
Definition: dom2_events.h:70
KEncodingDetector::WesternEuropean
WesternEuropean
KConfigGroup
KHTMLPartPrivate::m_redirectLockHistory
bool m_redirectLockHistory
Definition: khtmlpart_p.h:307
KHTMLPart::toplevelURL
KUrl toplevelURL()
Returns the toplevel (origin) URL of this document, even if this part is a frame or an iframe...
Definition: khtml_part.cpp:7329
KEncodingDetector::setEncoding
bool setEncoding(const char *encoding, EncodingChoiceSource type)
KParts::OpenUrlArguments::setReload
void setReload(bool b)
DOM
This library provides a full-featured HTML parser and widget.
Definition: design.h:54
KUrl::List
KHTMLPart::nonSharedNodeUnderMouse
DOM::Node nonSharedNodeUnderMouse() const
Returns the Node currently under the mouse that is not shared.
Definition: khtml_part.cpp:5694
KHTMLPart::submitFormProxy
void submitFormProxy(const char *action, const QString &url, const QByteArray &formData, const QString &target, const QString &contentType=QString(), const QString &boundary=QString())
Definition: khtml_part.cpp:4684
KHTMLPartPrivate::m_find
KHTMLFind m_find
Definition: khtmlpart_p.h:405
DOM::DOMString::isEmpty
bool isEmpty() const
Definition: dom_string.cpp:315
KParts::BrowserOpenOrSaveQuestion::Cancel
Cancel
DOM::Range::endOffset
long endOffset() const
Offset within the ending node of the range.
Definition: dom2_range.cpp:147
KParts::BrowserOpenOrSaveQuestion::askEmbedOrSave
Result askEmbedOrSave(int flags=0)
ktemporaryfile.h
KHTMLPartPrivate::m_bPluginsOverride
bool m_bPluginsOverride
Definition: khtmlpart_p.h:265
KHTMLPart::KHTMLPartPrivate
friend class KHTMLPartPrivate
Definition: khtml_part.h:1932
KParts::ReadOnlyPart::setArguments
void setArguments(const OpenUrlArguments &arguments)
maxZoom
static const int maxZoom
Definition: khtml_part.cpp:5720
KEncodingDetector::flush
QString flush()
KUrl::setFileName
void setFileName(const QString &_txt)
KHTMLPart::setJScriptEnabled
void setJScriptEnabled(bool enable)
Enable/disable Javascript support.
Definition: khtml_part.cpp:1093
dom_element.h
KHTMLPart::configurationChanged
void configurationChanged()
Emitted whenever the configuration has changed.
KHTMLSettings::isJavaScriptDebugEnabled
bool isJavaScriptDebugEnabled(const QString &hostname=QString()) const
Definition: khtml_settings.cpp:916
KRun::runUrl
static bool runUrl(const KUrl &url, const QString &mimetype, QWidget *window, bool tempFile=false, bool runExecutables=true, const QString &suggestedFileName=QString(), const QByteArray &asn=QByteArray())
KHTMLPart::setDNDEnabled
void setDNDEnabled(bool b)
Enables or disables Drag&#39;n&#39;Drop support.
Definition: khtml_part.cpp:6074
KHTMLPart::document
DOM::Document document() const
Returns a reference to the DOM document.
Definition: khtml_part.cpp:1008
KHTMLPartPrivate::m_numDNSPrefetchedNames
int m_numDNSPrefetchedNames
Definition: khtmlpart_p.h:274
KIO::CC_Cache
CC_Cache
KIO::http_post
TransferJob * http_post(const KUrl &url, const QByteArray &postData, JobFlags flags=DefaultFlags)
setCaretInvisibleIfNeeded
static void setCaretInvisibleIfNeeded(KHTMLPart *part)
Definition: khtml_part.cpp:2857
KHTMLPartPrivate::m_ssl_peer_chain
QString m_ssl_peer_chain
Definition: khtmlpart_p.h:291
KHTMLSettings::dnsPrefetch
KDNSPrefetch dnsPrefetch() const
Definition: khtml_settings.cpp:1144
KIO::CC_Refresh
CC_Refresh
KHTMLPart::setDNSPrefetch
void setDNSPrefetch(DNSPrefetch pmode)
Sets whether DNS Names found in loaded documents&#39;anchors should be pre-fetched (pre-resolved).
Definition: khtml_part.cpp:1111
KCodecAction::setCurrentAutoDetectScript
bool setCurrentAutoDetectScript(KEncodingDetector::AutoDetectScript)
KHTMLPartPrivate::m_frame
QPointer< khtml::ChildFrame > m_frame
Definition: khtmlpart_p.h:223
KParts::BrowserExtension::ShowReload
ShowReload
kjserrordlg.h
KParts::StatusBarExtension::statusBar
KStatusBar * statusBar() const
KHTMLPart::setAlwaysHonourDoctype
void setAlwaysHonourDoctype(bool b=true)
Sets whether the document&#39;s Doctype should always be used to determine the parsing mode for the docum...
Definition: khtml_part.cpp:2110
KParts::BrowserRun::AttachmentDisposition
AttachmentDisposition
KHTMLPart::khtmlMouseDoubleClickEvent
virtual void khtmlMouseDoubleClickEvent(khtml::MouseDoubleClickEvent *)
Eventhandler for the khtml::MouseDoubleClickEvent.
Definition: khtml_part.cpp:6338
KJobUiDelegate::showErrorMessage
virtual void showErrorMessage()
KHTMLPart::setCaretDisplayPolicyNonFocused
void setCaretDisplayPolicyNonFocused(CaretDisplayPolicy policy)
Sets the caret display policy when the view is not focused.
Definition: khtml_part.cpp:2939
KConfigGroup::readEntry
T readEntry(const QString &key, const T &aDefault) const
KHTMLPart::findText
void findText()
Starts a new search by popping up a dialog asking the user what he wants to search for...
Definition: khtml_part.cpp:3050
KHTMLPartPrivate::m_bFirstData
bool m_bFirstData
Definition: khtmlpart_p.h:377
KHTMLPartPrivate::m_paSaveDocument
KAction * m_paSaveDocument
Definition: khtmlpart_p.h:321
KHTMLPart::urlCursor
QCursor urlCursor() const
Returns the cursor which is used when the cursor is on a link.
Definition: khtml_part.cpp:2785
KParts::OpenUrlArguments::setMimeType
void setMimeType(const QString &mime)
KHTMLPartPrivate::m_job
KIO::TransferJob * m_job
Definition: khtmlpart_p.h:281
KHTMLPopupGUIClient
Definition: khtml_ext.h:116
KMimeType::defaultMimeType
static QString defaultMimeType()
KHTMLPart::DNSPrefetchDisabled
Definition: khtml_part.h:282
KHTMLFindBar::options
long options() const
Returns the state of the options.
Definition: khtmlfindbar.cpp:87
KJob::errorString
virtual QString errorString() const
DOM::Editor::closeTyping
void closeTyping()
Definition: editor.cpp:484
KMimeType::findByUrl
static Ptr findByUrl(const KUrl &url, mode_t mode=0, bool is_local_file=false, bool fast_mode=false, int *accuracy=0)
kstandarddirs.h
kselectaction.h
KParts::ScriptableExtension::setHost
void setHost(ScriptableExtension *host)
KIO::CC_Verify
CC_Verify
KHTMLPartPrivate::m_scriptableExtension
KJS::KHTMLPartScriptable * m_scriptableExtension
Definition: khtmlpart_p.h:233
KHTMLPartPrivate::isLocalAnchorJump
bool isLocalAnchorJump(const KUrl &url)
Definition: khtml_part.cpp:620
KHTMLPartPrivate::m_statusBarPopupLabel
KUrlLabel * m_statusBarPopupLabel
Definition: khtmlpart_p.h:238
KHTMLPageCache::createCacheEntry
long createCacheEntry()
Create a new cache entry.
Definition: khtml_pagecache.cpp:151
KParts::BrowserOpenOrSaveQuestion::Save
Save
sDNSCacheSize
static const int sDNSCacheSize
Definition: khtml_part.cpp:146
KAction::setHelpText
void setHelpText(const QString &text)
kurllabel.h
KIO::TransferJob::isErrorPage
bool isErrorPage() const
KParts::OpenUrlArguments::setYOffset
void setYOffset(int y)
KHTMLPart::end
virtual void end()
Call this after your last call to write().
Definition: khtml_part.cpp:2134
KAction
DOM::Range::startOffset
long startOffset() const
Offset within the starting node of the range.
Definition: dom2_range.cpp:124
zoomIn
KAction * zoomIn(const QObject *recvr, const char *slot, QObject *parent)
KHTMLPart::settings
const KHTMLSettings * settings() const
Definition: khtml_part.cpp:2504
KUrl::ObeyTrailingSlash
ObeyTrailingSlash
KHTMLPartPrivate::m_ssl_parent_ip
QString m_ssl_parent_ip
Definition: khtmlpart_p.h:291
KHTMLPartPrivate::m_httpHeaders
QString m_httpHeaders
Definition: khtmlpart_p.h:286
KHTMLPart::executeScript
QVariant executeScript(const DOM::Node &n, const QString &script)
Same as executeScript( const QString & ) except with the Node parameter specifying the &#39;this&#39; value...
Definition: khtml_part.cpp:1322
KHTMLPartPrivate::m_ssl_parent_cert
QString m_ssl_parent_cert
Definition: khtmlpart_p.h:291
KIO::Job
KParts::GUIActivateEvent::activated
bool activated() const
KEncodingDetector::CentralEuropean
CentralEuropean
KHTMLPart::statusMessagesEnabled
bool statusMessagesEnabled() const
Returns true if status messages are enabled.
Definition: khtml_part.cpp:1088
MimeText
Definition: khtmlpart_p.h:88
KEncodingDetector::Hebrew
Hebrew
KIO::NoReload
NoReload
KHTMLPartPrivate::m_paLoadImages
KAction * m_paLoadImages
Definition: khtmlpart_p.h:328
KUrl::queryItem
QString queryItem(const QString &item) const
KHTMLPart::closeUrl
virtual bool closeUrl()
Stops loading the document and kills all data requests (for images, etc.)
Definition: khtml_part.cpp:918
KHTMLPartPrivate::m_paDebugDOMTree
KAction * m_paDebugDOMTree
Definition: khtmlpart_p.h:337
KParts::BrowserRun::InlineDisposition
InlineDisposition
KUrlLabel::setUseCursor
void setUseCursor(bool on, QCursor *cursor=0L)
KHTMLPartPrivate::m_statusMessagesEnabled
bool m_statusMessagesEnabled
Definition: khtmlpart_p.h:268
SmallIcon
QPixmap SmallIcon(const QString &name, int force_size, int state, const QStringList &overlays)
DOM::Node::handle
NodeImpl * handle() const
Definition: dom_node.h:925
DOM::Node::nextSibling
Node nextSibling() const
The node immediately following this node.
Definition: dom_node.cpp:229
KHTMLPart::jScriptEnabled
bool jScriptEnabled() const
Returns true if Javascript support is enabled or false otherwise.
Definition: khtml_part.cpp:1102
KHTMLPart::jsStatusBarText
QString jsStatusBarText() const
Called by KJS.
Definition: khtml_part.cpp:5930
KIO::ERR_NO_CONTENT
ERR_NO_CONTENT
KHTMLPartPrivate::m_settings
KHTMLSettings * m_settings
Definition: khtmlpart_p.h:279
KHTMLPartPrivate::m_DNSPrefetchTimer
int m_DNSPrefetchTimer
Definition: khtmlpart_p.h:272
khtml::ChildFrame::m_jscript
KJSProxy * m_jscript
Definition: khtml_childframe_p.h:60
KWallet::Wallet::keyDoesNotExist
static bool keyDoesNotExist(const QString &wallet, const QString &folder, const QString &key)
KUrl::isLocalFile
bool isLocalFile() const
kwindowsystem.h
KParts::StatusBarExtension::childObject
static StatusBarExtension * childObject(QObject *obj)
KWallet::Wallet::NetworkWallet
static const QString NetworkWallet()
DOM::Node::firstChild
Node firstChild() const
The first child of this node.
Definition: dom_node.cpp:211
khtml::ChildFrame::m_partContainerElement
QWeakPointer< DOM::HTMLPartContainerElementImpl > m_partContainerElement
Definition: khtml_childframe_p.h:49
DOM::Node::isNull
bool isNull() const
tests if this Node is 0.
Definition: dom_node.h:920
KHTMLPart::onlyLocalReferences
bool onlyLocalReferences() const
Returns whether only file:/ or data:/ references are allowed to be loaded ( default false )...
Definition: khtml_part.cpp:2790
kWarning
static QDebug kWarning(bool cond, int area=KDE_DEFAULT_DEBUG_AREA)
KHTMLPartPrivate::m_runningScripts
int m_runningScripts
Definition: khtmlpart_p.h:253
KHTMLPart::setEditable
void setEditable(bool enable)
Makes the document editable.
Definition: khtml_part.cpp:2886
KHTMLSettings::isAdFiltered
bool isAdFiltered(const QString &url) const
tests whether url is filtered.
Definition: khtml_settings.cpp:833
DOM::Node::TEXT_NODE
Definition: dom_node.h:384
khtml::ChildFrame::m_type
Type m_type
Definition: khtml_childframe_p.h:67
kcodecaction.h
KUrl::hasRef
bool hasRef() const
KHTMLPart::setForcePermitLocalImages
void setForcePermitLocalImages(bool enable)
Security option.
Definition: khtml_part.cpp:2805
KHTMLSettings::KSmoothScrollingMode
KSmoothScrollingMode
Definition: khtml_settings.h:60
KHTMLPart::isEditable
bool isEditable() const
Returns true if the document is editable, false otherwise.
Definition: khtml_part.cpp:2901
KHTMLPart::mayPrefetchHostname
bool mayPrefetchHostname(const QString &name)
Will pre-resolve name according to dnsPrefetch current settings Returns true if the name will be pre-...
Definition: khtml_part.cpp:3457
KXMLGUIClient::actionCollection
virtual KActionCollection * actionCollection() const
KHTMLPartPrivate::m_ssl_peer_ip
QString m_ssl_peer_ip
Definition: khtmlpart_p.h:291
KParts::PartManager
ktoggleaction.h
KSSLSettings::warnOnUnencrypted
bool warnOnUnencrypted() const
KUrl::url
QString url(AdjustPathOption trailing=LeaveTrailingSlash) const
QPair
KHTMLPartPrivate::executeJavascriptURL
void executeJavascriptURL(const QString &u)
Definition: khtml_part.cpp:2535
KHTMLPart::setZoomFactor
void setZoomFactor(int percent)
Sets the Zoom factor.
Definition: khtml_part.cpp:5775
KHTMLPart::setAutoloadImages
void setAutoloadImages(bool enable)
Specifies whether images contained in the document should be loaded automatically or not...
Definition: khtml_part.cpp:1446
KToggleAction
KHTMLPart::show
void show()
Convenience method to show the document&#39;s view.
Definition: khtml_part.cpp:5677
KMimeType::mimeType
static Ptr mimeType(const QString &name, FindByNameOption options=ResolveAliases)
KHTMLPageCache::saveData
void saveData(long id, QDataStream *str)
Save the data of cache entry id to the datastream str.
Definition: khtml_pagecache.cpp:267
KLocale::LongDate
LongDate
KHTMLSettings::init
void init()
Called by constructor and reparseConfiguration.
Definition: khtml_settings.cpp:342
KHTMLPart::showError
virtual void showError(KJob *job)
Called when a certain error situation (i.e.
Definition: khtml_part.cpp:1786
KHTMLPart::jScriptInterpreter
KJS::Interpreter * jScriptInterpreter()
Returns the JavaScript interpreter the part is using.
Definition: khtml_part.cpp:1079
KParts::PartBase::setComponentData
virtual void setComponentData(const KComponentData &componentData)
KHTMLPartPrivate::m_bottomViewBar
QPointer< KHTMLViewBar > m_bottomViewBar
Definition: khtmlpart_p.h:229
KParts::BrowserArguments::setContentType
void setContentType(const QString &contentType)
DOM::Range
Definition: dom2_range.h:79
KHTMLPartPrivate::m_paFindPrev
KAction * m_paFindPrev
Definition: khtmlpart_p.h:331
sMaxDNSPrefetchPerPage
static const int sMaxDNSPrefetchPerPage
Definition: khtml_part.cpp:143
khtml::ChildFrame::m_bCompleted
bool m_bCompleted
Definition: khtml_childframe_p.h:61
KIO::ERR_UNKNOWN
ERR_UNKNOWN
ksslsettings.h
KHTMLPart::pageReferrer
QString pageReferrer() const
Referrer used to obtain this page.
Definition: khtml_part.cpp:5945
KHTMLWalletQueue
Definition: khtml_wallet_p.h:41
khtmlpart_p.h
KHTMLPart::popupMenu
void popupMenu(const QString &url, const QPoint &point)
Emitted when the user clicks the right mouse button on the document.
KConfigGroup::sync
void sync()
KUrl::query
QString query() const
KIO::rawErrorDetail
QByteArray rawErrorDetail(int errorCode, const QString &errorText, const KUrl *reqUrl=0L, int method=-1)
KHTMLPart::stopAnimations
void stopAnimations()
Stops all animated images on the current and child pages.
Definition: khtml_part.cpp:2196
KXMLGUIClient::insertChildClient
void insertChildClient(KXMLGUIClient *child)
KParts::BrowserExtension::pasteRequest
void pasteRequest()
KHTMLSettings::encoding
const QString & encoding() const
Definition: khtml_settings.cpp:1094
KParts::BrowserExtension::IsLink
IsLink
KParts::WindowArgs::setLowerWindow
void setLowerWindow(bool lower)
KIO::HostInfo::prefetchHost
void prefetchHost(const QString &hostName)
KHTMLPart::selectAll
void selectAll()
Marks all text in the document as selected.
Definition: khtml_part.cpp:6743
KIO::TransferJob
KJob::errorText
QString errorText() const
KHTMLView::SSMDisabled
Definition: khtmlview.h:305
KHTMLPart::nodeActivated
void nodeActivated(const DOM::Node &)
This signal is emitted when an element retrieves the keyboard focus.
KHTMLPartPrivate::propagateInitialDomainAndBaseTo
void propagateInitialDomainAndBaseTo(KHTMLPart *kid)
Definition: khtml_part.cpp:5058
KHTMLPartPrivate::m_lookedupHosts
QSet< QString > m_lookedupHosts
Definition: khtmlpart_p.h:420
KHTMLPart::CaretDisplayPolicy
CaretDisplayPolicy
Enumeration for displaying the caret.
Definition: khtml_part.h:586
KHTMLPart::doCloseStream
virtual bool doCloseStream()
Implements the streaming API of KParts::ReadOnlyPart.
Definition: khtml_part.cpp:2183
MimeOther
Definition: khtmlpart_p.h:89
KHTMLPartPrivate::m_paViewInfo
KAction * m_paViewInfo
Definition: khtmlpart_p.h:319
khtml::ChildFrame::Type
Type
Definition: khtml_childframe_p.h:44
khtml::MousePressEvent::test
static bool test(const QEvent *event)
Definition: khtml_events.h:72
kicon.h
KParts::BrowserExtension::setLocationBarUrl
void setLocationBarUrl(const QString &url)
KProtocolManager::cacheControl
static KIO::CacheControl cacheControl()
WebCore::String
DOM::DOMString String
Definition: PlatformString.h:8
KHTMLPartPrivate::m_restoreScrollPosition
bool m_restoreScrollPosition
Definition: khtmlpart_p.h:267
hostinfo_p.h
DOM::Editor::clearTypingStyle
void clearTypingStyle()
Clears the typing style for the document.
Definition: editor.cpp:479
kmessagebox.h
KHTMLPartPrivate::m_lastModified
QString m_lastModified
Definition: khtmlpart_p.h:285
KMessageBox::Dangerous
Dangerous
KHTMLPartPrivate::m_progressUpdateTimer
QTimer m_progressUpdateTimer
Definition: khtmlpart_p.h:401
KIO::convertSize
QString convertSize(KIO::filesize_t size)
KHTMLPartPrivate::m_pageServices
QString m_pageServices
Definition: khtmlpart_p.h:287
KParts::BrowserExtension::setPageSecurity
void setPageSecurity(int)
KIO::Job::ui
JobUiDelegate * ui() const
KParts
KIO::NetAccess::download
static bool download(const KUrl &src, QString &target, QWidget *window)
QEvent
KHTMLPartPrivate::m_mousePressNode
DOM::Node m_mousePressNode
Definition: khtmlpart_p.h:369
KHTMLPartPrivate::m_referrer
QString m_referrer
Definition: khtmlpart_p.h:352
KHTMLPart::htmlError
void htmlError(int errorCode, const QString &text, const KUrl &reqUrl)
presents a detailed error message to the user.
Definition: khtml_part.cpp:1803
KUrl::htmlRef
QString htmlRef() const
QFrame
KHTMLGlobal::vLinks
static KParts::HistoryProvider * vLinks()
Definition: khtml_global.h:69
khtml_settings.h
KHTMLPageCache::addData
void addData(long id, const QByteArray &data)
Add data to the cache entry with id id.
Definition: khtml_pagecache.cpp:163
KHTMLPart::forcePermitLocalImages
bool forcePermitLocalImages() const
If true, local image files will be loaded even when forbidden by the Kiosk/KAuthorized policies ( def...
Definition: khtml_part.cpp:2800
MimeXML
Definition: khtmlpart_p.h:86
KEncodingDetector::None
None
khtml::MouseReleaseEvent::test
static bool test(const QEvent *event)
Definition: khtml_events.h:124
KParts::LiveConnectExtension::childObject
static LiveConnectExtension * childObject(QObject *obj)
KHTMLPartPrivate::m_restored
bool m_restored
Definition: khtmlpart_p.h:266
KUrl::fileName
QString fileName(const DirectoryOptions &options=IgnoreTrailingSlash) const
KSslInfoDialog::setSslInfo
void setSslInfo(const QList< QSslCertificate > &certificateChain, const QString &ip, const QString &host, const QString &sslProtocol, const QString &cipher, int usedBits, int bits, const QList< QList< KSslError::Error > > &validationErrors)
KGlobalSettings::dndEventDelay
static int dndEventDelay()
KUrl::encodedHtmlRef
QString encodedHtmlRef() const
KHTMLPart::setJSDefaultStatusBarText
void setJSDefaultStatusBarText(const QString &text)
Called by KJS.
Definition: khtml_part.cpp:5925
KIO::HostInfo::setCacheSize
void setCacheSize(int s)
KHTMLPart::selection
DOM::Range selection() const
Returns the selected part of the HTML.
Definition: khtml_part.cpp:3258
KUrl::AllowEmptyPath
AllowEmptyPath
KLocalizedString::toString
QString toString() const
KUrlLabel
KHTMLPartPrivate::m_paDebugScript
KAction * m_paDebugScript
Definition: khtmlpart_p.h:336
MimeType
MimeType
Definition: khtmlpart_p.h:82
KHTMLPartPrivate::m_bMousePressed
bool m_bMousePressed
Definition: khtmlpart_p.h:367
khtml::ChildFrame::m_serviceName
QString m_serviceName
Definition: khtml_childframe_p.h:58
KHTMLPart::KHTMLRun
friend class KHTMLRun
Definition: khtml_part.h:219
KHTMLPart::NotCrypted
Definition: khtml_part.h:1277
KMessageBox::warningContinueCancel
static int warningContinueCancel(QWidget *parent, const QString &text, const QString &caption=QString(), const KGuiItem &buttonContinue=KStandardGuiItem::cont(), const KGuiItem &buttonCancel=KStandardGuiItem::cancel(), const QString &dontAskAgainName=QString(), Options options=Notify)
KJob
kFatal
static QDebug kFatal(bool cond, int area=KDE_DEFAULT_DEBUG_AREA)
KLocalizedString
KAcceleratorManager::manage
static void manage(QWidget *widget, bool programmers_mode=false)
KEncodingDetector::Turkish
Turkish
KToolInvocation::kdeinitExec
static int kdeinitExec(const QString &name, const QStringList &args=QStringList(), QString *error=0, int *pid=0, const QByteArray &startup_id=QByteArray())
KSSLSettings::save
void save()
KXMLGUIClient::unplugActionList
void unplugActionList(const QString &name)
kfileitem.h
KUrl::join
static KUrl join(const List &_list)
KHTMLPartPrivate::renameFrameForContainer
void renameFrameForContainer(DOM::HTMLPartContainerElementImpl *cont, const QString &newName)
Definition: khtml_part.cpp:5323
KUrl::path
QString path(AdjustPathOption trailing=LeaveTrailingSlash) const
QAction
KParts::BrowserArguments::postData
QByteArray postData
zoomSizes
static const int zoomSizes[]
Definition: khtml_part.cpp:5717
KHTMLPartPrivate::m_loadedObjects
unsigned long m_loadedObjects
Definition: khtmlpart_p.h:396
DOM::Node::elementId
quint32 elementId() const
Definition: dom_node.cpp:400
KParts::WindowArgs
KMessageBox::error
static void error(QWidget *parent, const QString &text, const QString &caption=QString(), Options options=Notify)
QMap< QString, QString >
khtml::DrawContentsEvent
Definition: khtml_events.h:130
KFileItem
KParts::StatusBarExtension::setStatusBar
void setStatusBar(KStatusBar *status)
kconfiggroup.h
KHTMLPageCache::endData
void endData(long id)
Signal end of data for the cache entry with id id.
Definition: khtml_pagecache.cpp:172
KHTMLPart::parentPart
KHTMLPart * parentPart()
Returns a pointer to the parent KHTMLPart if the part is a frame in an HTML frameset.
Definition: khtml_part.cpp:5353
KParts::OpenUrlArguments
KHTMLPartPrivate::m_bRightMousePressed
bool m_bRightMousePressed
Definition: khtmlpart_p.h:368
KHTMLPartPrivate::m_ssl_protocol_version
QString m_ssl_protocol_version
Definition: khtmlpart_p.h:291
KHTMLPartPrivate::m_paSelectAll
KAction * m_paSelectAll
Definition: khtmlpart_p.h:335
KParts::ReadOnlyPart::arguments
OpenUrlArguments arguments() const
KEncodingDetector::UserChosenEncoding
UserChosenEncoding
QList
DOM::Node::nodeType
unsigned short nodeType() const
A code representing the type of the underlying object, as defined above.
Definition: dom_node.cpp:193
KHTMLPart::DNSPrefetch
DNSPrefetch
DNS Prefetching Mode enumeration.
Definition: khtml_part.h:281
KParts::ReadOnlyPart
KHTMLPartPrivate::m_bJavaForce
bool m_bJavaForce
Definition: khtmlpart_p.h:261
khtml::ChildFrame::Object
Definition: khtml_childframe_p.h:44
DOM::Node::nodeValue
DOMString nodeValue() const
The value of this node, depending on its type; see the table above.
Definition: dom_node.cpp:176
KParts::BrowserExtension::ShowTextSelectionItems
ShowTextSelectionItems
KHTMLSettings::autoLoadImages
bool autoLoadImages() const
Definition: khtml_settings.cpp:1124
KParts::BrowserArguments::lockHistory
bool lockHistory() const
This file is part of the KDE documentation.
Documentation copyright © 1996-2018 The KDE developers.
Generated on Fri Oct 19 2018 17:21:56 by doxygen 1.8.13 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

KHTML

Skip menu "KHTML"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members
  • Related Pages

kdelibs-4.14.3 API Reference

Skip menu "kdelibs-4.14.3 API Reference"
  • DNSSD
  • Interfaces
  •   KHexEdit
  •   KMediaPlayer
  •   KSpeech
  •   KTextEditor
  • kconf_update
  • KDE3Support
  •   KUnitTest
  • KDECore
  • KDED
  • KDEsu
  • KDEUI
  • KDEWebKit
  • KDocTools
  • KFile
  • KHTML
  • KImgIO
  • KInit
  • kio
  • KIOSlave
  • KJS
  •   KJS-API
  •   WTF
  • kjsembed
  • KNewStuff
  • KParts
  • KPty
  • Kross
  • KUnitConversion
  • KUtils
  • Nepomuk
  • Plasma
  • Solid
  • Sonnet
  • ThreadWeaver
Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal