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 );
}
