void IconView::contextMenuEvent( QContextMenuEvent* event )
{
QModelIndex index = indexAt( event->pos() );
if ( !index.isValid() || m_selectionModel->selectedIndexes().isEmpty() ) {
QMenu* menu = new QMenu;
menu->addAction( m_actionCollection.action( "new_menu" ) );
menu->addSeparator();
menu->addAction( m_actionCollection.action( "undo" ) );
menu->addAction( m_actionCollection.action( "paste" ) );
menu->addSeparator();
menu->addAction( m_actionCollection.action( "refresh" ) );
menu->addSeparator();
menu->addAction( m_actionCollection.action( "wallpaper" ) );
if ( event->reason() == QContextMenuEvent::Keyboard )
menu->exec( QPoint( 0, 0 ) );
else
menu->exec( event->pos() );
delete menu;
return;
}
KFileItemList items;
foreach ( const QModelIndex &index, m_selectionModel->selectedIndexes() ) {
KFileItem item = m_model->itemForIndex( m_proxyModel->mapToSource( index ) );
if ( !item.isNull() )
items.append( item );
}
QAction* pasteTo = m_actionCollection.action( "pasteto" );
if ( pasteTo ) {
pasteTo->setEnabled( m_actionCollection.action( "paste" )->isEnabled() );
pasteTo->setText( m_actionCollection.action( "paste" )->text() );
}
QList<QAction*> editActions;
editActions.append( m_actionCollection.action( "rename" ) );
editActions.append( m_actionCollection.action( "trash" ) );
KConfigGroup configGroup( KGlobal::config(), "KDE" );
bool showDeleteCommand = configGroup.readEntry( "ShowDeleteCommand", false );
if ( showDeleteCommand )
editActions.append( m_actionCollection.action( "del" ) );
KParts::BrowserExtension::ActionGroupMap actionGroups;
actionGroups.insert( "editactions", editActions );
KParts::BrowserExtension::PopupFlags flags = KParts::BrowserExtension::ShowProperties;
flags |= KParts::BrowserExtension::ShowUrlOperations;
KonqPopupMenu* contextMenu = new KonqPopupMenu( items, KUrl(QDir::homePath()), m_actionCollection, m_newMenu,
KonqPopupMenu::ShowNewWindow, flags,
QApplication::desktop(),
KBookmarkManager::userBookmarksManager(),
actionGroups );
contextMenu->exec( event->pos() );
delete contextMenu;
}
PopupMenuGUIClient::PopupMenuGUIClient( const KService::List &embeddingServices,
KParts::BrowserExtension::ActionGroupMap& actionGroups,
QAction* showMenuBar, QAction* stopFullScreen )
: m_actionCollection(this),
m_embeddingServices(embeddingServices)
{
QList<QAction *> topActions;
if (showMenuBar) {
topActions.append(showMenuBar);
KAction* separator = new KAction(&m_actionCollection);
separator->setSeparator(true);
topActions.append(separator);
}
if (stopFullScreen) {
topActions.append(stopFullScreen);
KAction* separator = new KAction(&m_actionCollection);
separator->setSeparator(true);
topActions.append(separator);
}
if (!embeddingServices.isEmpty()) {
QList<QAction *> previewActions;
if (embeddingServices.count() == 1) {
KService::Ptr service = embeddingServices.first();
QAction* act = addEmbeddingService( 0, i18n( "Preview &in %1", service->name() ), service );
previewActions.append(act);
} else if (embeddingServices.count() > 1) {
KService::List::ConstIterator it = embeddingServices.begin();
const KService::List::ConstIterator end = embeddingServices.end();
int idx = 0;
for (; it != end; ++it, ++idx ) {
QAction* act = addEmbeddingService( idx, (*it)->name(), *it );
previewActions.append(act);
}
}
actionGroups.insert("preview", previewActions);
}
actionGroups.insert("topactions", topActions);
}
void KonqPopupMenuPrivate::addGroup(const QString& name)
{
QList<QAction *> actions = m_actionGroups.value(name);
q->addActions(actions);
}
void KonqPopupMenuPrivate::init(KonqPopupMenu::Flags kpf, KParts::BrowserExtension::PopupFlags flags)
{
m_itemFlags = flags;
q->setFont(KGlobalSettings::menuFont());
Q_ASSERT(m_popupItemProperties.items().count() >= 1);
bool bTrashIncluded = false;
const KFileItemList lstItems = m_popupItemProperties.items();
KFileItemList::const_iterator it = lstItems.constBegin();
const KFileItemList::const_iterator kend = lstItems.constEnd();
for ( ; it != kend; ++it )
{
const KUrl url = (*it).url();
if ( !bTrashIncluded && (
( url.protocol() == "trash" && url.path().length() <= 1 ) ) ) {
bTrashIncluded = true;
}
}
const bool isDirectory = m_popupItemProperties.isDirectory();
const bool sReading = m_popupItemProperties.supportsReading();
bool sDeleting = (m_itemFlags & KParts::BrowserExtension::NoDeletion) == 0
&& m_popupItemProperties.supportsDeleting();
const bool sWriting = m_popupItemProperties.supportsWriting();
const bool sMoving = sDeleting && m_popupItemProperties.supportsMoving();
const bool isLocal = m_popupItemProperties.isLocal();
KUrl url = m_sViewURL;
url.cleanPath();
bool isTrashLink = false;
bool isCurrentTrash = false;
bool currentDir = false;
bool isSymLink = false;
bool isSymLinkInSameDir = false; // true for "ln -s foo bar", false for links to foo/sub or /foo
//check if url is current directory
if ( lstItems.count() == 1 )
{
KFileItem firstPopupItem( lstItems.first() );
if (firstPopupItem.isLink()) {
isSymLink = true;
isSymLinkInSameDir = !firstPopupItem.linkDest().contains('/');
}
KUrl firstPopupURL( firstPopupItem.url() );
firstPopupURL.cleanPath();
//kDebug(1203) << "View path is " << url.url();
//kDebug(1203) << "First popup path is " << firstPopupURL.url();
currentDir = firstPopupURL.equals( url, KUrl::CompareWithoutTrailingSlash );
if ( firstPopupItem.isDesktopFile() ) {
KDesktopFile desktopFile( firstPopupItem.localPath() );
const KConfigGroup cfg = desktopFile.desktopGroup();
isTrashLink = ( cfg.readEntry("Type") == "Link" && cfg.readEntry("URL") == "trash:/" );
}
if (isTrashLink) {
sDeleting = false;
}
// isCurrentTrash: popup on trash:/ itself, or on the trash.desktop link
isCurrentTrash = (firstPopupURL.protocol() == "trash" && firstPopupURL.path().length() <= 1)
|| isTrashLink;
}
const bool isIntoTrash = (url.protocol() == "trash") && !isCurrentTrash; // trashed file, not trash:/ itself
const bool bIsLink = (m_itemFlags & KParts::BrowserExtension::IsLink);
//kDebug() << "isLocal=" << isLocal << " url=" << url << " isCurrentTrash=" << isCurrentTrash << " isIntoTrash=" << isIntoTrash << " bTrashIncluded=" << bTrashIncluded;
//////////////////////////////////////////////////////////////////////////
addGroup( "topactions" ); // used e.g. for ShowMenuBar. includes a separator at the end
KAction * act;
KAction *actNewWindow = 0;
#if 0 // TODO in the desktop code itself.
if (( flags & KParts::BrowserExtension::ShowProperties ) && isOnDesktop &&
!KAuthorized::authorizeKAction("editable_desktop_icons"))
{
flags &= ~KParts::BrowserExtension::ShowProperties; // remove flag
}
#endif
// Either 'newview' is in the actions we're given (probably in the tabhandling group)
// or we need to insert it ourselves (e.g. for the desktop).
// In the first case, actNewWindow must remain 0.
if ( ((kpf & KonqPopupMenu::ShowNewWindow) != 0) && sReading )
{
const QString openStr = i18n("&Open");
actNewWindow = new KAction(m_parentWidget /*for status tips*/);
m_ownActions.append(actNewWindow);
actNewWindow->setIcon( KIcon("window-new") );
actNewWindow->setText( openStr );
QObject::connect(actNewWindow, SIGNAL(triggered()), q, SLOT(slotPopupNewView()));
}
if ( isDirectory && sWriting && !isCurrentTrash ) // A dir, and we can create things into it
{
const bool mkdirRequested = m_itemFlags & KParts::BrowserExtension::ShowCreateDirectory;
if ( (currentDir || mkdirRequested) && m_pMenuNew ) // Current dir -> add the "new" menu
{
// As requested by KNewFileMenu :
m_pMenuNew->checkUpToDate();
m_pMenuNew->setPopupFiles(m_popupItemProperties.urlList());
q->addAction( m_pMenuNew );
q->addSeparator();
}
else if (mkdirRequested)
{
KAction *actNewDir = new KAction(m_parentWidget);
m_ownActions.append(actNewDir);
actNewDir->setIcon( KIcon("folder-new") );
actNewDir->setText( i18n( "Create &Folder..." ) );
QObject::connect(actNewDir, SIGNAL(triggered()), q, SLOT(slotPopupNewDir()));
q->addAction( actNewDir );
q->addSeparator();
}
} else if ( isIntoTrash ) {
// Trashed item, offer restoring
act = new KAction(m_parentWidget /*for status tips*/);
m_ownActions.append(act);
act->setText( i18n( "&Restore" ) );
act->setHelpText(i18n("Restores this file or directory, back to the location where it was deleted from initially"));
QObject::connect(act, SIGNAL(triggered()), q, SLOT(slotPopupRestoreTrashedItems()));
q->addAction(act);
}
if (m_itemFlags & KParts::BrowserExtension::ShowNavigationItems)
{
if (m_itemFlags & KParts::BrowserExtension::ShowUp)
addNamedAction( "go_up" );
addNamedAction( "go_back" );
addNamedAction( "go_forward" );
if (m_itemFlags & KParts::BrowserExtension::ShowReload)
addNamedAction( "reload" );
q->addSeparator();
}
if (!currentDir && isSymLink && !isSymLinkInSameDir) {
// #65151: offer to open the target's parent dir
act = new KAction(m_parentWidget);
m_ownActions.append(act);
act->setText(isDirectory ? i18n("Show Original Directory") : i18n("Show Original File"));
act->setHelpText(i18n("Opens a new file manager window showing the target of this link, in its parent directory."));
QObject::connect(act, SIGNAL(triggered()), q, SLOT(slotShowOriginalFile()));
q->addAction(act);
}
// "open in new window" is either provided by us, or by the tabhandling group
if (actNewWindow) {
q->addAction(actNewWindow);
q->addSeparator();
}
addGroup( "tabhandling" ); // includes a separator at the end
if (m_itemFlags & KParts::BrowserExtension::ShowUrlOperations) {
if ( !currentDir && sReading ) {
if ( sDeleting ) {
addNamedAction( "cut" );
}
addNamedAction( "copy" );
}
if ( isDirectory && sWriting ) {
if ( currentDir )
addNamedAction( "paste" );
else
addNamedAction( "pasteto" );
}
}
if ( isCurrentTrash )
{
act = new KAction(m_parentWidget);
m_ownActions.append(act);
act->setIcon( KIcon("trash-empty") );
act->setText( i18n( "&Empty Trash Bin" ) );
KConfig trashConfig( "trashrc", KConfig::SimpleConfig);
act->setEnabled( !trashConfig.group("Status").readEntry( "Empty", true ) );
QObject::connect(act, SIGNAL(triggered()), q, SLOT(slotPopupEmptyTrashBin()));
q->addAction(act);
}
if ( isCurrentTrash )
{
act = new KAction(m_parentWidget);
m_ownActions.append(act);
act->setIcon( KIcon("trash-empty") );
act->setText( i18n( "&Configure Trash Bin" ) );
QObject::connect(act, SIGNAL(triggered()), q, SLOT(slotConfigTrashBin()));
q->addAction(act);
}
// This is used by KHTML, see khtml_popupmenu.rc (copy, selectAll, searchProvider etc.)
// and by DolphinPart (rename, trash, delete)
addGroup( "editactions" );
if (m_itemFlags & KParts::BrowserExtension::ShowTextSelectionItems) {
// OK, we have to stop here.
// Anything else that is provided by the part
addGroup( "partactions" );
return;
}
if ( !isCurrentTrash && !isIntoTrash && (m_itemFlags & KParts::BrowserExtension::ShowBookmark))
{
QString caption;
if (currentDir)
{
const bool httpPage = m_sViewURL.protocol().startsWith("http", Qt::CaseInsensitive);
if (httpPage)
caption = i18n("&Bookmark This Page");
else
caption = i18n("&Bookmark This Location");
}
else if (isDirectory)
caption = i18n("&Bookmark This Folder");
else if (bIsLink)
caption = i18n("&Bookmark This Link");
else
caption = i18n("&Bookmark This File");
act = new KAction(m_parentWidget);
m_ownActions.append(act);
act->setObjectName( QLatin1String("bookmark_add" )); // for unittest
act->setIcon( KIcon("bookmark-new") );
act->setText( caption );
QObject::connect(act, SIGNAL(triggered()), q, SLOT(slotPopupAddToBookmark()));
if (lstItems.count() > 1)
act->setEnabled(false);
if (KAuthorized::authorizeKAction("bookmarks"))
q->addAction( act );
if (bIsLink)
addGroup( "linkactions" ); // see khtml
}
// "Open With" actions
m_menuActions.setItemListProperties(m_popupItemProperties);
if ( sReading ) {
m_menuActions.addOpenWithActionsTo(q, "DesktopEntryName != 'kfmclient' and DesktopEntryName != 'kfmclient_dir' and DesktopEntryName != 'kfmclient_html'");
QList<QAction *> previewActions = m_actionGroups.value("preview");
if (!previewActions.isEmpty()) {
if (previewActions.count() == 1) {
q->addAction(previewActions.first());
} else {
QMenu* subMenu = new QMenu(i18n("Preview In"), q);
subMenu->menuAction()->setObjectName( QLatin1String("preview_submenu" )); // for the unittest
q->addMenu(subMenu);
subMenu->addActions(previewActions);
}
}
}
// Second block, builtin + user
m_menuActions.addServiceActionsTo(q);
q->addSeparator();
// Use the Dolphin setting for showing the "Copy To" and "Move To" actions
KSharedConfig::Ptr dolphin = KSharedConfig::openConfig("dolphinrc");
// CopyTo/MoveTo menus
if (m_itemFlags & KParts::BrowserExtension::ShowUrlOperations &&
KConfigGroup(dolphin, "General").readEntry("ShowCopyMoveMenu", false)) {
m_copyToMenu.setItems(lstItems);
m_copyToMenu.setReadOnly(sMoving == false);
m_copyToMenu.addActionsTo(q);
q->addSeparator();
}
if (!isCurrentTrash && !isIntoTrash && sReading &&
(kpf & KonqPopupMenu::NoPlugins) == 0) {
addPlugins(); // now it's time to add plugins
}
if ( (m_itemFlags & KParts::BrowserExtension::ShowProperties) && KPropertiesDialog::canDisplay( lstItems ) ) {
act = new KAction(m_parentWidget);
m_ownActions.append(act);
act->setObjectName( QLatin1String("properties" )); // for unittest
act->setText( i18n( "&Properties" ) );
QObject::connect(act, SIGNAL(triggered()), q, SLOT(slotPopupProperties()));
q->addAction(act);
}
while ( !q->actions().isEmpty() &&
q->actions().last()->isSeparator() )
delete q->actions().last();
if ( isDirectory && isLocal ) {
if ( KFileShare::authorization() == KFileShare::Authorized ) {
q->addSeparator();
act = new KAction(m_parentWidget);
m_ownActions.append(act);
act->setText( i18n("Share") );
QObject::connect(act, SIGNAL(triggered()), q, SLOT(slotOpenShareFileDialog()));
q->addAction(act);
}
}
// Anything else that is provided by the part
addGroup( "partactions" );
}
void WebView::editableContentActionPopupMenu(KParts::BrowserExtension::ActionGroupMap& partGroupMap)
{
QList<QAction*> editableContentActions;
KActionMenu* menu = new KActionMenu(i18nc("Text direction", "Direction"), this);
QActionGroup* group = new QActionGroup(this);
group->setExclusive(true);
QAction *action = m_actionCollection->addAction(QL1S("text-direction-default"), m_part->browserExtension(), SLOT(slotTextDirectionChanged()));
action->setText(i18n("Default"));
action->setCheckable(true);
action->setData(QWebPage::SetTextDirectionDefault);
action->setEnabled(pageAction(QWebPage::SetTextDirectionDefault)->isEnabled());
action->setCheckable(pageAction(QWebPage::SetTextDirectionDefault)->isChecked());
action->setActionGroup(group);
menu->addAction(action);
action = m_actionCollection->addAction(QL1S("text-direction-left-to-right"), m_part->browserExtension(), SLOT(slotTextDirectionChanged()));
action->setText(i18n("Left to right"));
action->setCheckable(true);
action->setData(QWebPage::SetTextDirectionLeftToRight);
action->setEnabled(pageAction(QWebPage::SetTextDirectionLeftToRight)->isEnabled());
action->setChecked(pageAction(QWebPage::SetTextDirectionLeftToRight)->isChecked());
action->setActionGroup(group);
menu->addAction(action);
action = m_actionCollection->addAction(QL1S("text-direction-right-to-left"), m_part->browserExtension(), SLOT(slotTextDirectionChanged()));
action->setText(i18n("Right to left"));
action->setCheckable(true);
action->setData(QWebPage::SetTextDirectionRightToLeft);
action->setEnabled(pageAction(QWebPage::SetTextDirectionRightToLeft)->isEnabled());
action->setChecked(pageAction(QWebPage::SetTextDirectionRightToLeft)->isChecked());
action->setActionGroup(group);
menu->addAction(action);
editableContentActions.append(menu);
action = new QAction(m_actionCollection);
action->setSeparator(true);
editableContentActions.append(action);
action = m_actionCollection->addAction(KStandardAction::Copy, QL1S("copy"), m_part->browserExtension(), SLOT(copy()));
action->setEnabled(pageAction(QWebPage::Copy)->isEnabled());
editableContentActions.append(action);
action = m_actionCollection->addAction(KStandardAction::Cut, QL1S("cut"), m_part->browserExtension(), SLOT(cut()));
action->setEnabled(pageAction(QWebPage::Cut)->isEnabled());
editableContentActions.append(action);
action = m_actionCollection->addAction(KStandardAction::Paste, QL1S("paste"), m_part->browserExtension(), SLOT(paste()));
action->setEnabled(pageAction(QWebPage::Paste)->isEnabled());
editableContentActions.append(action);
action = new QAction(m_actionCollection);
action->setSeparator(true);
editableContentActions.append(action);
const bool hasContent = (!m_result.element().evaluateJavaScript(QL1S("this.value")).toString().isEmpty());
action = m_actionCollection->addAction(KStandardAction::SelectAll, QL1S("selectall"), m_part->browserExtension(), SLOT(slotSelectAll()));
action->setEnabled((pageAction(QWebPage::SelectAll)->isEnabled() && hasContent));
editableContentActions.append(action);
if (showSpellCheckAction(m_result.element())) {
action = new QAction(m_actionCollection);
action->setSeparator(true);
editableContentActions.append(action);
action = m_actionCollection->addAction(KStandardAction::Spelling, QL1S("spelling"), m_part->browserExtension(), SLOT(slotCheckSpelling()));
action->setText(i18n("Check Spelling..."));
action->setEnabled(hasContent);
editableContentActions.append(action);
const bool hasSelection = (hasContent && m_result.isContentSelected());
action = m_actionCollection->addAction(KStandardAction::Spelling, QL1S("spellcheckSelection"), m_part->browserExtension(), SLOT(slotSpellCheckSelection()));
action->setText(i18n("Spellcheck selection..."));
action->setEnabled(hasSelection);
editableContentActions.append(action);
}
if (settings()->testAttribute(QWebSettings::DeveloperExtrasEnabled)) {
if (!m_webInspector) {
m_webInspector = new QWebInspector;
m_webInspector->setPage(page());
connect(page(), SIGNAL(destroyed()), m_webInspector, SLOT(deleteLater()));
}
action = new QAction(m_actionCollection);
action->setSeparator(true);
editableContentActions.append(action);
editableContentActions.append(pageAction(QWebPage::InspectElement));
}
partGroupMap.insert("editactions" , editableContentActions);
}
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);
}
void PopupView::showContextMenu(QWidget *widget, const QPoint &screenPos, const QList<QModelIndex> &indexes)
{
Q_UNUSED(widget)
// contextMenuRequest is only called from the icon view, which is created in init()
// which mean m_model should always be initialized
Q_ASSERT(m_model);
if (indexes.isEmpty()) {
return;
}
if (m_actionCollection.isEmpty()) {
createActions();
}
KFileItemList items;
bool hasRemoteFiles = false;
bool isTrashLink = false;
foreach (const QModelIndex &index, m_selectionModel->selectedIndexes()) {
KFileItem item = m_model->itemForIndex(index);
if (!item.isNull()) {
hasRemoteFiles |= item.localPath().isEmpty();
items.append(item);
}
}
// Check if we're showing the menu for the trash link
if (items.count() == 1 && items.at(0).isDesktopFile()) {
KDesktopFile file(items.at(0).localPath());
if (file.readType() == "Link" && file.readUrl() == "trash:/") {
isTrashLink = true;
}
}
QAction *pasteTo = m_actionCollection.action("pasteto");
if (pasteTo) {
if (QAction *paste = m_actionCollection.action("paste")) {
pasteTo->setEnabled(paste->isEnabled());
pasteTo->setText(paste->text());
}
}
QList<QAction*> editActions;
editActions.append(m_actionCollection.action("rename"));
KConfigGroup configGroup(KGlobal::config(), "KDE");
bool showDeleteCommand = configGroup.readEntry("ShowDeleteCommand", false);
// Don't add the "Move to Trash" action if we're showing the menu for the trash link
if (!isTrashLink) {
if (!hasRemoteFiles) {
editActions.append(m_actionCollection.action("trash"));
} else {
showDeleteCommand = true;
}
}
if (showDeleteCommand) {
editActions.append(m_actionCollection.action("del"));
}
KParts::BrowserExtension::ActionGroupMap actionGroups;
actionGroups.insert("editactions", editActions);
KParts::BrowserExtension::PopupFlags flags = KParts::BrowserExtension::ShowProperties;
flags |= KParts::BrowserExtension::ShowUrlOperations;
// m_newMenu can be NULL here but KonqPopupMenu does handle this.
KonqPopupMenu *contextMenu = new KonqPopupMenu(items, m_url, m_actionCollection, m_newMenu,
KonqPopupMenu::ShowNewWindow, flags,
QApplication::desktop(),
KBookmarkManager::userBookmarksManager(),
actionGroups);
connect(contextMenu->fileItemActions(), SIGNAL(openWithDialogAboutToBeShown()), this, SLOT(openWithDialogAboutToShow()));
m_showingMenu = true;
contextMenu->exec(screenPos);
delete contextMenu;
m_showingMenu = false;
if (pasteTo) {
pasteTo->setEnabled(false);
}
if (m_delayedClose) {
m_delayedClose = false;
closeThisAndParentPopup();
}
}
