bool KWebKitPart::openUrl(const QUrl &_u)
{
QUrl u (_u);
kDebug() << u;
// Ignore empty requests...
if (u.isEmpty())
return false;
// If the URL given is a supported local protocol, e.g. "bookmark" but lacks
// a path component, we set the path to "/" here so that the security context
// will properly allow access to local resources.
if (u.host().isEmpty() && u.path().isEmpty()
&& KProtocolInfo::protocolClass(u.scheme()) == QL1S(":local")) {
u.setPath(QL1S("/"));
}
// Do not emit update history when url is typed in since the embedding part
// should handle that automatically itself. At least Konqueror does that.
m_emitOpenUrlNotify = false;
// Pointer to the page object...
WebPage* p = page();
Q_ASSERT(p);
// Handle error conditions...
if (u.scheme() == QL1S("error")) {
/**
* The format of the error url is that two variables are passed in the query:
* error = int kio error code, errText = QString error text from kio
* and the URL where the error happened is passed as a sub URL.
*/
const QUrl mainUrl(u.fragment());
if (mainUrl.isValid()) {
QString query = u.query(QUrl::FullyDecoded);
QRegularExpression pattern("error=(\\d+)&errText=(.*)");
QRegularExpressionMatch match = pattern.match(query);
int error = match.captured(1).toInt();
// error=0 isn't a valid error code, so 0 means it's missing from the URL
if (error == 0) {
error = KIO::ERR_UNKNOWN;
}
const QString errorText = match.captured(2);
emit m_browserExtension->setLocationBarUrl(mainUrl.toDisplayString());
if (p) {
m_webView->setHtml(p->errorPage(error, errorText, mainUrl));
return true;
}
}
return false;
}
KParts::BrowserArguments bargs (m_browserExtension->browserArguments());
KParts::OpenUrlArguments args (arguments());
if (u != *globalBlankUrl) {
// Get the SSL information sent, if any...
if (args.metaData().contains(QL1S("ssl_in_use"))) {
WebSslInfo sslInfo;
sslInfo.restoreFrom(KIO::MetaData(args.metaData()).toVariant());
sslInfo.setUrl(u);
p->setSslInfo(sslInfo);
}
}
// Set URL in KParts before emitting started; konq plugins rely on that.
setUrl(u);
m_doLoadFinishedActions = true;
m_webView->loadUrl(u, args, bargs);
return true;
}
void KonqView::openUrl( const KUrl &url, const QString & locationBarURL,
const QString & nameFilter, bool tempFile )
{
kDebug() << "url=" << url << "locationBarURL=" << locationBarURL;
setPartMimeType();
KParts::OpenUrlArguments args;
if ( m_pPart )
args = m_pPart->arguments();
KParts::BrowserExtension *ext = browserExtension();
KParts::BrowserArguments browserArgs;
if ( ext )
browserArgs = ext->browserArguments();
// Typing "Enter" again after the URL of an aborted view, triggers a reload.
if ( m_bAborted && m_pPart && m_pPart->url() == url && !browserArgs.doPost())
{
if ( !prepareReload( args, browserArgs, false /* not softReload */ ) )
return;
m_pPart->setArguments( args );
}
#ifdef DEBUG_HISTORY
kDebug() << "m_bLockedLocation=" << m_bLockedLocation << "browserArgs.lockHistory()=" << browserArgs.lockHistory();
#endif
if ( browserArgs.lockHistory() )
lockHistory();
if ( !m_bLockHistory )
{
// Store this new URL in the history, removing any existing forward history.
// We do this first so that everything is ready if a part calls completed().
createHistoryEntry();
} else
m_bLockHistory = false;
if ( m_pPart )
m_pPart->setProperty("nameFilter", nameFilter);
if ( m_bDisableScrolling )
callExtensionMethod( "disableScrolling" );
// Set location-bar URL, except for error urls, where we know the browser component
// will set back the url with the error anyway.
if (url.protocol() != "error")
setLocationBarURL(locationBarURL);
setPageSecurity(KonqMainWindow::NotCrypted);
if ( !args.reload() )
{
// Save the POST data that is necessary to open this URL
// (so that reload can re-post it)
m_doPost = browserArgs.doPost();
m_postContentType = browserArgs.contentType();
m_postData = browserArgs.postData;
// Save the referrer
m_pageReferrer = args.metaData()["referrer"];
}
if ( tempFile ) {
// Store the path to the tempfile. Yes, we could store a bool only,
// but this would be more dangerous. If anything goes wrong in the code,
// we might end up deleting a real file.
if ( url.isLocalFile() )
m_tempFile = url.toLocalFile();
else
kWarning() << "Tempfile option is set, but URL is remote:" << url ;
}
aboutToOpenURL( url, args );
m_pPart->openUrl( url );
updateHistoryEntry(false /* don't save location bar URL yet */);
// add pending history entry
KonqHistoryManager::kself()->addPending( url, locationBarURL, QString());
#ifdef DEBUG_HISTORY
kDebug() << "Current position:" << historyIndex();
#endif
}
QObject* KWebPluginFactory::create(const QString& _mimeType, const QUrl& url, const QStringList& argumentNames, const QStringList& argumentValues) const
{
// Only attempt to find a KPart for the supported mime types...
QVariantList arguments;
const int count = argumentNames.count();
for (int i = 0; i < count; ++i) {
arguments << QString(argumentNames.at(i) + QL1S("=\"") + argumentValues.at(i) + QL1C('\"'));
}
QString mimeType (_mimeType.trimmed());
// If no mimetype is provided, we do our best to correctly determine it here...
if (mimeType.isEmpty()) {
kDebug(800) << "Looking up missing mimetype for plugin resource:" << url;
const KUrl reqUrl (url);
KMimeType::Ptr ptr = KMimeType::findByUrl(reqUrl, 0, reqUrl.isLocalFile());
if (ptr->isDefault())
mimeType = ptr->name();
// Disregard inode/* mime-types...
if (mimeType.startsWith(QLatin1String("inode/"), Qt::CaseInsensitive))
mimeType.clear();
kDebug(800) << "Updated mimetype to" << mimeType;
}
KParts::ReadOnlyPart* part = 0;
// Defer handling of flash content to QtWebKit's builtin viewer.
// If you want to use/test KDE's nspluginviewer, comment out the
// if statement below.
if (!mimeType.isEmpty() && !excludedMimeType(mimeType))
part = KMimeTypeTrader::createPartInstanceFromQuery<KParts::ReadOnlyPart>(mimeType, 0, parent(), QString(), arguments);
kDebug(800) << "Asked for" << mimeType << "plugin, got" << part;
if (part) {
QMap<QString, QString> metaData = part->arguments().metaData();
QString urlStr = url.toString(QUrl::RemovePath | QUrl::RemoveQuery | QUrl::RemoveFragment);
metaData.insert("PropagateHttpHeader", "true");
metaData.insert("referrer", urlStr);
metaData.insert("cross-domain", urlStr);
metaData.insert("main_frame_request", "TRUE");
metaData.insert("ssl_activate_warnings", "TRUE");
KWebPage *page = qobject_cast<KWebPage *>(parent());
if (page) {
const QString scheme = page->mainFrame()->url().scheme();
if (page && (QString::compare(scheme, QL1S("https"), Qt::CaseInsensitive) == 0 ||
QString::compare(scheme, QL1S("webdavs"), Qt::CaseInsensitive) == 0))
metaData.insert("ssl_was_in_use", "TRUE");
else
metaData.insert("ssl_was_in_use", "FALSE");
}
KParts::OpenUrlArguments openUrlArgs = part->arguments();
openUrlArgs.metaData() = metaData;
openUrlArgs.setMimeType(mimeType);
part->setArguments(openUrlArgs);
part->openUrl(url);
return part->widget();
}
return 0;
}
QObject* WebPluginFactory::create (const QString& _mimeType, const QUrl& url, const QStringList& argumentNames, const QStringList& argumentValues) const
{
//kDebug() << _mimeType << url << argumentNames;
QString mimeType (_mimeType.trimmed());
if (mimeType.isEmpty()) {
extractGuessedMimeType (url, &mimeType);
}
const bool noPluginHandling = WebKitSettings::self()->isInternalPluginHandlingDisabled();
if (!noPluginHandling && WebKitSettings::self()->isLoadPluginsOnDemandEnabled()) {
const uint id = pluginId(url, argumentNames, argumentValues);
if (!mPluginsLoadedOnDemand.contains(id)) {
FakePluginWidget* widget = new FakePluginWidget(id, url, mimeType);
connect(widget, SIGNAL(pluginLoaded(uint)), this, SLOT(loadedPlugin(uint)));
return widget;
}
}
Q_ASSERT(mPart); // should never happen!!
KParts::ReadOnlyPart* part = 0;
QWebView* view = (mPart ? mPart->view() : 0);
if (noPluginHandling || !excludedMimeType(mimeType)) {
QWebFrame* frame = (view ? view->page()->currentFrame() : 0);
if (frame) {
part = createPartInstanceFrom(mimeType, argumentNames, argumentValues, view, frame);
}
}
kDebug() << "Asked for" << mimeType << "plugin, got" << part;
if (part) {
connect (part->browserExtension(), SIGNAL (openUrlNotify()),
mPart->browserExtension(), SIGNAL (openUrlNotify()));
connect (part->browserExtension(), SIGNAL (openUrlRequest (KUrl, KParts::OpenUrlArguments, KParts::BrowserArguments)),
mPart->browserExtension(), SIGNAL (openUrlRequest (KUrl, KParts::OpenUrlArguments, KParts::BrowserArguments)));
// Check if this part is scriptable
KParts::ScriptableExtension* scriptExt = KParts::ScriptableExtension::childObject(part);
if (!scriptExt) {
// Try to fall back to LiveConnectExtension compat
KParts::LiveConnectExtension* lc = KParts::LiveConnectExtension::childObject(part);
if (lc) {
scriptExt = KParts::ScriptableExtension::adapterFromLiveConnect(part, lc);
}
}
if (scriptExt) {
scriptExt->setHost(KParts::ScriptableExtension::childObject(mPart));
}
QMap<QString, QString> metaData = part->arguments().metaData();
QString urlStr = url.toString (QUrl::RemovePath | QUrl::RemoveQuery | QUrl::RemoveFragment);
metaData.insert ("PropagateHttpHeader", "true");
metaData.insert ("referrer", urlStr);
metaData.insert ("cross-domain", urlStr);
metaData.insert ("main_frame_request", "TRUE");
metaData.insert ("ssl_activate_warnings", "TRUE");
KWebPage *page = (view ? qobject_cast<KWebPage*>(view->page()) : 0);
if (page) {
const QString scheme = page->currentFrame()->url().scheme();
if (page && (QString::compare (scheme, QL1S ("https"), Qt::CaseInsensitive) == 0 ||
QString::compare (scheme, QL1S ("webdavs"), Qt::CaseInsensitive) == 0))
metaData.insert ("ssl_was_in_use", "TRUE");
else
metaData.insert ("ssl_was_in_use", "FALSE");
}
KParts::OpenUrlArguments openUrlArgs = part->arguments();
openUrlArgs.metaData() = metaData;
openUrlArgs.setMimeType(mimeType);
part->setArguments(openUrlArgs);
QMetaObject::invokeMethod(part, "openUrl", Qt::QueuedConnection, Q_ARG(KUrl, KUrl(url)));
return part->widget();
}
return 0;
}