void ScriptManager::setupActions() { KActionCollection* ac = part()->actionCollection(); add_script = new QAction(QIcon::fromTheme("list-add"), i18n("Add Script"), this); connect(add_script, SIGNAL(triggered()), this, SIGNAL(addScript())); ac->addAction("add_script", add_script); remove_script = new QAction(QIcon::fromTheme("list-remove"), i18n("Remove Script"), this); connect(remove_script, SIGNAL(triggered()), this, SIGNAL(removeScript())); ac->addAction("remove_script", remove_script); run_script = new QAction(QIcon::fromTheme("system-run"), i18n("Run Script"), this); connect(run_script, SIGNAL(triggered()), this, SLOT(runScript())); ac->addAction("run_script", run_script); stop_script = new QAction(QIcon::fromTheme("media-playback-stop"), i18n("Stop Script"), this); connect(stop_script, SIGNAL(triggered()), this, SLOT(stopScript())); ac->addAction("stop_script", stop_script); edit_script = new QAction(QIcon::fromTheme("document-open"), i18n("Edit Script"), this); connect(edit_script, SIGNAL(triggered()), this, SLOT(editScript())); ac->addAction("edit_script", edit_script); properties = new QAction(QIcon::fromTheme("dialog-information"), i18n("Properties"), this); connect(properties, SIGNAL(triggered()), this, SLOT(showProperties())); ac->addAction("script_properties", properties); configure_script = new QAction(QIcon::fromTheme("preferences-other"), i18n("Configure"), this); connect(configure_script, SIGNAL(triggered()), this, SLOT(configureScript())); ac->addAction("configure_script", configure_script); }
KompareModelList::KompareModelList( DiffSettings* diffSettings, QWidget* widgetForKIO, QObject* parent, const char* name ) : QObject( parent ), m_diffProcess( 0 ), m_diffSettings( diffSettings ), m_models( 0 ), m_selectedModel( 0 ), m_selectedDifference( 0 ), m_modelIndex( 0 ), m_info( 0 ), m_textCodec( 0 ), m_widgetForKIO( widgetForKIO ) { kDebug(8101) << "Show me the arguments: " << diffSettings << ", " << widgetForKIO << ", " << parent << ", " << name << endl; KActionCollection *ac = ((KomparePart*) parent)->actionCollection(); m_applyDifference = ac->addAction( "difference_apply", this, SLOT(slotActionApplyDifference()) ); m_applyDifference->setIcon( KIcon("arrow-right") ); m_applyDifference->setText( i18n("&Apply Difference") ); m_applyDifference->setShortcut( QKeySequence(Qt::Key_Space) ); m_unApplyDifference = ac->addAction( "difference_unapply", this, SLOT(slotActionUnApplyDifference()) ); m_unApplyDifference->setIcon( KIcon("arrow-left") ); m_unApplyDifference->setText( i18n("Un&apply Difference") ); m_unApplyDifference->setShortcut( QKeySequence(Qt::Key_Backspace) ); m_applyAll = ac->addAction( "difference_applyall", this, SLOT(slotActionApplyAllDifferences()) ); m_applyAll->setIcon( KIcon("arrow-right-double") ); m_applyAll->setText( i18n("App&ly All") ); m_applyAll->setShortcut( QKeySequence(Qt::CTRL + Qt::Key_A) ); m_unapplyAll = ac->addAction( "difference_unapplyall", this, SLOT(slotActionUnapplyAllDifferences()) ); m_unapplyAll->setIcon( KIcon("arrow-left-double") ); m_unapplyAll->setText( i18n("&Unapply All") ); m_unapplyAll->setShortcut( QKeySequence(Qt::CTRL + Qt::Key_U) ); m_previousFile = ac->addAction( "difference_previousfile", this, SLOT(slotPreviousModel()) ); m_previousFile->setIcon( KIcon("arrow-up-double") ); m_previousFile->setText( i18n("P&revious File") ); m_previousFile->setShortcut( QKeySequence(Qt::CTRL + Qt::Key_PageUp) ); m_nextFile = ac->addAction( "difference_nextfile", this, SLOT(slotNextModel()) ); m_nextFile->setIcon( KIcon("arrow-down-double") ); m_nextFile->setText( i18n("N&ext File") ); m_nextFile->setShortcut( QKeySequence(Qt::CTRL + Qt::Key_PageDown) ); m_previousDifference = ac->addAction( "difference_previous", this, SLOT(slotPreviousDifference()) ); m_previousDifference->setIcon( KIcon("arrow-up") ); m_previousDifference->setText( i18n("&Previous Difference") ); m_previousDifference->setShortcut( QKeySequence(Qt::CTRL + Qt::Key_Up) ); m_nextDifference = ac->addAction( "difference_next", this, SLOT(slotNextDifference()) ); m_nextDifference->setIcon( KIcon("arrow-down") ); m_nextDifference->setText( i18n("&Next Difference") ); m_nextDifference->setShortcut( QKeySequence(Qt::CTRL + Qt::Key_Down) ); m_previousDifference->setEnabled( false ); m_nextDifference->setEnabled( false ); m_save = KStandardAction::save( this, SLOT(slotSaveDestination()), ac ); m_save->setEnabled( false ); updateModelListActions(); }
SwitchViewController::SwitchViewController( AbstractGroupedViews* groupedViews, KXMLGUIClient* guiClient ) : mGroupedViews( groupedViews ) { KActionCollection* actionCollection = guiClient->actionCollection(); mForwardAction = actionCollection->addAction( KStandardAction::Forward, QStringLiteral("window_next"), this, SLOT(forward()) ); mBackwardAction = actionCollection->addAction( KStandardAction::Back, QStringLiteral("window_previous"), this, SLOT(backward()) ); connect( groupedViews, SIGNAL(added(QList<Kasten::AbstractView*>)), SLOT(updateActions()) ); connect( groupedViews, SIGNAL(removing(QList<Kasten::AbstractView*>)), SLOT(updateActions()) ); connect( groupedViews, SIGNAL(viewFocusChanged(Kasten::AbstractView*)), SLOT(updateActions()) ); updateActions(); }
KisToolPolylineBase::KisToolPolylineBase(KoCanvasBase * canvas, KisToolPolylineBase::ToolType type, const QCursor & cursor) : KisToolShape(canvas, cursor), m_dragging(false), m_type(type), m_closeSnappingActivated(false) { KisCanvas2 * kiscanvas = dynamic_cast<KisCanvas2*>(this->canvas()); KActionCollection *collection = this->canvas()->canvasController()->actionCollection(); if (kiscanvas && kiscanvas->viewManager()) { QAction *undo_polygon_selection = new QAction("Undo Polygon Selection Points",this); undo_polygon_selection->setShortcut(QKeySequence(Qt::ShiftModifier + Qt::Key_Z)); collection->addAction("undo_polygon_selection", undo_polygon_selection); addAction("undo_polygon_selection", undo_polygon_selection); } }
void KOEventPopupMenu::forward() { KOrg::MainWindow *w = ActionManager::findInstance( KUrl() ); if ( !w || !mCurrentIncidence ) { return; } KActionCollection *ac = w->getActionCollection(); QAction *action = ac->action( "schedule_forward" ); if ( action ) { action->trigger(); } else { kError() << "What happened to the schedule_forward action?"; } }
void ActionConfigDialog::slotEditToolbar() { QString toolbarName; QString toolbarId; QListViewItem *oldItem; QListViewItem *item = actionTreeView->currentItem(); if (item->parent()) item = item->parent(); toolbarName = item->text(0); if ( toolbarName != i18n("All")) { emit configureToolbars(toolbarName +" <quanta>"); //update the tree view KAction *action; KActionCollection *ac = m_mainWindow->actionCollection(); ToolbarTabWidget *tb = ToolbarTabWidget::ref(); for (int i = 0; i < tb->count(); i++) { toolbarName = tb->label(i); toolbarId = tb->id(i); ToolbarEntry *p_toolbar = m_toolbarList[toolbarId]; if (p_toolbar) { oldItem = actionTreeView->findItem(toolbarName, 0); item = new KListViewItem(actionTreeView, oldItem, toolbarName); item->setOpen(oldItem->isOpen()); delete oldItem; QDomNode node = p_toolbar->guiClient->domDocument().firstChild().firstChild().firstChild(); while (!node.isNull()) { if (node.nodeName() == "Action") { action = ac->action(node.toElement().attribute("name")); if (action) { oldItem = new KListViewItem(item, oldItem, action->text().replace(QRegExp("\\&(?!\\&)"),""), action->shortcut().toString(), action->name()); oldItem->setPixmap(0, SmallIcon(action->icon())); } } node = node.nextSibling(); } } } actionTreeView->setCurrentItem(allActionsItem); actionTreeView->setSelected(allActionsItem, true); } }
Tag::Tag() { static int tagNumber = 0; ++tagNumber; QString sAction = "tag_shortcut_number_" + QString::number(tagNumber); KActionCollection *ac = Global::bnpView->actionCollection(); m_action = ac->addAction(sAction, Global::bnpView, SLOT(activatedTagShortcut())); m_action->setText("FAKE TEXT"); m_action->setIcon(KIcon("FAKE ICON")); m_action->setShortcutConfigurable(false); // We do it in the tag properties dialog m_inheritedBySiblings = false; }
MouseMarkEffect::MouseMarkEffect() { KActionCollection* actionCollection = new KActionCollection(this); KAction* a = static_cast< KAction* >(actionCollection->addAction("ClearMouseMarks")); a->setText(i18n("Clear All Mouse Marks")); a->setGlobalShortcut(KShortcut(Qt::SHIFT + Qt::META + Qt::Key_F11)); connect(a, SIGNAL(triggered(bool)), this, SLOT(clear())); a = static_cast< KAction* >(actionCollection->addAction("ClearLastMouseMark")); a->setText(i18n("Clear Last Mouse Mark")); a->setGlobalShortcut(KShortcut(Qt::SHIFT + Qt::META + Qt::Key_F12)); connect(a, SIGNAL(triggered(bool)), this, SLOT(clearLast())); connect(effects, SIGNAL(mouseChanged(QPoint,QPoint,Qt::MouseButtons,Qt::MouseButtons,Qt::KeyboardModifiers,Qt::KeyboardModifiers)), this, SLOT(slotMouseChanged(QPoint,QPoint,Qt::MouseButtons,Qt::MouseButtons,Qt::KeyboardModifiers,Qt::KeyboardModifiers))); reconfigure(ReconfigureAll); arrow_start = NULL_POINT; effects->startMousePolling(); // We require it to detect activation as well }
void GUI::setupActions() { KActionCollection* ac = actionCollection(); QAction * new_action = KStandardAction::openNew(this, SLOT(createTorrent()), ac); new_action->setToolTip(i18n("Create a new torrent")); QAction * open_action = KStandardAction::open(this, SLOT(openTorrent()), ac); open_action->setToolTip(i18n("Open a torrent")); paste_action = KStandardAction::paste(this, SLOT(paste()), ac); open_silently_action = new QAction(open_action->icon(), i18n("Open Silently"), this); open_silently_action->setToolTip(i18n("Open a torrent without asking any questions")); connect(open_silently_action, &QAction::triggered, this, &GUI::openTorrentSilently); ac->addAction(QStringLiteral("file_open_silently"), open_silently_action); KStandardAction::quit(this, SLOT(quit()), ac); show_status_bar_action = KStandardAction::showStatusbar(statusBar(), SLOT(setVisible(bool)), ac); show_status_bar_action->setIcon(QIcon::fromTheme(QStringLiteral("kt-show-statusbar"))); show_menu_bar_action = KStandardAction::showMenubar(menuBar(), SLOT(setVisible(bool)), ac); KStandardAction::preferences(this, SLOT(showPrefDialog()), ac); KStandardAction::keyBindings(this, SLOT(configureKeys()), ac); KStandardAction::configureToolbars(this, SLOT(configureToolbars()), ac); KStandardAction::configureNotifications(this, SLOT(configureNotifications()), ac); paste_url_action = new QAction(QIcon::fromTheme(QStringLiteral("document-open-remote")), i18n("Open URL"), this); paste_url_action->setToolTip(i18n("Open a URL which points to a torrent, magnet links are supported")); connect(paste_url_action, &QAction::triggered, this, &GUI::pasteURL); ac->addAction(QStringLiteral("paste_url"), paste_url_action); ac->setDefaultShortcut(paste_url_action, QKeySequence(Qt::CTRL + Qt::Key_P)); ipfilter_action = new QAction(QIcon::fromTheme(QStringLiteral("view-filter")), i18n("IP Filter"), this); ipfilter_action->setToolTip(i18n("Show the list of blocked IP addresses")); connect(ipfilter_action, &QAction::triggered, this, &GUI::showIPFilter); ac->addAction(QStringLiteral("ipfilter_action"), ipfilter_action); ac->setDefaultShortcut(ipfilter_action, QKeySequence(Qt::CTRL + Qt::Key_I)); import_action = new QAction(QIcon::fromTheme("document-import"), i18n("Import Torrent"), this); import_action->setToolTip(i18n("Import a torrent")); connect(import_action, &QAction::triggered, this, &GUI::import); ac->addAction(QStringLiteral("import"), import_action); ac->setDefaultShortcut(import_action, QKeySequence(Qt::SHIFT + Qt::Key_I)); show_kt_action = new QAction(QIcon::fromTheme(QStringLiteral("kt-show-hide")), i18n("Show/Hide KTorrent"), this); connect(show_kt_action, &QAction::triggered, this, &GUI::showOrHide); ac->addAction(QStringLiteral("show_kt"), show_kt_action); // KF5 show_kt_action->setGlobalShortcut(QKeySequence(Qt::ALT + Qt::SHIFT + Qt::Key_T)); setStandardToolBarMenuEnabled(true); }
// TODO: a tool(view) might perhaps be invoked indirectly by asking for a tool for the object, here select // so the status bar selection indicator can invoke the same tool, without knowing about it SelectRangeController::SelectRangeController( If::ToolInlineViewable* toolInlineViewable, KXMLGUIClient* guiClient ) : mToolInlineViewable( toolInlineViewable ) { KActionCollection* actionCollection = guiClient->actionCollection(); mSelectAction = actionCollection->addAction( QLatin1String("edit_select"), this, SLOT(select()) ); mSelectAction->setText( i18nc("@action:inmenu","&Select range...") ); mSelectAction->setIcon( KIcon(QLatin1String("select-rectangular")) ); mSelectAction->setShortcut( Qt::CTRL + Qt::Key_E ); mTool = new SelectRangeTool(); connect( mTool, SIGNAL(isUsableChanged(bool)), mSelectAction, SLOT(setEnabled(bool)) ); mSelectAction->setEnabled( mTool->isUsable() ); mView = new SelectRangeToolView( mTool ); }
void ActionManagerImpl::initArticleViewer(ArticleViewer* articleViewer) { if (d->articleViewer) return; else d->articleViewer = articleViewer; KActionCollection* coll = actionCollection(); KAction* action = 0; action = KStandardAction::print(articleViewer, SLOT(slotPrint()), actionCollection()); coll->addAction("viewer_print", action); action = KStandardAction::copy(articleViewer, SLOT(slotCopy()), coll); coll->addAction("viewer_copy", action); connect(d->tabWidget, SIGNAL(signalZoomInFrame(int)), d->articleViewer, SLOT(slotZoomIn(int))); connect(d->tabWidget, SIGNAL(signalZoomOutFrame(int)), d->articleViewer, SLOT(slotZoomOut(int))); }
void TabBar::updateToggleActions(int sessionId) { if (sessionId == -1) return; KActionCollection* actionCollection = m_mainWindow->actionCollection(); SessionStack* sessionStack = m_mainWindow->sessionStack(); QAction* toggleAction = actionCollection->action("toggle-session-prevent-closing"); toggleAction->setChecked(!sessionStack->isSessionClosable(sessionId)); toggleAction = actionCollection->action("toggle-session-keyboard-input"); toggleAction->setChecked(!sessionStack->hasTerminalsWithKeyboardInputEnabled(sessionId)); toggleAction = actionCollection->action("toggle-session-monitor-activity"); toggleAction->setChecked(!sessionStack->hasTerminalsWithMonitorActivityDisabled(sessionId)); toggleAction = actionCollection->action("toggle-session-monitor-silence"); toggleAction->setChecked(!sessionStack->hasTerminalsWithMonitorSilenceDisabled(sessionId)); }
void addActionToMenu(KMenu& popup, const char* name) { QAction* action = mActionCollection->action(name); if (!action) { kWarning() << "Unknown action" << name; return; } if (action->isEnabled()) { popup.addAction(action); } }
// private void kpTool::createAction () { #if DEBUG_KP_TOOL && 0 kdDebug () << "kpTool(" << name () << "::createAction()" << endl; #endif if (!m_mainWindow) { kdError () << "kpTool::createAction() without mw" << endl; return; } KActionCollection *ac = m_mainWindow->actionCollection (); if (!ac) { kdError () << "kpTool::createAction() without ac" << endl; return; } if (m_action) { // TODO: I don't think this will ever be executed as we are not called // outside of the constructor. #if DEBUG_KP_TOOL kdDebug () << "\tdeleting existing" << endl; #endif ac->remove (m_action); m_action = 0; } m_action = new kpToolAction (text (), iconName (), shortcutForKey (m_key), this, SLOT (slotActionActivated ()), m_mainWindow->actionCollection (), name ()); m_action->setExclusiveGroup (QString::fromLatin1 ("Tool Box Actions")); m_action->setWhatsThis (description ()); connect (m_action, SIGNAL (toolTipChanged (const QString &)), this, SLOT (slotActionToolTipChanged (const QString &))); }
MouseMarkEffect::MouseMarkEffect() { KActionCollection* actionCollection = new KActionCollection(this); QAction* a = actionCollection->addAction(QStringLiteral("ClearMouseMarks")); a->setText(i18n("Clear All Mouse Marks")); KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::SHIFT + Qt::META + Qt::Key_F11); KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::SHIFT + Qt::META + Qt::Key_F11); connect(a, SIGNAL(triggered(bool)), this, SLOT(clear())); a = actionCollection->addAction(QStringLiteral("ClearLastMouseMark")); a->setText(i18n("Clear Last Mouse Mark")); KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::SHIFT + Qt::META + Qt::Key_F12); KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::SHIFT + Qt::META + Qt::Key_F12); connect(a, SIGNAL(triggered(bool)), this, SLOT(clearLast())); connect(effects, SIGNAL(mouseChanged(QPoint,QPoint,Qt::MouseButtons,Qt::MouseButtons,Qt::KeyboardModifiers,Qt::KeyboardModifiers)), this, SLOT(slotMouseChanged(QPoint,QPoint,Qt::MouseButtons,Qt::MouseButtons,Qt::KeyboardModifiers,Qt::KeyboardModifiers))); connect(effects, SIGNAL(screenLockingChanged(bool)), SLOT(screenLockingChanged(bool))); reconfigure(ReconfigureAll); arrow_start = NULL_POINT; effects->startMousePolling(); // We require it to detect activation as well }
void RubyDebuggerPart::slotStatus(const QString &msg, int state) { QString stateIndicator; if (state & s_dbgNotStarted) { stateIndicator = " "; } else if (state & s_appBusy) { stateIndicator = "A"; debugger()->clearExecutionPoint(); stateChanged( QString("active") ); } else if (state & s_programExited) { stateIndicator = "E"; stateChanged( QString("stopped") ); KActionCollection *ac = actionCollection(); ac->action("debug_run")->setText( i18n("Restart") ); // ac->action("debug_run")->setIcon( "1rightarrow" ); ac->action("debug_run")->setToolTip( i18n("Restart the program in the debugger") ); ac->action("debug_run")->setWhatsThis( i18n("Restart in debugger\n\n" "Restarts the program in the debugger") ); // slotStop(); } else { stateIndicator = "P"; stateChanged( QString("paused") ); } // And now? :-) kdDebug(9012) << "Debugger state: " << stateIndicator << ": " << endl; kdDebug(9012) << " " << msg << endl; statusBarIndicator->setText(stateIndicator); if (!msg.isEmpty()) mainWindow()->statusBar()->message(msg, 3000); }
void TorrentActivity::setupActions() { KActionCollection* ac = part()->actionCollection(); start_all_action = new KAction(KIcon("kt-start-all"), i18n("Start All"), this); start_all_action->setToolTip(i18n("Start all torrents")); connect(start_all_action, SIGNAL(triggered()), this, SLOT(startAllTorrents())); ac->addAction("start_all", start_all_action); stop_all_action = new KAction(KIcon("kt-stop-all"), i18n("Stop All"), this); stop_all_action->setToolTip(i18n("Stop all torrents")); connect(stop_all_action, SIGNAL(triggered()), this, SLOT(stopAllTorrents())); ac->addAction("stop_all", stop_all_action); queue_suspend_action = new KToggleAction(KIcon("kt-pause"), i18n("Suspend Torrents"), this); ac->addAction("queue_suspend", queue_suspend_action); queue_suspend_action->setToolTip(i18n("Suspend all running torrents")); queue_suspend_action->setShortcut(KShortcut(Qt::SHIFT + Qt::Key_P)); queue_suspend_action->setGlobalShortcut(KShortcut(Qt::ALT + Qt::SHIFT + Qt::Key_P)); connect(queue_suspend_action, SIGNAL(toggled(bool)), this, SLOT(suspendQueue(bool))); show_group_view_action = new KToggleAction(KIcon("view-list-tree"), i18n("Group View Visible"), this); show_group_view_action->setToolTip(i18n("Show or hide the group view")); connect(show_group_view_action, SIGNAL(toggled(bool)), this, SLOT(setGroupViewVisible(bool))); ac->addAction("show_group_view", show_group_view_action); filter_torrent_action = new KAction(i18n("Filter Torrents"), this); filter_torrent_action->setToolTip(i18n("Filter torrents based on filter string")); filter_torrent_action->setShortcut(Qt::CTRL + Qt::Key_F); connect(filter_torrent_action, SIGNAL(triggered(bool)), search_bar, SLOT(showBar())); ac->addAction("filter_torrent", filter_torrent_action); view->setupActions(ac); }
void KexiFormManager::init(KexiFormPart *part, KFormDesigner::WidgetTreeWidget *widgetTree) { /* @todo add configuration for supported factory groups */ QStringList supportedFactoryGroups; supportedFactoryGroups += "kexi"; d->lib = new KFormDesigner::WidgetLibrary(this, supportedFactoryGroups); d->lib->setAdvancedPropertiesVisible(false); connect(d->lib, SIGNAL(widgetCreated(QWidget*)), this, SLOT(slotWidgetCreatedByFormsLibrary(QWidget*))); connect(d->lib, SIGNAL(widgetActionToggled(const QByteArray&)), this, SLOT(slotWidgetActionToggled(const QByteArray&))); d->part = part; KActionCollection *col = /*tmp*/ new KActionCollection(this); // 2.0 d->part->actionCollectionForMode(Kexi::DesignViewMode); if (col) { createActions( col ); //connect actions provided by widget factories //moved from KexiFormPart connect(col->action("widget_assign_action"), SIGNAL(activated()), this, SLOT(slotAssignAction())); } d->widgetTree = widgetTree; if (d->widgetTree) { #ifdef __GNUC__ #warning "Port this: connect()" #else #pragma WARNING( Port this: connect() ) #endif #ifdef __GNUC__ #warning "Port code related to KFormDesigner::FormManager::m_treeview here" #else #pragma WARNING( Port code related to KFormDesigner::FormManager::m_treeview here ) #endif //todo connect(m_propSet, SIGNAL(widgetNameChanged(const QByteArray&, const QByteArray&)), //todo m_treeview, SLOT(renameItem(const QByteArray&, const QByteArray&))); } }
K3b::DeviceMenu::Private::Private( DeviceMenu* parent ) : q( parent ) { KActionCollection* dmActions = k3bappcore->appDeviceManager()->actionCollection(); q->addAction( dmActions->action( "device_diskinfo" ) ); q->addSeparator(); q->addAction( dmActions->action( "device_unmount" ) ); q->addAction( dmActions->action( "device_mount" ) ); q->addAction( dmActions->action( "device_eject" ) ); q->addAction( dmActions->action( "device_load" ) ); q->addSeparator(); q->addAction( dmActions->action( "device_set_read_speed" ) ); q->addSeparator(); // FIXME: Should we move these actions to K3b::AppDeviceManager? actionContinueMultisession = q->addAction( QIcon::fromTheme( "media-optical-data" ), i18n("Continue Multisession Project"), q, SLOT(_k_continueMultisession()) ); actionCopy = q->addAction( QIcon::fromTheme( "tools-media-optical-copy" ), i18n("Copy &Medium..."), q, SLOT(_k_copy()) ); actionFormat = q->addAction( QIcon::fromTheme( "tools-media-optical-erase" ), i18n("&Format/Erase rewritable disk..."), q, SLOT(_k_format()) ); actionRipAudio = q->addAction( QIcon::fromTheme( "tools-rip-audio-cd" ), i18n("Rip Audio CD..."), q, SLOT(_k_ripAudio()) ); actionRipVideoDVD = q->addAction( QIcon::fromTheme( "tools-rip-video-dvd" ), i18n("Rip Video DVD..."), q, SLOT(_k_ripVideoDVD()) ); actionRipVcd = q->addAction( QIcon::fromTheme( "tools-rip-video-cd"), i18n("Rip Video CD..."), q, SLOT(_k_ripVcd()) ); actionCopy->setToolTip( i18n("Open the media copy dialog") ); actionCopy->setStatusTip( actionCopy->toolTip() ); actionFormat->setToolTip( i18n("Open the rewritable disk formatting/erasing dialog") ); actionFormat->setStatusTip( actionFormat->toolTip() ); }
KonqHistoryDialog::KonqHistoryDialog(KonqMainWindow *parent) : KDialog(parent), m_mainWindow(parent) { setCaption(i18nc("@title:window", "History")); setButtons(KDialog::Close); QVBoxLayout *mainLayout = new QVBoxLayout(mainWidget()); mainLayout->setMargin(0); m_historyView = new KonqHistoryView(mainWidget()); connect(m_historyView->treeView(), SIGNAL(doubleClicked(QModelIndex)), this, SLOT(slotOpenWindowForIndex(QModelIndex))); connect(m_historyView, &KonqHistoryView::openUrlInNewWindow, this, &KonqHistoryDialog::slotOpenWindow); connect(m_historyView, &KonqHistoryView::openUrlInNewTab, this, &KonqHistoryDialog::slotOpenTab); KActionCollection *collection = m_historyView->actionCollection(); QToolBar *toolBar = new QToolBar(mainWidget()); toolBar->setToolButtonStyle(Qt::ToolButtonTextBesideIcon); QToolButton *sortButton = new QToolButton(toolBar); sortButton->setText(i18nc("@action:inmenu Parent of 'By Name' and 'By Date'", "Sort")); sortButton->setIcon(QIcon::fromTheme(QStringLiteral("view-sort-ascending"))); sortButton->setPopupMode(QToolButton::InstantPopup); sortButton->setToolButtonStyle(Qt::ToolButtonTextBesideIcon); QMenu *sortMenu = new QMenu(sortButton); sortMenu->addAction(collection->action(QStringLiteral("byName"))); sortMenu->addAction(collection->action(QStringLiteral("byDate"))); sortButton->setMenu(sortMenu); toolBar->addWidget(sortButton); toolBar->addSeparator(); toolBar->addAction(collection->action(QStringLiteral("preferences"))); mainLayout->addWidget(toolBar); mainLayout->addWidget(m_historyView); restoreDialogSize(KSharedConfig::openConfig()->group("History Dialog")); // give focus to the search line edit when opening the dialog (#240513) m_historyView->lineEdit()->setFocus(); }
void ConfigTaskPanelImpl::initDescription() { toolbar->setToolButtonStyle( Qt::ToolButtonIconOnly ); KActionCollection *collection = new KActionCollection( this ); //krazy:exclude=tipsandthis kcfg_Description->setRichTextSupport( KRichTextWidget::SupportBold | KRichTextWidget::SupportItalic | KRichTextWidget::SupportUnderline | KRichTextWidget::SupportStrikeOut | KRichTextWidget::SupportChangeListStyle | KRichTextWidget::SupportAlignment | KRichTextWidget::SupportFormatPainting ); collection->addActions(kcfg_Description->createActions()); toolbar->addAction( collection->action( "format_text_bold" ) ); toolbar->addAction( collection->action( "format_text_italic" ) ); toolbar->addAction( collection->action( "format_text_underline" ) ); toolbar->addAction( collection->action( "format_text_strikeout" ) ); toolbar->addSeparator(); toolbar->addAction( collection->action( "format_list_style" ) ); toolbar->addSeparator(); toolbar->addAction( collection->action( "format_align_left" ) ); toolbar->addAction( collection->action( "format_align_center" ) ); toolbar->addAction( collection->action( "format_align_right" ) ); toolbar->addAction( collection->action( "format_align_justify" ) ); toolbar->addSeparator(); // toolbar->addAction( collection->action( "format_painter" ) ); // kcfg_Description->append( "" ); kcfg_Description->setReadOnly( false ); kcfg_Description->setOverwriteMode( false ); kcfg_Description->setLineWrapMode( KTextEdit::WidgetWidth ); kcfg_Description->setTabChangesFocus( true ); }
void KOViewManager::goMenu( bool enable ) { KOrg::MainWindow *w = ActionManager::findInstance( KUrl() ); if ( w ) { KActionCollection *ac = w->getActionCollection(); if ( ac ) { QAction *action; action = ac->action( "go_today" ); if ( action ) { action->setEnabled( enable ); } action = ac->action( "go_previous" ); if ( action ) { action->setEnabled( enable ); } action = ac->action( "go_next" ); if ( action ) { action->setEnabled( enable ); } } } }
void MainWindow::initContextMenu() { m_contextMenu->clear(); //load helper actions (copied from kdetraystatus.cpp, with slight modification) //TODO: add a new function in m_defaultActionCollection to handle this? KActionCollection * helperActioncol = m_defaultActionCollection->helperActionCollection(); if ( helperActioncol->count() ) { for(size_t i=0; i<helperActioncol->count();i++) { helperActioncol->action(i)->plug(m_contextMenu); } m_contextMenu->insertSeparator(); } m_toggleDockingAction->plug(m_contextMenu); KAction* configureaction = m_defaultActionCollection->action( "configure" ); if(configureaction) configureaction->plug(m_contextMenu); KAction* helpAction = m_defaultActionCollection->action( "help" ); if(helpAction) helpAction->plug(m_contextMenu); }
SearchWidget::SearchWidget(SearchPlugin* sp) : webview(0), sp(sp), prog(0), torrent_download(0) { QVBoxLayout* layout = new QVBoxLayout(this); layout->setSpacing(0); layout->setMargin(0); webview = new WebView(this); KActionCollection* ac = sp->getSearchActivity()->part()->actionCollection(); sbar = new KToolBar(this); sbar->setToolButtonStyle(Qt::ToolButtonIconOnly); sbar->addAction(webview->pageAction(QWebPage::Back)); sbar->addAction(webview->pageAction(QWebPage::Forward)); sbar->addAction(webview->pageAction(QWebPage::Reload)); sbar->addAction(ac->action(QStringLiteral("search_home"))); search_text = new QLineEdit(sbar); sbar->addWidget(search_text); sbar->addAction(ac->action(QStringLiteral("search_tab_search"))); sbar->addWidget(new QLabel(i18n(" Engine:"))); search_engine = new KComboBox(sbar); search_engine->setModel(sp->getSearchEngineList()); sbar->addWidget(search_engine); connect(search_text, SIGNAL(returnPressed()), this, SLOT(search()));; layout->addWidget(sbar); layout->addWidget(webview); search_text->setClearButtonEnabled(true); connect(webview, SIGNAL(loadStarted()), this, SLOT(loadStarted())); connect(webview, SIGNAL(loadFinished(bool)), this, SLOT(loadFinished(bool))); connect(webview, SIGNAL(loadProgress(int)), this, SLOT(loadProgress(int))); connect(webview->page(), SIGNAL(unsupportedContent(QNetworkReply*)), this, SLOT(unsupportedContent(QNetworkReply*))); connect(webview, SIGNAL(linkMiddleOrCtrlClicked(QUrl)), this, SIGNAL(openNewTab(QUrl))); connect(webview, SIGNAL(iconChanged()), this, SLOT(iconChanged())); connect(webview, SIGNAL(titleChanged(QString)), this, SLOT(titleChanged(QString))); }
void CMapWidget::showPathContextMenu(void) { CMapPath *path = (CMapPath *) getView()->getSelectedElement(); bool twoWay = path->getOpsitePath(); KActionCollection *acol = getView()->actionCollection(); KToggleAction *pathTwoWay = (KToggleAction *)acol->action("pathTwoWay"); KToggleAction *pathOneWay = (KToggleAction *)acol->action("pathOneWay"); QAction *pathEditBends = acol->action("pathEditBends"); QAction *pathDelBend = acol->action("pathDelBend"); QAction *pathAddBend = acol->action("pathAddBend"); pathTwoWay->setChecked(twoWay); pathOneWay->setChecked(!twoWay); CMapView *view = (CMapView *) viewWidget; pathDelBend->setEnabled(path->mouseInPathSeg(selectedPos,view->getCurrentlyViewedZone())!=-1); pathEditBends->setEnabled(path->getBendCount() > 0); pathAddBend->setEnabled(path->getSrcRoom()->getZone()==path->getDestRoom()->getZone()); showContextMenu (path_menu); }
void TrayIcon::show() { if (status_notifier_item) { suspendStateChanged(core->getQueueManager()->getSuspendedState()); return; } status_notifier_item = new KStatusNotifierItem(mwnd); connect(status_notifier_item, SIGNAL(secondaryActivateRequested(QPoint)), this, SLOT(secondaryActivate(QPoint))); menu = status_notifier_item->contextMenu(); max_upload_rate = new SetMaxRate(core,SetMaxRate::UPLOAD,menu); max_upload_rate->setTitle(i18n("Set max upload speed")); max_download_rate = new SetMaxRate(core,SetMaxRate::DOWNLOAD,menu); max_download_rate->setTitle(i18n("Set max download speed")); menu->addMenu(max_download_rate); menu->addMenu(max_upload_rate); menu->addSeparator(); KActionCollection* ac = mwnd->getTorrentActivity()->part()->actionCollection(); menu->addAction(ac->action("start_all")); menu->addAction(ac->action("stop_all")); menu->addAction(ac->action("queue_suspend")); menu->addSeparator(); ac = mwnd->actionCollection(); menu->addAction(ac->action("paste_url")); menu->addAction(ac->action(KStandardAction::name(KStandardAction::Open))); menu->addSeparator(); menu->addAction(ac->action(KStandardAction::name(KStandardAction::Preferences))); menu->addSeparator(); status_notifier_item->setIconByName("ktorrent"); status_notifier_item->setCategory(KStatusNotifierItem::ApplicationStatus); status_notifier_item->setStatus(KStatusNotifierItem::Passive); status_notifier_item->setStandardActionsEnabled(true); status_notifier_item->setContextMenu(menu); queue_suspended = core->getQueueManager()->getSuspendedState(); if (queue_suspended) status_notifier_item->setOverlayIconByName("kt-pause"); }
void ViewManager::setupActions() { KActionCollection* collection = _actionCollection; KAction* nextViewAction = new KAction(i18nc("@action Shortcut entry", "Next Tab") , this); KAction* previousViewAction = new KAction(i18nc("@action Shortcut entry", "Previous Tab") , this); KAction* lastViewAction = new KAction(i18nc("@action Shortcut entry", "Switch to Last Tab") , this); KAction* nextContainerAction = new KAction(i18nc("@action Shortcut entry", "Next View Container") , this); KAction* moveViewLeftAction = new KAction(i18nc("@action Shortcut entry", "Move Tab Left") , this); KAction* moveViewRightAction = new KAction(i18nc("@action Shortcut entry", "Move Tab Right") , this); // list of actions that should only be enabled when there are multiple view // containers open QList<QAction*> multiViewOnlyActions; multiViewOnlyActions << nextContainerAction; if (collection) { KAction* splitLeftRightAction = new KAction(KIcon("view-split-left-right"), i18nc("@action:inmenu", "Split View Left/Right"), this); splitLeftRightAction->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_ParenLeft)); collection->addAction("split-view-left-right", splitLeftRightAction); connect(splitLeftRightAction , SIGNAL(triggered()) , this , SLOT(splitLeftRight())); KAction* splitTopBottomAction = new KAction(KIcon("view-split-top-bottom") , i18nc("@action:inmenu", "Split View Top/Bottom"), this); splitTopBottomAction->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_ParenRight)); collection->addAction("split-view-top-bottom", splitTopBottomAction); connect(splitTopBottomAction , SIGNAL(triggered()) , this , SLOT(splitTopBottom())); KAction* closeActiveAction = new KAction(i18nc("@action:inmenu Close Active View", "Close Active") , this); closeActiveAction->setIcon(KIcon("view-close")); closeActiveAction->setShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_S)); closeActiveAction->setEnabled(false); collection->addAction("close-active-view", closeActiveAction); connect(closeActiveAction , SIGNAL(triggered()) , this , SLOT(closeActiveView())); multiViewOnlyActions << closeActiveAction; KAction* closeOtherAction = new KAction(i18nc("@action:inmenu Close Other Views", "Close Others") , this); closeOtherAction->setShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_O)); closeOtherAction->setEnabled(false); collection->addAction("close-other-views", closeOtherAction); connect(closeOtherAction , SIGNAL(triggered()) , this , SLOT(closeOtherViews())); multiViewOnlyActions << closeOtherAction; KAction* detachViewAction = collection->addAction("detach-view"); detachViewAction->setIcon(KIcon("tab-detach")); detachViewAction->setText(i18nc("@action:inmenu", "D&etach Current Tab")); // Ctrl+Shift+D is not used as a shortcut by default because it is too close // to Ctrl+D - which will terminate the session in many cases detachViewAction->setShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_H)); connect(this , SIGNAL(splitViewToggle(bool)) , this , SLOT(updateDetachViewState())); connect(detachViewAction , SIGNAL(triggered()) , this , SLOT(detachActiveView())); // Expand & Shrink Active View KAction* expandActiveAction = new KAction(i18nc("@action:inmenu", "Expand View") , this); expandActiveAction->setShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_BracketRight)); expandActiveAction->setEnabled(false); collection->addAction("expand-active-view", expandActiveAction); connect(expandActiveAction , SIGNAL(triggered()) , this , SLOT(expandActiveView())); multiViewOnlyActions << expandActiveAction; KAction* shrinkActiveAction = new KAction(i18nc("@action:inmenu", "Shrink View") , this); shrinkActiveAction->setShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_BracketLeft)); shrinkActiveAction->setEnabled(false); collection->addAction("shrink-active-view", shrinkActiveAction); connect(shrinkActiveAction , SIGNAL(triggered()) , this , SLOT(shrinkActiveView())); multiViewOnlyActions << shrinkActiveAction; // Next / Previous View , Next Container collection->addAction("next-view", nextViewAction); collection->addAction("previous-view", previousViewAction); collection->addAction("last-tab", lastViewAction); collection->addAction("next-container", nextContainerAction); collection->addAction("move-view-left", moveViewLeftAction); collection->addAction("move-view-right", moveViewRightAction); // Switch to tab N shortcuts const int SWITCH_TO_TAB_COUNT = 10; QSignalMapper* switchToTabMapper = new QSignalMapper(this); connect(switchToTabMapper, SIGNAL(mapped(int)), this, SLOT(switchToView(int))); for (int i = 0; i < SWITCH_TO_TAB_COUNT; i++) { KAction* switchToTabAction = new KAction(i18nc("@action Shortcut entry", "Switch to Tab %1", i + 1), this); switchToTabMapper->setMapping(switchToTabAction, i); connect(switchToTabAction, SIGNAL(triggered()), switchToTabMapper, SLOT(map())); collection->addAction(QString("switch-to-tab-%1").arg(i), switchToTabAction); } } QListIterator<QAction*> iter(multiViewOnlyActions); while (iter.hasNext()) { connect(this , SIGNAL(splitViewToggle(bool)) , iter.next() , SLOT(setEnabled(bool))); } // keyboard shortcut only actions nextViewAction->setShortcut(QKeySequence(Qt::SHIFT + Qt::Key_Right)); connect(nextViewAction, SIGNAL(triggered()) , this , SLOT(nextView())); _viewSplitter->addAction(nextViewAction); previousViewAction->setShortcut(QKeySequence(Qt::SHIFT + Qt::Key_Left)); connect(previousViewAction, SIGNAL(triggered()) , this , SLOT(previousView())); _viewSplitter->addAction(previousViewAction); nextContainerAction->setShortcut(QKeySequence(Qt::SHIFT + Qt::Key_Tab)); connect(nextContainerAction , SIGNAL(triggered()) , this , SLOT(nextContainer())); _viewSplitter->addAction(nextContainerAction); moveViewLeftAction->setShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_Left)); connect(moveViewLeftAction , SIGNAL(triggered()) , this , SLOT(moveActiveViewLeft())); _viewSplitter->addAction(moveViewLeftAction); moveViewRightAction->setShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_Right)); connect(moveViewRightAction , SIGNAL(triggered()) , this , SLOT(moveActiveViewRight())); _viewSplitter->addAction(moveViewRightAction); connect(lastViewAction, SIGNAL(triggered()) , this , SLOT(lastView())); _viewSplitter->addAction(lastViewAction); }
void JuK::setupActions() { KActionCollection *collection = ActionCollection::actions(); // Setup KDE standard actions that JuK uses. KStandardAction::quit(this, SLOT(slotQuit()), collection); KStandardAction::undo(this, SLOT(slotUndo()), collection); KStandardAction::cut(collection); KStandardAction::copy(collection); KStandardAction::paste(collection); KAction *clear = KStandardAction::clear(collection); KStandardAction::selectAll(collection); KStandardAction::keyBindings(this, SLOT(slotEditKeys()), collection); // Setup the menu which handles the random play options. KActionMenu *actionMenu = collection->add<KActionMenu>("actionMenu"); actionMenu->setText(i18n("&Random Play")); actionMenu->setIcon(KIcon( QLatin1String( "media-playlist-shuffle" ))); actionMenu->setDelayed(false); QActionGroup* randomPlayGroup = new QActionGroup(this); QAction *act = collection->add<KToggleAction>("disableRandomPlay"); act->setText(i18n("&Disable Random Play")); act->setIcon(KIcon( QLatin1String( "go-down" ))); act->setActionGroup(randomPlayGroup); actionMenu->addAction(act); m_randomPlayAction = collection->add<KToggleAction>("randomPlay"); m_randomPlayAction->setText(i18n("Use &Random Play")); m_randomPlayAction->setIcon(KIcon( QLatin1String( "media-playlist-shuffle" ))); m_randomPlayAction->setActionGroup(randomPlayGroup); actionMenu->addAction(m_randomPlayAction); act = collection->add<KToggleAction>("albumRandomPlay"); act->setText(i18n("Use &Album Random Play")); act->setIcon(KIcon( QLatin1String( "media-playlist-shuffle" ))); act->setActionGroup(randomPlayGroup); connect(act, SIGNAL(triggered(bool)), SLOT(slotCheckAlbumNextAction(bool))); actionMenu->addAction(act); act = collection->addAction("removeFromPlaylist", clear, SLOT(clear())); act->setText(i18n("Remove From Playlist")); act->setIcon(KIcon( QLatin1String( "list-remove" ))); act = collection->add<KToggleAction>("crossfadeTracks"); act->setText(i18n("Crossfade Between Tracks")); connect(act, SIGNAL(triggered(bool)), m_player, SLOT(setCrossfadeEnabled(bool))); act = collection->addAction("play", m_player, SLOT(play())); act->setText(i18n("&Play")); act->setIcon(KIcon( QLatin1String( "media-playback-start" ))); act = collection->addAction("pause", m_player, SLOT(pause())); act->setText(i18n("P&ause")); act->setIcon(KIcon( QLatin1String( "media-playback-pause" ))); act = collection->addAction("stop", m_player, SLOT(stop())); act->setText(i18n("&Stop")); act->setIcon(KIcon( QLatin1String( "media-playback-stop" ))); act = new KToolBarPopupAction(KIcon( QLatin1String( "media-skip-backward") ), i18nc("previous track", "Previous" ), collection); collection->addAction("back", act); connect(act, SIGNAL(triggered(bool)), m_player, SLOT(back())); act = collection->addAction("forward", m_player, SLOT(forward())); act->setText(i18nc("next track", "&Next")); act->setIcon(KIcon( QLatin1String( "media-skip-forward" ))); act = collection->addAction("loopPlaylist"); act->setText(i18n("&Loop Playlist")); act->setCheckable(true); act = collection->add<KToggleAction>("resizeColumnsManually"); act->setText(i18n("&Resize Playlist Columns Manually")); // the following are not visible by default act = collection->addAction("mute", m_player, SLOT(mute())); act->setText(i18nc("silence playback", "Mute")); act->setIcon(KIcon( QLatin1String( "audio-volume-muted" ))); act = collection->addAction("volumeUp", m_player, SLOT(volumeUp())); act->setText(i18n("Volume Up")); act->setIcon(KIcon( QLatin1String( "audio-volume-high" ))); act = collection->addAction("volumeDown", m_player, SLOT(volumeDown())); act->setText(i18n("Volume Down")); act->setIcon(KIcon( QLatin1String( "audio-volume-low" ))); act = collection->addAction("playPause", m_player, SLOT(playPause())); act->setText(i18n("Play / Pause")); act->setIcon(KIcon( QLatin1String( "media-playback-start" ))); act = collection->addAction("seekForward", m_player, SLOT(seekForward())); act->setText(i18n("Seek Forward")); act->setIcon(KIcon( QLatin1String( "media-seek-forward" ))); act = collection->addAction("seekBack", m_player, SLOT(seekBack())); act->setText(i18n("Seek Back")); act->setIcon(KIcon( QLatin1String( "media-seek-backward" ))); act = collection->addAction("showHide", this, SLOT(slotShowHide())); act->setText(i18n("Show / Hide")); ////////////////////////////////////////////////// // settings menu ////////////////////////////////////////////////// m_toggleSplashAction = collection->add<KToggleAction>("showSplashScreen"); m_toggleSplashAction->setText(i18n("Show Splash Screen on Startup")); m_toggleSystemTrayAction = collection->add<KToggleAction>("toggleSystemTray"); m_toggleSystemTrayAction->setText(i18n("&Dock in System Tray")); connect(m_toggleSystemTrayAction, SIGNAL(triggered(bool)), SLOT(slotToggleSystemTray(bool))); m_toggleDockOnCloseAction = collection->add<KToggleAction>("dockOnClose"); m_toggleDockOnCloseAction->setText(i18n("&Stay in System Tray on Close")); m_togglePopupsAction = collection->add<KToggleAction>("togglePopups"); m_togglePopupsAction->setText(i18n("Popup &Track Announcement")); act = collection->add<KToggleAction>("saveUpcomingTracks"); act->setText(i18n("Save &Play Queue on Exit")); act = collection->addAction("tagGuesserConfig", this, SLOT(slotConfigureTagGuesser())); act->setText(i18n("&Tag Guesser...")); act = collection->addAction("fileRenamerConfig", this, SLOT(slotConfigureFileRenamer())); act->setText(i18n("&File Renamer...")); act = collection->addAction("scrobblerConfig", this, SLOT(slotConfigureScrobbling())); act->setText(i18n("&Configure scrobbling...")); ////////////////////////////////////////////////// // just in the toolbar ////////////////////////////////////////////////// collection->addAction("trackPositionAction", new TrackPositionAction(i18n("Track Position"), this)); collection->addAction("volumeAction", new VolumeAction(i18n("Volume"), this)); ActionCollection::actions()->addAssociatedWidget(this); foreach (QAction* action, ActionCollection::actions()->actions()) action->setShortcutContext(Qt::WidgetWithChildrenShortcut); }
KrViewer::KrViewer(QWidget *parent) : KParts::MainWindow(parent, (Qt::WindowFlags)KDE_DEFAULT_WINDOWFLAGS), manager(this, this), tabBar(this), reservedKeys(), reservedKeyActions(), sizeX(-1), sizeY(-1) { //setWFlags(Qt::WType_TopLevel | WDestructiveClose); setXMLFile("krviewer.rc"); // kpart-related xml file setHelpMenuEnabled(false); connect(&manager, SIGNAL(activePartChanged(KParts::Part*)), this, SLOT(createGUI(KParts::Part*))); connect(&tabBar, &QTabWidget::currentChanged, this, &KrViewer::tabChanged); connect(&tabBar, SIGNAL(tabCloseRequested(int)), this, SLOT(tabCloseRequest(int))); tabBar.setDocumentMode(true); tabBar.setMovable(true); setCentralWidget(&tabBar); printAction = KStandardAction::print(this, SLOT(print()), 0); copyAction = KStandardAction::copy(this, SLOT(copy()), 0); viewerMenu = new QMenu(this); QAction *tempAction; KActionCollection *ac = actionCollection(); #define addCustomMenuAction(name, text, slot, shortcut)\ tempAction = ac->addAction(name, this, slot);\ tempAction->setText(text);\ ac->setDefaultShortcut(tempAction, shortcut);\ viewerMenu->addAction(tempAction); addCustomMenuAction("genericViewer", i18n("&Generic Viewer"), SLOT(viewGeneric()), Qt::CTRL + Qt::SHIFT + Qt::Key_G); addCustomMenuAction("textViewer", i18n("&Text Viewer"), SLOT(viewText()), Qt::CTRL + Qt::SHIFT + Qt::Key_T); addCustomMenuAction("hexViewer", i18n("&Hex Viewer"), SLOT(viewHex()), Qt::CTRL + Qt::SHIFT + Qt::Key_H); addCustomMenuAction("lister", i18n("&Lister"), SLOT(viewLister()), Qt::CTRL + Qt::SHIFT + Qt::Key_L); viewerMenu->addSeparator(); addCustomMenuAction("textEditor", i18n("Text &Editor"), SLOT(editText()), Qt::CTRL + Qt::SHIFT + Qt::Key_E); viewerMenu->addSeparator(); QList<QAction *> actList = menuBar()->actions(); bool hasPrint = false, hasCopy = false; foreach(QAction *a, actList) { if (a->shortcut().matches(printAction->shortcut()) != QKeySequence::NoMatch) hasPrint = true; if (a->shortcut().matches(copyAction->shortcut()) != QKeySequence::NoMatch) hasCopy = true; } QAction *printAct = viewerMenu->addAction(printAction->icon(), printAction->text(), this, SLOT(print())); if (hasPrint) printAct->setShortcut(printAction->shortcut()); QAction *copyAct = viewerMenu->addAction(copyAction->icon(), copyAction->text(), this, SLOT(copy())); if (hasCopy) copyAct->setShortcut(copyAction->shortcut()); viewerMenu->addSeparator(); configKeysAction = ac->addAction(KStandardAction::KeyBindings, this, SLOT(configureShortcuts())); viewerMenu->addAction(configKeysAction); viewerMenu->addSeparator(); detachAction = ac->addAction("detachTab", this, SLOT(detachTab())); detachAction->setText(i18n("&Detach Tab")); //no point in detaching only one tab.. detachAction->setEnabled(false); ac->setDefaultShortcut(detachAction, Qt::META + Qt::Key_D); viewerMenu->addAction(detachAction); quitAction = ac->addAction(KStandardAction::Quit, this, SLOT(close())); viewerMenu->addAction(quitAction); tabCloseAction = ac->addAction("closeTab", this, SLOT(tabCloseRequest())); tabCloseAction->setText(i18n("&Close Current Tab")); QList<QKeySequence> shortcuts = KStandardShortcut::close(); shortcuts.append(Qt::Key_Escape); ac->setDefaultShortcuts(tabCloseAction, shortcuts); tabNextAction = ac->addAction("nextTab", this, SLOT(nextTab())); tabNextAction->setText(i18n("&Next Tab")); ac->setDefaultShortcuts(tabNextAction, KStandardShortcut::tabNext()); tabPrevAction = ac->addAction("prevTab", this, SLOT(prevTab())); tabPrevAction->setText(i18n("&Previous Tab")); ac->setDefaultShortcuts(tabPrevAction, KStandardShortcut::tabPrev()); tabBar.setTabsClosable(true); checkModified(); KConfigGroup group(krConfig, "KrViewerWindow"); int sx = group.readEntry("Window Width", -1); int sy = group.readEntry("Window Height", -1); if (sx != -1 && sy != -1) resize(sx, sy); else resize(900, 700); if (group.readEntry("Window Maximized", false)) { setWindowState(windowState() | Qt::WindowMaximized); } // filtering out the key events menuBar() ->installEventFilter(this); }
ViewConfigController::ViewConfigController( KXMLGUIClient* guiClient ) : mByteArrayView( 0 ) { KActionCollection* actionCollection = guiClient->actionCollection(); // Offset coding mOffsetCodingAction = actionCollection->add<KSelectAction>( QStringLiteral("view_offsetcoding") ); mOffsetCodingAction->setText( i18nc("@title:menu","&Offset Coding") ); QStringList list; list.append( i18nc("@item:inmenu offset in the hexadecimal format", "&Hexadecimal") ); list.append( i18nc("@item:inmenu offset in the decimal format", "&Decimal") ); mOffsetCodingAction->setItems( list ); connect( mOffsetCodingAction, static_cast<void (KSelectAction::*)(int)>(&KSelectAction::triggered), this, &ViewConfigController::setOffsetCoding ); // value valueCoding mCodingAction = actionCollection->add<KSelectAction>( QStringLiteral("view_valuecoding") ); mCodingAction->setText( i18nc("@title:menu","&Value Coding") ); list.clear(); list.append( i18nc("@item:inmenu encoding of the bytes as values in the hexadecimal format", "&Hexadecimal") ); list.append( i18nc("@item:inmenu encoding of the bytes as values in the decimal format", "&Decimal") ); list.append( i18nc("@item:inmenu encoding of the bytes as values in the octal format", "&Octal") ); list.append( i18nc("@item:inmenu encoding of the bytes as values in the binary format", "&Binary") ); mCodingAction->setItems( list ); connect( mCodingAction, static_cast<void (KSelectAction::*)(int)>(&KSelectAction::triggered), this, &ViewConfigController::setValueCoding ); // char valueCoding mEncodingAction = actionCollection->add<KSelectAction>( QStringLiteral("view_charencoding") ); mEncodingAction->setText( i18nc("@title:menu","&Char Coding") ); mEncodingAction->setItems( Okteta::CharCodec::codecNames() ); connect( mEncodingAction, static_cast<void (KSelectAction::*)(int)>(&KSelectAction::triggered), this, &ViewConfigController::setCharCoding ); mShowsNonprintingAction = actionCollection->add<KToggleAction>( QStringLiteral("view_showsnonprinting") ); mShowsNonprintingAction->setText( i18nc("@option:check","Show &Non-printing Chars") ); connect( mShowsNonprintingAction, &KToggleAction::triggered, this, &ViewConfigController::setShowsNonprinting ); // bytes per line mSetBytesPerLineAction = actionCollection->addAction( QStringLiteral("view_bytesperline"), this, SLOT(setBytesPerLine()) ); mSetBytesPerLineAction->setText( i18nc("@action:inmenu","Set Bytes per Line...") ); // byte groups size mSetBytesPerGroupAction = actionCollection->addAction( QStringLiteral("view_bytespergroup"), this, SLOT(setBytesPerGroup()) ); mSetBytesPerGroupAction->setText( i18nc("@action:inmenu","Set Bytes per Group...") ); // resize style mResizeStyleAction = actionCollection->add<KSelectAction>( QStringLiteral("resizestyle") ); mResizeStyleAction->setText( i18nc("@title:menu","&Dynamic Layout") ); list.clear(); list.append( i18nc("@item:inmenu The layout will not change on size changes.", "&Off") ); list.append( i18nc("@item:inmenu The layout will adapt to the size, but only with complete groups of bytes.", "&Wrap Only Complete Byte Groups") ); list.append( i18nc("@item:inmenu The layout will adapt to the size and fit in as much bytes per line as possible.", "&On") ); mResizeStyleAction->setItems( list ); connect( mResizeStyleAction, static_cast<void (KSelectAction::*)(int)>(&KSelectAction::triggered), this, &ViewConfigController::setLayoutStyle ); mShowOffsetColumnAction = actionCollection->add<KToggleAction>( QStringLiteral("view_lineoffset") ); mShowOffsetColumnAction->setText( i18nc("@option:check","Show &Line Offset") ); actionCollection->setDefaultShortcut( mShowOffsetColumnAction, Qt::Key_F11 ); connect( mShowOffsetColumnAction, &KToggleAction::triggered, this, &ViewConfigController::toggleOffsetColumn ); // show buffer columns mToggleColumnsAction = actionCollection->add<KSelectAction>( QStringLiteral("togglecolumns") ); mToggleColumnsAction->setText( i18nc("@title:menu","&Show Values or Chars") ); list.clear(); list.append( i18nc("@item:inmenu","&Values") ); list.append( i18nc("@item:inmenu","&Chars") ); list.append( i18nc("@item:inmenu","Values && Chars") ); mToggleColumnsAction->setItems( list ); connect( mToggleColumnsAction, static_cast<void (KSelectAction::*)(int)>(&KSelectAction::triggered), this, &ViewConfigController::toggleValueCharColumns ); setTargetModel( 0 ); }