void ActionManagerImpl::initTabWidget(TabWidget* tabWidget)
{
if (d->tabWidget)
return;
else
d->tabWidget = tabWidget;
KActionCollection *coll = actionCollection();
KAction *action = coll->addAction("select_next_tab");
action->setText(i18n("Select Next Tab"));
connect(action, SIGNAL(triggered(bool)), d->tabWidget, SLOT(slotNextTab()));
action->setShortcuts(KShortcut( "Ctrl+Period" ));
action = coll->addAction("select_previous_tab");
action->setText(i18n("Select Previous Tab"));
connect(action, SIGNAL(triggered(bool)), d->tabWidget, SLOT(slotPreviousTab()));
action->setShortcuts(KShortcut( "Ctrl+Comma" ));
action = coll->addAction("tab_detach");
action->setIcon(KIcon("tab-detach"));
action->setText(i18n("Detach Tab"));
connect(action, SIGNAL(triggered(bool)), d->tabWidget, SLOT(slotDetachTab()));
action->setShortcut(QKeySequence(Qt::CTRL+Qt::SHIFT+Qt::Key_B));
action = coll->addAction("tab_copylinkaddress");
action->setText(i18n("Copy Link Address"));
connect(action, SIGNAL(triggered(bool)), d->tabWidget, SLOT(slotCopyLinkAddress()));
action = coll->addAction("tab_remove");
action->setIcon(KIcon("tab-close"));
action->setText(i18n("Close Tab"));
connect(action, SIGNAL(triggered(bool)), d->tabWidget, SLOT(slotCloseTab()));
action->setShortcuts(KStandardShortcut::close());
action = coll->addAction("inc_font_sizes");
action->setIcon(KIcon("format-font-size-more"));
action->setText(i18n("Enlarge Font"));
connect(action, SIGNAL(triggered(bool)), d->tabWidget, SLOT(slotFrameZoomIn()));
action->setShortcut( QKeySequence::ZoomIn );
action = coll->addAction("dec_font_sizes");
action->setIcon(KIcon("format-font-size-less"));
action->setText(i18n("Shrink Font"));
connect(action, SIGNAL(triggered(bool)), d->tabWidget, SLOT(slotFrameZoomOut()));
action->setShortcut( QKeySequence::ZoomOut );
QString actionname;
for (int i=1;i<10;i++) {
actionname.sprintf("activate_tab_%02d", i);
action = new KAction( i18n("Activate Tab %1", i),this );
action->setShortcut( QKeySequence( QString::fromLatin1( "Alt+%1" ).arg( i ) ) );
coll->addAction( actionname, action );
connect( action, SIGNAL(triggered(bool)), d->tabWidget, SLOT(slotActivateTab()) );
}
}
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 TorrentActivity::setupActions()
{
KActionCollection* ac = part()->actionCollection();
start_all_action = new QAction(QIcon::fromTheme(QStringLiteral("kt-start-all")), i18n("Start All"), this);
start_all_action->setToolTip(i18n("Start all torrents"));
connect(start_all_action, &QAction::triggered, this, &TorrentActivity::startAllTorrents);
ac->addAction(QStringLiteral("start_all"), start_all_action);
stop_all_action = new QAction(QIcon::fromTheme(QStringLiteral("kt-stop-all")), i18n("Stop All"), this);
stop_all_action->setToolTip(i18n("Stop all torrents"));
connect(stop_all_action, &QAction::triggered, this, &TorrentActivity::stopAllTorrents);
ac->addAction(QStringLiteral("stop_all"), stop_all_action);
queue_suspend_action = new KToggleAction(QIcon::fromTheme(QStringLiteral("kt-pause")), i18n("Suspend Torrents"), this);
ac->addAction(QStringLiteral("queue_suspend"), queue_suspend_action);
ac->setDefaultShortcut(queue_suspend_action, QKeySequence(Qt::SHIFT + Qt::Key_P));
queue_suspend_action->setToolTip(i18n("Suspend all running torrents"));
//KF5 queue_suspend_action->setGlobalShortcut(QKeySequence(Qt::ALT + Qt::SHIFT + Qt::Key_P));
connect(queue_suspend_action, &KToggleAction::toggled, this, &TorrentActivity::suspendQueue);
show_group_view_action = new KToggleAction(QIcon::fromTheme(QStringLiteral("view-list-tree")), i18n("Group View"), this);
show_group_view_action->setToolTip(i18n("Show or hide the group view"));
connect(show_group_view_action, &QAction::toggled, this, &TorrentActivity::setGroupViewVisible);
ac->addAction(QStringLiteral("show_group_view"), show_group_view_action);
filter_torrent_action = new QAction(i18n("Filter Torrents"), this);
filter_torrent_action->setToolTip(i18n("Filter torrents based on filter string"));
connect(filter_torrent_action, &QAction::triggered, search_bar, &TorrentSearchBar::showBar);
ac->addAction(QStringLiteral("filter_torrent"), filter_torrent_action);
ac->setDefaultShortcut(filter_torrent_action, QKeySequence(Qt::CTRL + Qt::Key_F));
view->setupActions(ac);
}
void GUI::setupActions()
{
KActionCollection* ac = actionCollection();
KAction* new_action = KStandardAction::openNew(this, SLOT(createTorrent()), ac);
new_action->setToolTip(i18n("Create a new torrent"));
KAction* 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 KAction(KIcon(open_action->icon()), i18n("Open Silently"), this);
open_silently_action->setToolTip(i18n("Open a torrent without asking any questions"));
connect(open_silently_action, SIGNAL(triggered()), this, SLOT(openTorrentSilently()));
ac->addAction("file_open_silently", open_silently_action);
KStandardAction::quit(this, SLOT(quit()), ac);
show_status_bar_action = KStandardAction::showStatusbar(this, SLOT(showStatusBar()), ac);
show_status_bar_action->setIcon(KIcon("kt-show-statusbar"));
show_menu_bar_action = KStandardAction::showMenubar(this, SLOT(showMenuBar()), 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 KAction(KIcon("document-open-remote"), i18n("Open URL"), this);
paste_url_action->setToolTip(i18n("Open a URL which points to a torrent, magnet links are supported"));
paste_url_action->setShortcut(KShortcut(Qt::CTRL + Qt::Key_P));
connect(paste_url_action, SIGNAL(triggered()), this, SLOT(pasteURL()));
ac->addAction("paste_url", paste_url_action);
ipfilter_action = new KAction(KIcon("view-filter"), i18n("IP Filter"), this);
ipfilter_action->setToolTip(i18n("Show the list of blocked IP addresses"));
ipfilter_action->setShortcut(KShortcut(Qt::CTRL + Qt::Key_I));
connect(ipfilter_action, SIGNAL(triggered()), this, SLOT(showIPFilter()));
ac->addAction("ipfilter_action", ipfilter_action);
import_action = new KAction(KIcon("document-import"), i18n("Import Torrent"), this);
import_action->setToolTip(i18n("Import a torrent"));
import_action->setShortcut(KShortcut(Qt::SHIFT + Qt::Key_I));
connect(import_action, SIGNAL(triggered()), this, SLOT(import()));
ac->addAction("import", import_action);
show_kt_action = new KAction(KIcon("kt-show-hide"), i18n("Show/Hide KTorrent"), this);
connect(show_kt_action, SIGNAL(triggered()), this, SLOT(showOrHide()));
ac->addAction("show_kt", show_kt_action);
show_kt_action->setGlobalShortcut(KShortcut(Qt::ALT + Qt::SHIFT + Qt::Key_T));
setStandardToolBarMenuEnabled(true);
}
void SearchActivity::setupActions()
{
KActionCollection* ac = part()->actionCollection();
search_action = new KAction(KIcon("edit-find"),i18n("Search"),this);
connect(search_action,SIGNAL(triggered()),this,SLOT(search()));
ac->addAction("search_tab_search",search_action);
find_action = KStandardAction::find(this,SLOT(find()),this);
ac->addAction("search_tab_find",find_action);
home_action = KStandardAction::home(this,SLOT(home()),this);
ac->addAction("search_home",home_action);
}
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();
}
void KisColorSelectorNgDockerWidget::setCanvas(KisCanvas2 *canvas)
{
if (m_canvas) {
m_canvas->disconnect(this);
KActionCollection *ac = m_canvas->viewManager()->actionCollection();
ac->takeAction(ac->action("show_color_history"));
ac->takeAction(ac->action("show_common_colors"));
}
m_canvas = canvas;
m_commonColorsWidget->setCanvas(canvas);
m_colorHistoryWidget->setCanvas(canvas);
m_colorSelectorContainer->setCanvas(canvas);
if (m_canvas && m_canvas->viewManager()) {
if (m_canvas->viewManager()->nodeManager()) {
connect(m_canvas->viewManager()->nodeManager(), SIGNAL(sigLayerActivated(KisLayerSP)), SLOT(reactOnLayerChange()), Qt::UniqueConnection);
}
KActionCollection* actionCollection = canvas->viewManager()->actionCollection();
actionCollection->addAction("show_color_history", m_colorHistoryAction);
actionCollection->addAction("show_common_colors", m_commonColorsAction);
}
reactOnLayerChange();
}
WindowGeometry::WindowGeometry()
{
iAmActivated = true;
iAmActive = false;
myResizeWindow = 0L;
#define myResizeString "Window geometry display, %1 and %2 are the new size," \
" %3 and %4 are pixel increments - avoid reformatting or suffixes like 'px'", \
"Width: %1 (%3)\nHeight: %2 (%4)"
#define myCoordString_0 "Window geometry display, %1 and %2 are the cartesian x and y coordinates" \
" - avoid reformatting or suffixes like 'px'", \
"X: %1\nY: %2"
#define myCoordString_1 "Window geometry display, %1 and %2 are the cartesian x and y coordinates," \
" %3 and %4 are the resp. increments - avoid reformatting or suffixes like 'px'", \
"X: %1 (%3)\nY: %2 (%4)"
reconfigure(ReconfigureAll);
QFont fnt; fnt.setBold(true); fnt.setPointSize(12);
for (int i = 0; i < 3; ++i) {
myMeasure[i] = effects->effectFrame(EffectFrameUnstyled, false);
myMeasure[i]->setFont(fnt);
}
myMeasure[0]->setAlignment(Qt::AlignLeft | Qt::AlignTop);
myMeasure[1]->setAlignment(Qt::AlignCenter);
myMeasure[2]->setAlignment(Qt::AlignRight | Qt::AlignBottom);
KActionCollection* actionCollection = new KActionCollection(this);
KAction* a = static_cast< KAction* >(actionCollection->addAction("WindowGeometry"));
a->setText(i18n("Toggle window geometry display (effect only)"));
a->setGlobalShortcut(KShortcut(Qt::CTRL + Qt::SHIFT + Qt::Key_F11));
connect(a, SIGNAL(triggered(bool)), this, SLOT(toggle()));
connect(effects, SIGNAL(windowStartUserMovedResized(KWin::EffectWindow*)), this, SLOT(slotWindowStartUserMovedResized(KWin::EffectWindow*)));
connect(effects, SIGNAL(windowFinishUserMovedResized(KWin::EffectWindow*)), this, SLOT(slotWindowFinishUserMovedResized(KWin::EffectWindow*)));
connect(effects, SIGNAL(windowStepUserMovedResized(KWin::EffectWindow*,QRect)), this, SLOT(slotWindowStepUserMovedResized(KWin::EffectWindow*,QRect)));
}
KAction *create(StandardAction id, const QObject *recvr, const char *slot, QObject *parent)
{
KAction *pAction = 0;
const Info* pInfo = infoPtr(id);
if (pInfo) {
pAction = new KAction(parent);
pAction->setObjectName(pInfo->psName);
KShortcut cut(pInfo->shortcut);
if (!cut.isEmpty())
pAction->setShortcut(cut);
pAction->setText(i18n(pInfo->psText));
pAction->setToolTip(i18n(pInfo->psToolTip));
pAction->setWhatsThis(i18n(pInfo->psWhatsThis));
if (pInfo->psIconName)
pAction->setIcon(KIcon(QLatin1String(pInfo->psIconName)));
}
if (recvr && slot)
QObject::connect(pAction, SIGNAL(triggered(bool)), recvr, slot);
if (pAction) {
KActionCollection *collection = qobject_cast<KActionCollection *>(parent);
if (collection)
collection->addAction(pAction->objectName(), pAction);
}
return pAction;
}
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 SyndicationPlugin::setupActions()
{
KActionCollection* ac = actionCollection();
add_feed = new KAction(KIcon("kt-add-feeds"), i18n("Add Feed"), this);
ac->addAction("add_feed", add_feed);
remove_feed = new KAction(KIcon("kt-remove-feeds"), i18n("Remove Feed"), this);
ac->addAction("remove_feed", remove_feed);
manage_filters = new KAction(KIcon("view-filter"), i18n("Add/Remove Filters"), this);
ac->addAction("manage_filters", manage_filters);
edit_feed_name = new KAction(KIcon("edit-rename"), i18n("Rename"), this);
ac->addAction("edit_feed_name", edit_feed_name);
add_filter = new KAction(KIcon("kt-add-filters"), i18n("Add Filter"), this);
ac->addAction("add_filter", add_filter);
remove_filter = new KAction(KIcon("kt-remove-filters"), i18n("Remove Filter"), this);
ac->addAction("remove_filter", remove_filter);
edit_filter = new KAction(KIcon("preferences-other"), i18n("Edit Filter"), this);
ac->addAction("edit_filter", edit_filter);
remove_filter->setEnabled(false);
edit_filter->setEnabled(false);
remove_feed->setEnabled(false);
manage_filters->setEnabled(false);
}
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);
}
ThumbnailAsideEffect::ThumbnailAsideEffect()
{
KActionCollection* actionCollection = new KActionCollection( this );
KAction* a = (KAction*)actionCollection->addAction( "ToggleCurrentThumbnail" );
a->setText( i18n("Toggle Thumbnail for Current Window" ));
a->setGlobalShortcut(KShortcut(Qt::CTRL + Qt::META + Qt::Key_T));
connect(a, SIGNAL(triggered(bool)), this, SLOT(toggleCurrentThumbnail()));
reconfigure( ReconfigureAll );
}
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();
}
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)));
}
VideoRecordEffect::VideoRecordEffect()
: client( NULL )
{
KActionCollection* actionCollection = new KActionCollection( this );
KAction* a = static_cast< KAction* >( actionCollection->addAction( "VideoRecord" ));
a->setText( i18n("Toggle Video Recording" ));
a->setGlobalShortcut( KShortcut( Qt::CTRL + Qt::META + Qt::Key_V ));
connect( a, SIGNAL( triggered( bool )), this, SLOT( toggleRecording()));
area = QRect( 0, 0, displayWidth(), displayHeight());
}
void KDEDKSysGuard::init()
{
KActionCollection* actionCollection = new KActionCollection(this);
QAction* action = actionCollection->addAction(QStringLiteral("Show System Activity"));
action->setText(i18n("Show System Activity"));
connect(action, &QAction::triggered, this, &KDEDKSysGuard::showTaskManager);
KGlobalAccel::self()->setGlobalShortcut(action, QKeySequence(Qt::CTRL + Qt::Key_Escape));
}
void ClangSupport::createActionsForMainWindow (Sublime::MainWindow* /*window*/, QString& _xmlFile, KActionCollection& actions)
{
_xmlFile = xmlFile();
QAction* renameDeclarationAction = actions.addAction(QStringLiteral("code_rename_declaration"));
renameDeclarationAction->setText( i18n("Rename Declaration") );
renameDeclarationAction->setIcon(QIcon::fromTheme(QStringLiteral("edit-rename")));
actions.setDefaultShortcut(renameDeclarationAction, Qt::CTRL | Qt::SHIFT | Qt::Key_R);
connect(renameDeclarationAction, &QAction::triggered,
m_refactoring, &BasicRefactoring::executeRenameAction);
}
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
}
ViewProfilesManageController::ViewProfilesManageController( KXMLGUIClient* guiClient,
ByteArrayViewProfileManager* viewProfileManager,
QWidget* parentWidget )
: mParentWidget( parentWidget ),
mViewProfileManager( viewProfileManager )
{
KActionCollection* actionCollection = guiClient->actionCollection();
mManageAction = actionCollection->addAction( QLatin1String("settings_profiles_manage"),
this, SLOT(manageProfiles()) );
mManageAction->setText( i18nc("@action:inmenu",
"Manage View Profiles...") );
}
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);
}
}
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;
}
// 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 EditActions::setupActions() {
KActionCollection* actionCollection = mTutorialEditor->actionCollection();
mUndoStack->createUndoAction(actionCollection);
mUndoStack->createRedoAction(actionCollection);
KAction* action = new KAction(this);
action->setText(i18nc("@action", "Set information..."));
action->setStatusTip(i18nc("@info:status", "Set the name and description "
"of the tutorial."));
action->setIcon(KIcon("documentinfo"));
actionCollection->addAction("setTutorialInformation", action);
connect(action, SIGNAL(triggered(bool)),
this, SLOT(setTutorialInformation()));
action = new KAction(this);
action->setText(i18nc("@action", "Set license..."));
action->setStatusTip(i18nc("@info:status", "Set the license text of the "
"tutorial."));
action->setIcon(KIcon("document-edit"));
actionCollection->addAction("setTutorialLicense", action);
connect(action, SIGNAL(triggered(bool)), this, SLOT(setTutorialLicense()));
action = new KAction(this);
action->setText(i18nc("@action", "Set setup code..."));
action->setStatusTip(i18nc("@info:status", "Set the custom code to be "
"executed when the tutorial starts."));
action->setIcon(KIcon("code-function"));
actionCollection->addAction("setTutorialSetup", action);
connect(action, SIGNAL(triggered(bool)), this, SLOT(setTutorialSetup()));
action = new KAction(this);
action->setText(i18nc("@action", "Set tear down code..."));
action->setStatusTip(i18nc("@info:status", "Set the custom code to be "
"executed when the tutorial finishes."));
action->setIcon(KIcon("code-function"));
actionCollection->addAction("setTutorialTearDown", action);
connect(action, SIGNAL(triggered(bool)), this, SLOT(setTutorialTearDown()));
action = new KAction(this);
action->setText(i18nc("@action", "Add step..."));
action->setStatusTip(i18nc("@info:status", "Add a new step to the "
"tutorial."));
action->setIcon(KIcon("list-add"));
actionCollection->addAction("addStep", action);
connect(action, SIGNAL(triggered(bool)), this, SLOT(addStep()));
action = new KAction(this);
action->setText(i18nc("@action", "Set step data..."));
action->setStatusTip(i18nc("@info:status", "Set the name and text of the "
"currently selected step."));
action->setIcon(KIcon("document-edit"));
action->setEnabled(false);
actionCollection->addAction("setStepData", action);
connect(action, SIGNAL(triggered(bool)), this, SLOT(setStepData()));
action = new KAction(this);
action->setText(i18nc("@action", "Set setup code..."));
action->setStatusTip(i18nc("@info:status", "Set the custom code to be "
"executed when the tutorial passes to the currently selected step."));
action->setIcon(KIcon("code-function"));
action->setEnabled(false);
actionCollection->addAction("setStepSetup", action);
connect(action, SIGNAL(triggered(bool)), this, SLOT(setStepSetup()));
action = new KAction(this);
action->setText(i18nc("@action", "Set tear down code..."));
action->setStatusTip(i18nc("@info:status", "Set the custom code to be "
"executed when the tutorial changes from the currently selected step to "
"another step."));
action->setIcon(KIcon("code-function"));
action->setEnabled(false);
actionCollection->addAction("setStepTearDown", action);
connect(action, SIGNAL(triggered(bool)), this, SLOT(setStepTearDown()));
action = new KAction(this);
action->setText(i18nc("@action", "Remove step"));
action->setStatusTip(i18nc("@info:status", "Removes the currently selected "
"step from the tutorial."));
action->setIcon(KIcon("list-remove"));
action->setEnabled(false);
actionCollection->addAction("removeStep", action);
connect(action, SIGNAL(triggered(bool)), this, SLOT(removeStep()));
action = new KAction(this);
action->setText(i18nc("@action", "Add reaction..."));
action->setStatusTip(i18nc("@info:status", "Add a new reaction to the "
"selected step."));
action->setIcon(KIcon("list-add"));
action->setEnabled(false);
actionCollection->addAction("addReaction", action);
connect(action, SIGNAL(triggered(bool)), this, SLOT(addReaction()));
action = new KAction(this);
action->setText(i18nc("@action", "Set reaction data..."));
action->setStatusTip(i18nc("@info:status", "Set the trigger and the "
"response of the currently selected reaction."));
action->setIcon(KIcon("document-edit"));
action->setEnabled(false);
actionCollection->addAction("setReactionData", action);
connect(action, SIGNAL(triggered(bool)), this, SLOT(setReactionData()));
action = new KAction(this);
action->setText(i18nc("@action", "Remove reaction"));
action->setStatusTip(i18nc("@info:status", "Removes the currently selected "
"reaction from its step."));
action->setIcon(KIcon("list-remove"));
action->setEnabled(false);
actionCollection->addAction("removeReaction", action);
connect(action, SIGNAL(triggered(bool)), this, SLOT(removeReaction()));
}
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);
}
void MainWindow::setupActions()
{
KActionCollection* collection = actionCollection();
// File Menu
KAction* newTabAction = collection->addAction("new-tab");
newTabAction->setIcon( KIcon("tab-new") );
newTabAction->setText( i18n("New &Tab") );
newTabAction->setShortcut( QKeySequence(Qt::CTRL+Qt::SHIFT+Qt::Key_N) );
connect( newTabAction , SIGNAL(triggered()) , this , SLOT(newTab()) );
KAction* newWindowAction = collection->addAction("new-window");
newWindowAction->setIcon( KIcon("window-new") );
newWindowAction->setText( i18n("New &Window") );
newWindowAction->setShortcut( QKeySequence(Qt::CTRL+Qt::SHIFT+Qt::Key_M) );
connect( newWindowAction , SIGNAL(triggered()) , this , SLOT(newWindow()) );
KAction* remoteConnectionAction = collection->addAction("remote-connection");
remoteConnectionAction->setText( i18n("Remote Connection...") );
remoteConnectionAction->setIcon( KIcon("network-connect") );
remoteConnectionAction->setShortcut( QKeySequence(Qt::CTRL+Qt::SHIFT+Qt::Key_R) );
connect( remoteConnectionAction , SIGNAL(triggered()) , this , SLOT(showRemoteConnectionDialog()) );
KAction* quitAction = KStandardAction::quit( this , SLOT(close()) , collection );
// the default shortcut for quit is typically Ctrl+[Some Letter, usually Q] but that is reserved for
// use by terminal applications
quitAction->setShortcut(Qt::CTRL+Qt::SHIFT+Qt::Key_Q);
// Bookmark Menu
KActionMenu* bookmarkMenu = new KActionMenu(i18n("&Bookmarks") , collection );
_bookmarkHandler = new BookmarkHandler( collection , bookmarkMenu->menu() , true , this );
collection->addAction("bookmark" , bookmarkMenu);
connect( _bookmarkHandler , SIGNAL(openUrls(QList<KUrl>)) , this , SLOT(openUrls(QList<KUrl>)) );
//TODO - The 'Add Bookmark' menu action currently has a Ctrl+B shortcut by
// default which cannot be overridden
// View Menu
_toggleMenuBarAction = new KToggleAction(this);
_toggleMenuBarAction->setText( i18n("Show Menu Bar") );
_toggleMenuBarAction->setIcon( KIcon("show-menu") );
_toggleMenuBarAction->setChecked( !menuBar()->isHidden() );
connect( _toggleMenuBarAction , SIGNAL(toggled(bool)) , menuBar() , SLOT(setVisible(bool)) );
collection->addAction("show-menubar",_toggleMenuBarAction);
// Hide the Show/Hide menubar item if the menu bar is a MacOS-style menu bar
if ( menuBar()->isTopLevelMenu() )
_toggleMenuBarAction->setVisible(false);
// Full Screen
KToggleFullScreenAction* fullScreenAction = new KToggleFullScreenAction(this);
fullScreenAction->setWindow(this);
fullScreenAction->setShortcut( Qt::CTRL + Qt::SHIFT + Qt::Key_F11 );
collection->addAction("view-full-screen",fullScreenAction);
connect( fullScreenAction , SIGNAL(toggled(bool)) , this , SLOT(viewFullScreen(bool)) );
// Settings Menu
KStandardAction::configureNotifications( this , SLOT(configureNotifications()) , collection );
KStandardAction::keyBindings( this , SLOT(showShortcutsDialog()) , collection );
KAction* manageProfilesAction = collection->addAction("manage-profiles");
manageProfilesAction->setText( i18n("Manage Profiles...") );
manageProfilesAction->setIcon( KIcon("configure") );
connect( manageProfilesAction , SIGNAL(triggered()) , this , SLOT(showManageProfilesDialog()) );
}
void StorageServiceManagerMainWindow::setupActions()
{
KActionCollection *ac = actionCollection();
KStandardAction::quit(this, &StorageServiceManagerMainWindow::close, ac);
mAuthenticate = ac->addAction(QStringLiteral("authenticate"), mStorageServiceMainWidget->storageServiceTabWidget(), SLOT(slotAuthenticate()));
mAuthenticate->setText(i18n("Authenticate..."));
mCreateFolder = ac->addAction(QStringLiteral("create_folder"), mStorageServiceMainWidget->storageServiceTabWidget(), SLOT(slotCreateFolder()));
mCreateFolder->setText(i18n("Create Folder..."));
mCreateFolder->setIcon(QIcon::fromTheme(QStringLiteral("folder-new")));
mRefreshList = ac->addAction(QStringLiteral("refresh_list"), mStorageServiceMainWidget->storageServiceTabWidget(), SLOT(slotRefreshList()));
mRefreshList->setText(i18n("Refresh List"));
mRefreshList->setIcon(QIcon::fromTheme(QStringLiteral("view-refresh")));
ac->setDefaultShortcut(mRefreshList, QKeySequence(Qt::Key_F5));
mAccountInfo = ac->addAction(QStringLiteral("account_info"), mStorageServiceMainWidget->storageServiceTabWidget(), SLOT(slotAccountInfo()));
mAccountInfo->setText(i18n("Account Info..."));
mUploadFile = ac->addAction(QStringLiteral("upload_file"), mStorageServiceMainWidget->storageServiceTabWidget(), SLOT(slotUploadFile()));
mUploadFile->setText(i18n("Upload File..."));
mDelete = ac->addAction(QStringLiteral("delete"), mStorageServiceMainWidget->storageServiceTabWidget(), SLOT(slotDelete()));
ac->setDefaultShortcut(mDelete, QKeySequence(Qt::Key_Delete));
mDelete->setText(i18n("Delete..."));
mDelete->setIcon(QIcon::fromTheme(QStringLiteral("edit-delete")));
mDownloadFile = ac->addAction(QStringLiteral("download_file"), mStorageServiceMainWidget->storageServiceTabWidget(), SLOT(slotDownloadFile()));
mDownloadFile->setText(i18n("Download File..."));
mDownloadFile->setIcon(QIcon::fromTheme(QStringLiteral("download")));
mShowLog = ac->addAction(QStringLiteral("show_log"), mStorageServiceMainWidget->storageServiceTabWidget(), SLOT(slotShowLog()));
mShowLog->setText(i18n("Show Log..."));
mLogout = ac->addAction(QStringLiteral("logout"), this, SLOT(slotLogout()));
mLogout->setText(i18n("Logout"));
mShutdownAllServices = ac->addAction(QStringLiteral("shutdown_all_services"), this, SLOT(slotShutdownAllServices()));
mShutdownAllServices->setText(i18n("Shutdown All Services"));
mRefreshAll = ac->addAction(QStringLiteral("refresh_all"), this, SLOT(slotRefreshAll()));
mRefreshAll->setText(i18n("Refresh All"));
ac->setDefaultShortcut(mRefreshAll, QKeySequence(Qt::CTRL + Qt::Key_F5));
mRenameItem = ac->addAction(QStringLiteral("rename"), mStorageServiceMainWidget->storageServiceTabWidget(), SLOT(slotRename()));
mRenameItem->setText(i18n("Rename..."));
ac->setDefaultShortcut(mRenameItem, QKeySequence(Qt::Key_F2));
KStandardAction::preferences(this, &StorageServiceManagerMainWindow::slotConfigure, ac);
KStandardAction::configureNotifications(this, &StorageServiceManagerMainWindow::slotShowNotificationOptions, ac); // options_configure_notifications
}
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);
}
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 );
}
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);
}
