void KonqSidebarBookmarkModule::slotOpenTab()
{
KonqSidebarBookmarkItem *bi = dynamic_cast<KonqSidebarBookmarkItem*>( tree()->selectedItem() );
KBookmark bookmark;
if (bi)
{
bookmark = bi->bookmark();
}
else if(tree()->selectedItem() == m_topLevelItem)
bookmark = s_bookmarkManager->root();
else
return;
KParts::OpenUrlArguments args;
args.setActionRequestedByUser(true);
KParts::BrowserArguments browserArguments;
browserArguments.setNewTab(true);
if (bookmark.isGroup()) {
KBookmarkGroup group = bookmark.toGroup();
bookmark = group.first();
while (!bookmark.isNull()) {
if (!bookmark.isGroup() && !bookmark.isSeparator()) {
emit tree()->createNewWindow(bookmark.url(),
args,
browserArguments);
}
bookmark = group.next(bookmark);
}
} else {
emit tree()->createNewWindow(bookmark.url(),
args,
browserArguments);
}
}
void TestKHTML::reload()
{
KParts::OpenUrlArguments args;
args.setReload( true );
m_part->setArguments( args );
m_part->openUrl( m_part->url() );
}
void KHTMLImage::slotPopupMenu( const QPoint &global, const KUrl &url, mode_t mode,
const KParts::OpenUrlArguments &origArgs,
const KParts::BrowserArguments &browserArgs,
KParts::BrowserExtension::PopupFlags flags,
const KParts::BrowserExtension::ActionGroupMap& actionGroups )
{
KParts::OpenUrlArguments args = origArgs;
args.setMimeType(m_mimeType);
m_ext->popupMenu(global, url, mode, args, browserArgs, flags, actionGroups);
}
void KonqSidebarBookmarkModule::slotOpenNewWindow()
{
KonqSidebarBookmarkItem *bi = dynamic_cast<KonqSidebarBookmarkItem*>( tree()->selectedItem() );
if (!bi)
return;
KParts::OpenUrlArguments args;
args.setActionRequestedByUser(true);
KParts::BrowserArguments browserArgs;
browserArgs.setForcesNewWindow(true);
emit tree()->createNewWindow(bi->bookmark().url(), args, browserArgs);
}
KTextEditor::Document* PartController::createTextPart(const QString &encoding)
{
KTextEditor::Document* doc = editorPart()->createDocument(this);
if ( !encoding.isNull() )
{
KParts::OpenUrlArguments args = doc->arguments();
args.setMimeType( QString::fromLatin1( "text/plain;" ) + encoding );
doc->setArguments( args );
}
doc->editor()->readConfig();
return doc;
}
bool KHTMLImage::openUrl( const KUrl &url )
{
static const QString &html = KGlobal::staticQString( "<html><body><img src=\"%1\"></body></html>" );
// Propagate statusbar to our kid part.
KParts::StatusBarExtension::childObject( m_khtml )->setStatusBar( m_sbExt->statusBar() );
disposeImage();
setUrl(url);
emit started( 0 );
KParts::OpenUrlArguments args = arguments();
m_mimeType = args.mimeType();
emit setWindowCaption( url.prettyUrl() );
// Need to keep a copy of the offsets since they are cleared when emitting completed
m_xOffset = args.xOffset();
m_yOffset = args.yOffset();
m_khtml->begin( this->url() );
m_khtml->setAutoloadImages( true );
DOM::DocumentImpl *impl = dynamic_cast<DOM::DocumentImpl *>( m_khtml->document().handle() ); // ### hack ;-)
if (!impl) return false;
if ( arguments().reload() )
impl->docLoader()->setCachePolicy( KIO::CC_Reload );
khtml::DocLoader *dl = impl->docLoader();
m_image = dl->requestImage( this->url().url() );
if ( m_image )
m_image->ref( this );
m_khtml->write( html.arg( this->url().url() ) );
m_khtml->end();
/*
connect( khtml::Cache::loader(), SIGNAL(requestDone(khtml::DocLoader*,khtml::CachedObject*)),
this, SLOT(updateWindowCaption()) );
*/
return true;
}
void KonqSidebarTree::slotExecuted( Q3ListViewItem *item )
{
kDebug(1201) << item;
if ( !item )
return;
if ( !static_cast<KonqSidebarTreeItem*>(item)->isClickable() )
return;
KonqSidebarTreeItem *dItem = static_cast<KonqSidebarTreeItem *>( item );
KParts::OpenUrlArguments args;
args.setMimeType(dItem->externalMimeType());
KParts::BrowserArguments browserArgs;
browserArgs.trustedSource = true; // is this needed?
KUrl externalURL = dItem->externalURL();
if ( !externalURL.isEmpty() )
openUrlRequest( externalURL, args, browserArgs );
}
void WebView::loadUrl(const QUrl& url, const KParts::OpenUrlArguments& args, const KParts::BrowserArguments& bargs)
{
page()->setProperty("NavigationTypeUrlEntered", true);
if (args.reload() && url == this->url()) {
reload();
return;
}
QNetworkRequest request(url);
if (args.reload()) {
request.setAttribute(QNetworkRequest::CacheLoadControlAttribute, QNetworkRequest::AlwaysNetwork);
}
if (bargs.postData.isEmpty()) {
KWebView::load(request);
} else {
KWebView::load(request, QNetworkAccessManager::PostOperation, bargs.postData);
}
}
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;
}
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;
}
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
}
void WebView::contextMenuEvent(QContextMenuEvent* e)
{
m_result = page()->mainFrame()->hitTestContent(e->pos());
// Clear the previous collection entries first...
m_actionCollection->clear();
KParts::BrowserExtension::PopupFlags flags = KParts::BrowserExtension::DefaultPopupItems;
KParts::BrowserExtension::ActionGroupMap mapAction;
QString mimeType (QL1S("text/html"));
bool forcesNewWindow = false;
QUrl emitUrl;
if (m_result.isContentEditable()) {
if (m_result.element().hasAttribute(QL1S("disabled"))) {
e->accept();
return;
}
flags |= KParts::BrowserExtension::ShowTextSelectionItems;
editableContentActionPopupMenu(mapAction);
} else if (isMultimediaElement(m_result.element())) {
multimediaActionPopupMenu(mapAction);
} else if (!m_result.linkUrl().isValid()) {
if (m_result.imageUrl().isValid()) {
emitUrl = m_result.imageUrl();
extractMimeTypeFor(emitUrl, mimeType);
} else {
flags |= KParts::BrowserExtension::ShowBookmark;
flags |= KParts::BrowserExtension::ShowReload;
emitUrl = m_part->url();
if (m_result.isContentSelected()) {
flags |= KParts::BrowserExtension::ShowTextSelectionItems;
selectActionPopupMenu(mapAction);
} else {
flags |= KParts::BrowserExtension::ShowNavigationItems;
}
}
partActionPopupMenu(mapAction);
} else {
flags |= KParts::BrowserExtension::ShowBookmark;
flags |= KParts::BrowserExtension::ShowReload;
flags |= KParts::BrowserExtension::IsLink;
emitUrl = m_result.linkUrl();
linkActionPopupMenu(mapAction);
if (emitUrl.isLocalFile())
mimeType = KMimeType::findByUrl(emitUrl, 0, true, false)->name();
else
extractMimeTypeFor(emitUrl, mimeType);
partActionPopupMenu(mapAction);
// Show the OpenInThisWindow context menu item
forcesNewWindow = (page()->currentFrame() != m_result.linkTargetFrame());
}
if (!mapAction.isEmpty()) {
KParts::OpenUrlArguments args;
KParts::BrowserArguments bargs;
args.setMimeType(mimeType);
bargs.setForcesNewWindow(forcesNewWindow);
e->accept();
emit m_part->browserExtension()->popupMenu(e->globalPos(), emitUrl, static_cast<mode_t>(-1), args, bargs, flags, mapAction);
return;
}
KWebView::contextMenuEvent(e);
}
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;
}