void RubyDebuggerPart::slotStopDebugger()
{
controller->slotStopDebugger();
debugger()->clearExecutionPoint();
delete floatingToolBar;
floatingToolBar = 0;
rdbBreakpointWidget->reset();
framestackWidget->clear();
variableWidget->varTree()->clear();
// variableWidget->setEnabled(false);
framestackWidget->setEnabled(false);
rdbOutputWidget->setEnabled(false);
// mainWindow()->setViewAvailable(variableWidget, false);
mainWindow()->setViewAvailable(framestackWidget, false);
mainWindow()->setViewAvailable(rdbOutputWidget, false);
KActionCollection *ac = actionCollection();
ac->action("debug_run")->setText( i18n("&Start") );
// ac->action("debug_run")->setIcon( "1rightarrow" );
ac->action("debug_run")->setToolTip( i18n("Runs the program in the debugger") );
ac->action("debug_run")->setWhatsThis( i18n("Start in debugger\n\n"
"Starts the debugger with the project's main "
"executable. You may set some breakpoints "
"before this, or you can interrupt the program "
"while it is running, in order to get information "
"about variables, frame stack, and so on.") );
stateChanged( QString("stopped") );
core()->running(this, false);
}
void FileBrowserWidget::setupToolbar()
{
KActionCollection *coll = m_dirOperator->actionCollection();
m_toolbar->addAction(coll->action("back"));
m_toolbar->addAction(coll->action("forward"));
QAction *action = new QAction(this);
action->setIcon(QIcon::fromTheme("document-open"));
action->setText(i18n("Open selected"));
connect(action, SIGNAL(triggered()), this, SLOT(emitFileSelectedSignal()));
m_toolbar->addAction(action);
QAction *showOnlyLaTexFilesAction = new QAction(this);
showOnlyLaTexFilesAction->setText(i18n("Show LaTeX Files Only"));
showOnlyLaTexFilesAction->setCheckable(true);
showOnlyLaTexFilesAction->setChecked(KileConfig::showLaTeXFilesOnly());
connect(showOnlyLaTexFilesAction, SIGNAL(triggered(bool)), this, SLOT(toggleShowLaTeXFilesOnly(bool)));
// section for settings menu
KActionMenu *optionsMenu = new KActionMenu(QIcon::fromTheme("configure"), i18n("Options"), this);
optionsMenu->setDelayed(false);
optionsMenu->addAction(m_dirOperator->actionCollection()->action("short view"));
optionsMenu->addAction(m_dirOperator->actionCollection()->action("detailed view"));
optionsMenu->addAction(m_dirOperator->actionCollection()->action("tree view"));
optionsMenu->addAction(m_dirOperator->actionCollection()->action("detailed tree view"));
optionsMenu->addSeparator();
optionsMenu->addAction(showOnlyLaTexFilesAction);
optionsMenu->addAction(m_dirOperator->actionCollection()->action("show hidden"));
m_toolbar->addSeparator();
m_toolbar->addAction(optionsMenu);
}
void CMapWidget::showRoomContextMenu(void)
{
CMapRoom *room = (CMapRoom *) getView()->getSelectedElement();
KActionCollection *acol = getView()->actionCollection();
QAction *roomSetCurrentPos = acol->action("roomCurrentPos");
QAction *roomSetLogin = acol->action("roomLoginPoint");
KSelectAction *labelMenu=(KSelectAction *) acol->action("labelMenu");
roomSetCurrentPos->setEnabled(!room->getCurrentRoom());
roomSetLogin->setEnabled(!room->getLoginRoom());
switch(room->getLabelPosition())
{
case CMapRoom::HIDE : labelMenu->setCurrentItem(0); break;
case CMapRoom::NORTH : labelMenu->setCurrentItem(1); break;
case CMapRoom::NORTHEAST : labelMenu->setCurrentItem(2); break;
case CMapRoom::EAST : labelMenu->setCurrentItem(3); break;
case CMapRoom::SOUTHEAST : labelMenu->setCurrentItem(4); break;
case CMapRoom::SOUTH : labelMenu->setCurrentItem(5); break;
case CMapRoom::SOUTHWEST : labelMenu->setCurrentItem(6); break;
case CMapRoom::WEST : labelMenu->setCurrentItem(7); break;
case CMapRoom::NORTHWEST : labelMenu->setCurrentItem(8); break;
case CMapRoom::CUSTOM : labelMenu->setCurrentItem(9); break;
}
showContextMenu (room_menu);
}
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() );
}
void RubyDebuggerPart::slotRun()
{
if (controller->stateIsOn(s_programExited)) {
rdbBreakpointWidget->reset();
}
if ( controller->stateIsOn( s_dbgNotStarted ) ) {
mainWindow()->statusBar()->message(i18n("Debugging program"), 1000);
mainWindow()->raiseView(rdbOutputWidget);
appFrontend()->clearView();
startDebugger();
} else {
KActionCollection *ac = actionCollection();
ac->action("debug_run")->setText( i18n("&Continue") );
ac->action("debug_run")->setToolTip( i18n("Continues the application execution") );
ac->action("debug_run")->setWhatsThis( i18n("Continue application execution\n\n"
"Continues the execution of your application in the "
"debugger. This only takes effect when the application "
"has been halted by the debugger (i.e. a breakpoint has "
"been activated or the interrupt was pressed).") );
mainWindow()->statusBar()->message(i18n("Continuing program"), 1000);
}
controller->slotRun();
}
void FileBrowserWidget::setupToolbar()
{
KActionCollection *coll = m_dirOperator->actionCollection();
m_toolbar->addAction(coll->action("back"));
m_toolbar->addAction(coll->action("forward"));
KAction *action = new KAction(this);
action->setIcon(SmallIcon("document-open"));
action->setText(i18n("Open selected"));
connect(action, SIGNAL(triggered()), this, SLOT(emitFileSelectedSignal()));
m_toolbar->addAction(action);
// section for settings menu
KActionMenu *optionsMenu = new KActionMenu(KIcon("configure"), i18n("Options"), this);
optionsMenu->setDelayed(false);
optionsMenu->addAction(m_dirOperator->actionCollection()->action("short view"));
optionsMenu->addAction(m_dirOperator->actionCollection()->action("detailed view"));
optionsMenu->addAction(m_dirOperator->actionCollection()->action("tree view"));
optionsMenu->addAction(m_dirOperator->actionCollection()->action("detailed tree view"));
optionsMenu->addSeparator();
optionsMenu->addAction(m_dirOperator->actionCollection()->action("show hidden"));
m_toolbar->addSeparator();
m_toolbar->addAction(optionsMenu);
}
void DebuggerManager::enableAction(const QString& action, bool enable)
{
if(action == "*")
{
// Enable/Disable all session related actions + connect/disconnect
enableAction("debug_request", enable);
enableAction("debug_run", enable);
enableAction("debug_trace", enable);
enableAction("debug_pause", enable);
enableAction("debug_kill", enable);
enableAction("debug_stepover", enable);
enableAction("debug_stepinto", enable);
enableAction("debug_stepout", enable);
enableAction("debug_skip", enable);
enableAction("debug_connect", enable);
enableAction("debug_disconnect", enable);
enableAction("debug_breakpoints_toggle", enable);
enableAction("debug_breakpoints_clear", enable);
enableAction("debug_profiler_open", enable);
}
else
{
// The action may or may not exist, depending on capabilities of the debugger plugin
KActionCollection *ac = quantaApp->actionCollection();
if(ac && ac->action(action))
ac->action(action)->setEnabled(enable);
}
}
void KoPageNavigator::initActions()
{
KActionCollection *actionCollection = d->view->actionCollection();
d->gotoFirstPageButton->setAction(actionCollection->action(QLatin1String("page_first")));
d->gotoPreviousPageButton->setAction(actionCollection->action(QLatin1String("page_previous")));
d->gotoNextPageButton->setAction(actionCollection->action(QLatin1String("page_next")));
d->gotoLastPageButton->setAction(actionCollection->action(QLatin1String("page_last")));
}
void EditActions::selectReaction(Reaction* reaction) {
mCurrentReaction = reaction;
KActionCollection* actionCollection = mTutorialEditor->actionCollection();
if (mCurrentReaction) {
actionCollection->action("setReactionData")->setEnabled(true);
actionCollection->action("removeReaction")->setEnabled(true);
} else {
actionCollection->action("setReactionData")->setEnabled(false);
actionCollection->action("removeReaction")->setEnabled(false);
}
}
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();
}
void Core::setupShourtcutTips(KXMLGUIClient * client)
{
QPtrList<KXMLGUIClient> clients;
if (client != 0)
clients.append(client);
else
clients = TopLevel::getInstance()->main()->guiFactory()->clients();
for( QPtrListIterator<KXMLGUIClient> it(clients); it.current(); ++it ) {
KActionCollection *actionCollection = (*it)->actionCollection();
for (int i = 0; i < actionCollection->count(); i++) {
KAction *action = actionCollection->action(i);
QString tooltip = action->toolTip();
if (tooltip.isEmpty())
tooltip = action->text().remove('&');
else {
int i = tooltip.findRev('(');
if (i > 0) tooltip = tooltip.left(i).stripWhiteSpace();
}
QString shortcut = action->shortcutText();
if (!shortcut.isEmpty())
tooltip += " (" + shortcut + ")";
action->setToolTip(tooltip);
}
}
}
void EditActions::selectStep(Step* step) {
mCurrentStep = step;
KActionCollection* actionCollection = mTutorialEditor->actionCollection();
if (mCurrentStep) {
actionCollection->action("setStepData")->setEnabled(true);
actionCollection->action("setStepSetup")->setEnabled(true);
actionCollection->action("setStepTearDown")->setEnabled(true);
actionCollection->action("removeStep")->setEnabled(true);
actionCollection->action("addReaction")->setEnabled(true);
} else {
actionCollection->action("setStepData")->setEnabled(false);
actionCollection->action("setStepSetup")->setEnabled(false);
actionCollection->action("setStepTearDown")->setEnabled(false);
actionCollection->action("removeStep")->setEnabled(false);
actionCollection->action("addReaction")->setEnabled(false);
}
}
void KOEventPopupMenu::forward()
{
KOrg::MainWindow *w = ActionManager::findInstance(KURL());
if(!w || !mCurrentIncidence)
return;
KActionCollection *ac = w->getActionCollection();
KAction *action = ac->action("schedule_forward");
action->activate();
}
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);
}
}
void KexiView::setAvailable(const QString& action_name, bool set)
{
if (part()) {
KActionCollection *ac;
QAction* a;
if ((ac = part()->actionCollectionForMode(viewMode())) && (a = ac->action(action_name))) {
a->setEnabled(set);
}
}
KexiActionProxy::setAvailable(action_name, set);
}
QAction* KexiView::sharedAction(const QString& action_name)
{
if (part()) {
KActionCollection *ac;
if ((ac = part()->actionCollectionForMode(viewMode()))) {
QAction* a = ac->action(action_name);
if (a)
return a;
}
}
return KexiActionProxy::sharedAction(action_name);
}
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 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 );
}
}
}
}
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();
}
MyDirOperator( const KURL &url, QWidget *parent ) : KDirOperator( url, parent ) {
setDirLister( new MyDirLister( true ) );
//the delete key event was being eaten with the file browser open
//so folks couldn't use the del key to remove items from the playlist
//refer to KDirOperator::setupActions() to understand this code
KActionCollection* dirActionCollection = static_cast<KActionCollection*>(KDirOperator::child("KDirOperator::myActionCollection"));
if(dirActionCollection)
{
KAction* trash = dirActionCollection->action("trash");
if(trash)
trash->setEnabled(false);
}
}
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 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);
}
}
void TaskDescriptionPanel::initDescription( bool readOnly )
{
toolbar->setVisible( ! readOnly );
toolbar->setToolButtonStyle( Qt::ToolButtonIconOnly );
KActionCollection *collection = new KActionCollection( this ); //krazy:exclude=tipsandthis
descriptionfield->setRichTextSupport( KRichTextWidget::SupportBold |
KRichTextWidget::SupportItalic |
KRichTextWidget::SupportUnderline |
KRichTextWidget::SupportStrikeOut |
KRichTextWidget::SupportChangeListStyle |
KRichTextWidget::SupportAlignment |
KRichTextWidget::SupportFormatPainting );
descriptionfield->createActions( collection );
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" ) );
descriptionfield->append( "" );
descriptionfield->setReadOnly( readOnly );
descriptionfield->setOverwriteMode( false );
descriptionfield->setLineWrapMode( KTextEdit::WidgetWidth );
descriptionfield->setTabChangesFocus( true );
}
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&)));
}
}
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);
}
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 ActionConfigDialog::slotShortcutCaptured(const KShortcut &shortcut)
{
QString shortcutText = shortcut.toString();
QString shortcutText2;
int pos = shortcutText.find(';');
if (pos != -1)
{
shortcutText2 = shortcutText.mid(pos + 1);
shortcutText = shortcutText.left(pos);
}
QString s = shortcutText;
s.replace('+', "\\+");
QRegExp shortcutRx("\\(" + s + "\\)|" + s + "$|" + s + ";");
s = shortcutText2;
s.replace('+', "\\+");
QRegExp shortcutRx2("\\(" + s + "\\)|" + s + "$|" + s + ";");
QString global;
//check for conflicting global shortcuts
QMap<QString, QString>::Iterator it;
for ( it = globalShortcuts.begin(); it != globalShortcuts.end(); ++it )
{
if (it.data().contains(shortcutRx))
{
global = it.key();
break;
}
if (!shortcutText2.isEmpty() && it.data().contains(shortcutRx2))
{
shortcutText = shortcutText2;
global = it.key();
break;
}
}
if (global.isEmpty())
{
QPtrList<KXMLGUIClient> clients = m_mainWindow->guiFactory()->clients();
for( QPtrListIterator<KXMLGUIClient> it( clients ); it.current(); ++it )
{
KActionCollection *ac = (*it)->actionCollection();
for (uint i = 0; i < ac->count(); i++)
{
KAction *action = ac->action(i);
if (action != currentAction && action->shortcut().toString().contains(shortcutRx))
{
global = action->text();
break;
}
if (!shortcutText2.isEmpty() && action != currentAction && action->shortcut().toString().contains(shortcutRx))
{
shortcutText = shortcutText2;
global = action->text();
break;
}
}
if (!global.isEmpty())
break;
}
}
if (global.isEmpty())
{
shortcutKeyButton->setText(shortcutText);
buttonApply->setEnabled(true);
selectedShortcut = shortcut;
} else
{
global.replace('&',"");
QString s = i18n("The '%1' key combination has already been allocated "
"to the \"%2\" action.\n"
"Please choose a unique key combination.").
arg(shortcutText).arg(global);
KMessageBox::sorry( this, s, i18n("Conflicting Shortcuts"));
}
}
