void TitleWidget::slotJourneysIconClicked()
{
KActionMenu *journeysAction = qobject_cast<KActionMenu*>( m_journeysAction );
Q_ASSERT( journeysAction );
// Show the journeys menu under the journey search icon
journeysAction->menu()->exec( QCursor::pos() );
}
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);
}
CreatorController::CreatorController( ModelCodecManager* modelCodecManager,
AbstractDocumentStrategy* documentStrategy,
KXMLGUIClient* guiClient )
: AbstractXmlGuiController(),
mModelCodecManager( modelCodecManager ),
mDocumentStrategy( documentStrategy )
{
KActionCollection* actionCollection = guiClient->actionCollection();
KActionMenu* newMenuAction = actionCollection->add<KActionMenu>( QLatin1String("file_new"), this, SLOT(onNewActionTriggered()) );
newMenuAction->setText( i18nc("@title:menu create new byte arrays from different sources", "New" ) );
newMenuAction->setIcon( KIcon( QLatin1String("document-new") ) );
newMenuAction->setShortcut( KStandardShortcut::openNew() );
QAction* newEmptyDocumentAction =
new QAction( KIcon( QLatin1String("document-new") ), i18nc("@title:menu create a new empty document", "Empty" ), this );
// newEmptyDocumentAction->setToolTip( factory-toolTip() );
// i18nc( "@info:tooltip", "Create an empty document" ) );
// newEmptyDocumentAction->setHelpText( factory->helpText() );
// i18nc( "@info:status", "Create an new, empty document" ) );
// newEmptyDocumentAction->setWhatsThis( factory->whatsThis() );
// i18nc( "@info:whatsthis", "." ) );
connect( newEmptyDocumentAction, SIGNAL(triggered(bool)), SLOT(onNewActionTriggered()) );
QAction* newFromClipboardDocumentAction =
new QAction( KIcon( QLatin1String("edit-paste") ), i18nc("@title:menu create a new document from data in the clipboard", "From Clipboard" ), this );
connect( newFromClipboardDocumentAction, SIGNAL(triggered(bool)), SLOT(onNewFromClipboardActionTriggered()) );
newMenuAction->addAction( newEmptyDocumentAction );
newMenuAction->addSeparator();
newMenuAction->addAction( newFromClipboardDocumentAction );
// generators
const QList<AbstractModelDataGenerator*> generatorList =
mModelCodecManager->generatorList();
const bool hasGenerators = ( generatorList.size() > 0 );
if( hasGenerators )
{
newMenuAction->addSeparator();
// TODO: ask factory which mimetypes it can read
// AbstractDocumentFactory->canCreateFromData( QMimeData() ) needs already data
foreach( AbstractModelDataGenerator* generator, generatorList )
{
const QString title = generator->typeName();
const QString iconName = QString::fromLatin1( "document-new" );//generator->iconName();
QAction* action = new QAction( KIcon(iconName), title, this );
action->setData( QVariant::fromValue(generator) );
connect( action, SIGNAL(triggered(bool)), SLOT(onNewFromGeneratorActionTriggered()) );
newMenuAction->addAction( action );
}
}
}
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 MainWindow::initToolsMenu()
{
if (!m_toolsMenu)
return;
m_toolsMenu->menu()->clear();
m_toolsMenu->addAction(actionByName(KStandardAction::name(KStandardAction::Open)));
m_toolsMenu->addAction(actionByName(KStandardAction::name(KStandardAction::SaveAs)));
m_toolsMenu->addAction(actionByName(KStandardAction::name(KStandardAction::Print)));
m_toolsMenu->addAction(actionByName(KStandardAction::name(KStandardAction::Find)));
QAction *action = actionByName(KStandardAction::name(KStandardAction::Zoom));
action->setCheckable(true);
connect (m_zoomBar, SIGNAL(visibilityChanged(bool)), action, SLOT(setChecked(bool)));
m_toolsMenu->addAction(action);
m_toolsMenu->addAction(actionByName(QL1S("encodings")));
m_toolsMenu->addSeparator();
m_toolsMenu->addAction(actionByName(QL1S("private_browsing")));
m_toolsMenu->addAction(actionByName(QL1S("clear_private_data")));
m_toolsMenu->addSeparator();
KActionMenu *webMenu = new KActionMenu(KIcon("applications-development-web"), i18n("Development"), this);
webMenu->addAction(actionByName(QL1S("web_inspector")));
webMenu->addAction(actionByName(QL1S("page_source")));
webMenu->addAction(actionByName(QL1S("net_analyzer")));
m_toolsMenu->addAction(webMenu);
m_toolsMenu->addSeparator();
action = m_bookmarksBar->toolBar()->toggleViewAction();
action->setText(i18n("Bookmarks Toolbar"));
action->setIcon(KIcon("bookmarks-bar"));
m_toolsMenu->addAction(action);
m_toolsMenu->addAction(actionByName(QL1S("show_history_panel")));
m_toolsMenu->addAction(actionByName(QL1S("show_bookmarks_panel")));
m_toolsMenu->addAction(actionByName(KStandardAction::name(KStandardAction::FullScreen)));
m_toolsMenu->addSeparator();
this->setHelpMenuEnabled(true);
helpMenu()->setIcon(KIcon("help-browser"));
m_toolsMenu->addAction(helpMenu()->menuAction());
m_toolsMenu->addAction(actionByName(KStandardAction::name(KStandardAction::Preferences)));
}
KActionMenu * Account::actionMenu()
{
//default implementation
KActionMenu *menu = new KActionMenu( accountId(), myself()->onlineStatus().iconFor( this ), this );
QString nick = myself()->property( Kopete::Global::Properties::self()->nickName()).value().toString();
menu->popupMenu()->insertTitle( myself()->onlineStatus().iconFor( myself() ),
nick.isNull() ? accountLabel() : i18n( "%2 <%1>" ).arg( accountLabel(), nick )
);
OnlineStatusManager::self()->createAccountStatusActions(this, menu);
menu->popupMenu()->insertSeparator();
menu->insert( new KAction ( i18n( "Properties" ), 0, this, SLOT( editAccount() ), menu, "actionAccountProperties" ) );
return menu;
}
void KBookmarkMenuImporter::newFolder(const QString &text, bool, const QString &)
{
QString _text = KStringHandler::csqueeze(text).replace('&', QLatin1String("&&"));
KActionMenu *actionMenu = new KImportedBookmarkActionMenu(QIcon::fromTheme(QStringLiteral("folder")), _text, this);
mstack.top()->parentMenu()->addAction(actionMenu);
mstack.top()->m_actions.append(actionMenu);
KImportedBookmarkMenu *subMenu = new KImportedBookmarkMenu(m_pManager, m_menu->owner(), actionMenu->menu());
mstack.top()->m_lstSubMenus.append(subMenu);
mstack.push(subMenu);
}
KActionMenu *JabberTransport::actionMenu ()
{
KActionMenu *menu = new KActionMenu( accountId(), myself()->onlineStatus().iconFor( this ), this );
QString nick = myself()->property( Kopete::Global::Properties::self()->nickName()).value().toString();
menu->popupMenu()->insertTitle( myself()->onlineStatus().iconFor( myself() ),
nick.isNull() ? accountLabel() : i18n( "%2 <%1>" ).arg( accountLabel(), nick )
);
QPtrList<KAction> *customActions = myself()->customContextMenuActions( );
if( customActions && !customActions->isEmpty() )
{
menu->popupMenu()->insertSeparator();
for( KAction *a = customActions->first(); a; a = customActions->next() )
a->plug( menu->popupMenu() );
}
delete customActions;
return menu;
/* KActionMenu *m_actionMenu = Kopete::Account::actionMenu();
m_actionMenu->popupMenu()->insertSeparator();
m_actionMenu->insert(new KAction (i18n ("Join Groupchat..."), "jabber_group", 0,
this, SLOT (slotJoinNewChat ()), this, "actionJoinChat"));
m_actionMenu->popupMenu()->insertSeparator();
m_actionMenu->insert ( new KAction ( i18n ("Services..."), "jabber_serv_on", 0,
this, SLOT ( slotGetServices () ), this, "actionJabberServices") );
m_actionMenu->insert ( new KAction ( i18n ("Send Raw Packet to Server..."), "mail_new", 0,
this, SLOT ( slotSendRaw () ), this, "actionJabberSendRaw") );
m_actionMenu->insert ( new KAction ( i18n ("Edit User Info..."), "identity", 0,
this, SLOT ( slotEditVCard () ), this, "actionEditVCard") );
return m_actionMenu;*/
}
void MainWindow::createActions()
{
KStandardAction::open( this, SLOT(slotFileOpen()), actionCollection() );
KStandardAction::openRecent( this, SLOT(slotFileOpenRecent()), actionCollection() );
KStandardAction::save( this, SLOT(slotFileSave()), actionCollection() );
KStandardAction::saveAs( this, SLOT(slotFileSaveAs()), actionCollection() );
KStandardAction::close( this, SLOT(slotViewClose()), actionCollection() );
KStandardAction::print( this, SLOT(slotFilePrint()), actionCollection() );
KStandardAction::quit( this, SLOT(slotFileQuit()), actionCollection() );
KStandardAction::undo( this, SLOT(slotUndo()), actionCollection() );
KStandardAction::redo( this, SLOT(slotRedo()), actionCollection() );
KStandardAction::cut( this, SLOT(slotCut()), actionCollection() );
KStandardAction::copy( this, SLOT(slotCopy()), actionCollection() );
KStandardAction::paste( this, SLOT(slotPaste()), actionCollection() );
KActionMenu *newActionMenu = new KActionMenu( KIcon("document-new"), i18n("&New"), this );
actionCollection()->addAction( KStandardAction::name(KStandardAction::New), newActionMenu );
connect( newActionMenu, SIGNAL(activated()), this, SLOT(slotFileNew()) );
KAction *action;
action = actionCollection()->addAction( QString("newfile_asm") );
action->setText( i18n("Assembly") );
action->setIcon( KIcon("") );
connect( action, SIGNAL(triggered()), this, SLOT(slotFileNewAssembly()) );
newActionMenu->addAction( action );
action = actionCollection()->addAction( QString("newfile_c") );
action->setText( i18n("C source") );
action->setIcon( KIcon("text-x-csrc") );
connect( action, SIGNAL(triggered()), this, SLOT(slotFileNewC()) );
newActionMenu->addAction( action );
action = actionCollection()->addAction( QString("ktechlab_circuit") );
action->setText( i18n("Circuit") );
action->setIcon( KIcon("ktechlab_circuit") );
connect( action, SIGNAL(triggered()), this, SLOT(slotFileNewCircuit()) );
newActionMenu->addAction( action );
action = actionCollection()->addAction( QString("ktechlab_flowcode") );
action->setText( i18n("FlowCode") );
action->setIcon( KIcon("ktechlab_flowcode") );
connect( action, SIGNAL(triggered()), this, SLOT(slotFileNewFlowCode()) );
newActionMenu->addAction( action );
action = actionCollection()->addAction( QString("ktechlab_mechanics") );
action->setText( i18n("Mechanics") );
action->setIcon( KIcon("") );
connect( action, SIGNAL(triggered()), this, SLOT(slotFileNewMechanics()) );
newActionMenu->addAction( action );
action = actionCollection()->addAction( QString("ktechlab_microbe") );
action->setText( i18n("Microbe") );
action->setIcon( KIcon("ktechlab_microbe") );
connect( action, SIGNAL(triggered()), this, SLOT(slotFileNewMicrobe()) );
newActionMenu->addAction( action );
}
QAction *KBookmarkMenu::actionForBookmark(const KBookmark &bm)
{
if (bm.isGroup()) {
//qDebug() << "Creating bookmark submenu named " << bm.text();
KActionMenu *actionMenu = new KBookmarkActionMenu(bm, this);
m_actions.append(actionMenu);
KBookmarkMenu *subMenu = new KBookmarkMenu(m_pManager, m_pOwner, actionMenu->menu(), bm.address());
m_lstSubMenus.append(subMenu);
return actionMenu;
} else if (bm.isSeparator()) {
QAction *sa = new QAction(this);
sa->setSeparator(true);
m_actions.append(sa);
return sa;
} else {
//qDebug() << "Creating bookmark menu item for " << bm.text();
QAction *action = new KBookmarkAction(bm, m_pOwner, this);
m_actions.append(action);
return action;
}
}
KActionMenu *TabBar::setupHistoryActions()
{
MainWindow *w = rApp->mainWindow();
MainView *mv = qobject_cast<MainView *>(parent());
QAction *openLastClosedTabAction = w->actionByName(QL1S("open_last_closed_tab"));
bool closedTabsAvailable = (mv->recentlyClosedTabs().size() > 0);
openLastClosedTabAction->setEnabled(closedTabsAvailable);
KActionMenu *am = new KActionMenu(KIcon("tab-new"), i18n("Closed Tabs"), this);
am->setDelayed(false);
am->setEnabled(closedTabsAvailable);
if (am->menu())
am->menu()->clear();
if (!closedTabsAvailable)
return am;
for (int i = 0; i < mv->recentlyClosedTabs().count(); ++i)
{
TabHistory item = mv->recentlyClosedTabs().at(i);
KAction *a = new KAction(rApp->iconManager()->iconForUrl(item.url), item.title, this);
a->setData(i);
connect(a, SIGNAL(triggered()), mv, SLOT(openClosedTab()));
am->addAction(a);
}
return am;
}
KActionMenu* WPAccount::actionMenu()
{
kdDebug(14170) << "WPAccount::actionMenu()" << endl;
/// How to remove an action from Kopete::Account::actionMenu()? GF
KActionMenu *theActionMenu = new KActionMenu(accountId() , myself()->onlineStatus().iconFor(this), this);
theActionMenu->popupMenu()->insertTitle(myself()->onlineStatus().iconFor(this), i18n("WinPopup (%1)").arg(accountId()));
if (mProtocol)
{
KAction *goOnline = new KAction("Online", QIconSet(mProtocol->WPOnline.iconFor(this)), 0,
this, SLOT(connect()), theActionMenu, "actionGoAvailable");
goOnline->setEnabled(isConnected() && isAway());
theActionMenu->insert(goOnline);
KAction *goAway = new KAction("Away", QIconSet(mProtocol->WPAway.iconFor(this)), 0,
this, SLOT(goAway()), theActionMenu, "actionGoAway");
goAway->setEnabled(isConnected() && !isAway());
theActionMenu->insert(goAway);
/// One can not really go offline manually - appears online as long as samba server is running. GF
theActionMenu->popupMenu()->insertSeparator();
theActionMenu->insert(new KAction(i18n("Properties"), 0,
this, SLOT(editAccount()), theActionMenu, "actionAccountProperties"));
}
return theActionMenu;
}
KAction *XMLActionHandler::createAction( KActionCollection *parent )
{
// kdDebug(80001) << "Creating Action, type is " << type << endl;
// kdDebug(80001) << "text=" << text << ", icons=" << icons << endl;
// kdDebug(80001) << "keys=" << keys << ", name=" << name << endl;
if ( !parent ) {
kdWarning() << "Create action called but no parent set" << endl;
return 0;
}
KAction *act=0;
if ( ad.type.isEmpty() || (ad.type == "KAction") ) {
act = new KAction( ad.text, ad.icons, ad.keys, 0, 0, parent, ad.name.latin1() );
}
else if ( ad.type == "KToggleAction" ) {
act = new KToggleAction( ad.text, ad.icons, ad.keys, 0, 0, parent, ad.name.latin1() );
}
else if ( ad.type == "KRadioAction" ) {
KRadioAction *ra = new KRadioAction( ad.text, ad.icons, ad.keys, 0, 0, parent, ad.name.latin1() );
if ( ad.exclusive )
ra->setExclusiveGroup( ad.group );
act = ra;
}
else if ( ad.type == "KStdAction" ) {
for ( int i = KStdAction::ActionNone ; i < KStdAction::ConfigureNotifications ; i++ ) {
if ( KStdAction::stdName(static_cast<KStdAction::StdAction>(i)) == ad.name )
act = KStdAction::create( (KStdAction::StdAction)i, 0, 0, parent );
}
}
else if ( ad.type == "KListAction" ) {
KListAction *la = new KListAction( ad.text, ad.icons, ad.keys, 0, 0, parent, ad.name.latin1() );
la->setItems( ad.items );
ad.items.clear();
act = la;
}
else if ( ad.type == "KActionMenu" ) {
KActionMenu *am = new KActionMenu( ad.text, ad.icons, parent, ad.name.latin1() );
for ( QStringList::Iterator it = ad.items.begin() ; it != ad.items.end() ; ++it ) {
KAction *a = parent->action( (*it).latin1() );
if ( a )
am->insert( a );
}
ad.items.clear();
act = am;
}
else {
kdWarning() << "Unknown ActionType " << ad.type << endl;
return 0;
}
if ( !act ) {
kdWarning() << "Unable to create action" << endl;
return act;
}
if ( !ad.group.isEmpty() )
act->setGroup( ad.group );
act->setStatusText( ad.status );
act->setWhatsThis( ad.whatsthis );
QObject::connect( actclient, SIGNAL( destroyed() ), act, SLOT( deleteLater() ) );
return act;
}
TemplatesInsertCommand::TemplatesInsertCommand( QWidget *parent,
const char *name )
: QPushButton( parent, name )
{
setText( i18n( "&Insert Command..." ) );
connect( this, SIGNAL( clicked() ),
this, SLOT( slotClicked() ) );
KAction *action;
KActionMenu *menu;
QSignalMapper *mapper = new QSignalMapper( this );
connect( mapper, SIGNAL( mapped(int) ),
this, SLOT( slotMapped(int) ) );
mMenu = new KActionMenu( i18n( "Insert Command..." ), this );
// ******************************************************
menu = new KActionMenu( i18n( "Original Message" ), mMenu );
mMenu->insert( menu );
action = new KAction( i18n("Quoted Message"),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CQuote );
menu->insert( action );
action = new KAction( i18n("Message Text as Is"),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CText );
menu->insert( action );
action = new KAction( i18n("Message Id"),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, COMsgId );
menu->insert( action );
action = new KAction( i18n("Date"),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CODate );
menu->insert( action );
action = new KAction( i18n("Date in Short Format"),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CODateShort );
menu->insert( action );
action = new KAction( i18n("Date in C Locale"),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CODateEn );
menu->insert( action );
action = new KAction( i18n("Day of Week"),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CODow );
menu->insert( action );
action = new KAction( i18n("Time"),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, COTime );
menu->insert( action );
action = new KAction( i18n("Time in Long Format"),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, COTimeLong );
menu->insert( action );
action = new KAction( i18n("Time in C Locale"),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, COTimeLongEn );
menu->insert( action );
action = new KAction( i18n("To Field Address"),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, COToAddr );
menu->insert( action );
action = new KAction( i18n("To Field Name"),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, COToName );
menu->insert( action );
action = new KAction( i18n("To Field First Name"),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, COToFName );
menu->insert( action );
action = new KAction( i18n("To Field Last Name"),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, COToLName );
menu->insert( action );
action = new KAction( i18n( "CC Field Address" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, COCCAddr );
menu->insert( action );
action = new KAction( i18n( "CC Field Name" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, COCCName );
menu->insert( action );
action = new KAction( i18n( "CC Field First Name" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, COCCFName );
menu->insert( action );
action = new KAction( i18n( "CC Field Last Name" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, COCCLName );
menu->insert( action );
action = new KAction( i18n( "From Field Address" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, COFromAddr );
menu->insert( action );
action = new KAction( i18n( "From Field Name" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, COFromName );
menu->insert( action );
action = new KAction( i18n( "From Field First Name" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, COFromFName );
menu->insert( action );
action = new KAction( i18n( "From Field Last Name" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, COFromLName );
menu->insert( action );
action = new KAction( i18n( "Subject" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, COFullSubject );
menu->insert( action );
action = new KAction( i18n( "Quoted Headers" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CQHeaders );
menu->insert( action );
action = new KAction( i18n( "Headers as Is" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CHeaders );
menu->insert( action );
action = new KAction( i18n( "Header Content" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, COHeader );
menu->insert( action );
// ******************************************************
menu = new KActionMenu( i18n( "Current Message" ), mMenu );
mMenu->insert( menu );
action = new KAction( i18n( "Message Id" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CMsgId );
menu->insert( action );
action = new KAction( i18n( "Date" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CDate );
menu->insert( action );
action = new KAction( i18n( "Date in Short Format" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CDateShort );
menu->insert( action );
action = new KAction( i18n( "Date in C Locale" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CDateEn );
menu->insert( action );
action = new KAction( i18n( "Day of Week" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CDow );
menu->insert( action );
action = new KAction( i18n( "Time" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CTime );
menu->insert( action );
action = new KAction( i18n( "Time in Long Format" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CTimeLong );
menu->insert( action );
action = new KAction( i18n( "Time in C Locale" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CTimeLongEn );
menu->insert( action );
action = new KAction( i18n( "To Field Address" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CToAddr );
menu->insert( action );
action = new KAction( i18n( "To Field Name" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CToName );
menu->insert( action );
action = new KAction( i18n( "To Field First Name" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CToFName );
menu->insert( action );
action = new KAction( i18n( "To Field Last Name" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CToLName );
menu->insert( action );
action = new KAction( i18n( "CC Field Address" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CCCAddr );
menu->insert( action );
action = new KAction( i18n( "CC Field Name" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CCCName );
menu->insert( action );
action = new KAction( i18n( "CC Field First Name" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CCCFName );
menu->insert( action );
action = new KAction( i18n( "CC Field Last Name" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CCCLName );
menu->insert( action );
action = new KAction( i18n( "From Field Address" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CFromAddr );
menu->insert( action );
action = new KAction( i18n( "From Field Name" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CFromName );
menu->insert( action );
action = new KAction( i18n( "From Field First Name" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CFromFName );
menu->insert( action );
action = new KAction( i18n( "From Field Last Name" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CFromLName );
menu->insert( action );
action = new KAction( i18n( "Subject" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CFullSubject );
menu->insert( action );
action = new KAction( i18n( "Header Content" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CHeader );
menu->insert( action );
// ******************************************************
menu = new KActionMenu( i18n( "Process With External Programs" ), mMenu );
mMenu->insert( menu );
action = new KAction( i18n( "Insert Result of Command" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CSystem );
menu->insert( action );
action = new KAction( i18n( "Pipe Original Message Body and Insert Result as Quoted Text" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CQuotePipe );
menu->insert( action );
action = new KAction( i18n( "Pipe Original Message Body and Insert Result as Is" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CTextPipe );
menu->insert( action );
action = new KAction( i18n( "Pipe Original Message with Headers and Insert Result as Is" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CMsgPipe );
menu->insert( action );
action = new KAction( i18n( "Pipe Current Message Body and Insert Result as Is" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CBodyPipe );
menu->insert( action );
action = new KAction( i18n( "Pipe Current Message Body and Replace with Result" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CClearPipe );
menu->insert( action );
// ******************************************************
menu = new KActionMenu( i18n( "Miscellaneous" ), mMenu );
mMenu->insert( menu );
action = new KAction( i18n( "Set Cursor Position" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CCursor );
menu->insert( action );
action = new KAction( i18n( "Insert File Content" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CInsert );
menu->insert( action );
action = new KAction( i18n( "DNL" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CDnl );
menu->insert( action );
action = new KAction( i18n( "Template Comment" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CRem );
menu->insert( action );
action = new KAction( i18n( "No Operation" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CNop );
menu->insert( action );
action = new KAction( i18n( "Clear Generated Message" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CClear );
menu->insert( action );
action = new KAction( i18n( "Turn Debug On" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CDebug );
menu->insert( action );
action = new KAction( i18n( "Turn Debug Off" ),
0, mapper, SLOT( map() ), menu );
mapper->setMapping( action, CDebugOff );
menu->insert( action );
}
void JuK::setupActions()
{
ActionCollection::actions()->setWidget(this);
KStdAction::quit(this, SLOT(slotQuit()), actions());
KStdAction::undo(this, SLOT(slotUndo()), actions());
KStdAction::cut(kapp, SLOT(cut()), actions());
KStdAction::copy(kapp, SLOT(copy()), actions());
KStdAction::paste(kapp, SLOT(paste()), actions());
KStdAction::clear(kapp, SLOT(clear()), actions());
KStdAction::selectAll(kapp, SLOT(selectAll()), actions());
new KAction(i18n("Remove From Playlist"), "edit_remove", 0, kapp, SLOT(clear()), actions(), "removeFromPlaylist");
KActionMenu *actionMenu = new KActionMenu(i18n("&Random Play"), "roll", actions(), "actionMenu");
actionMenu->setDelayed(false);
KRadioAction *ka = new KRadioAction(i18n("&Disable Random Play"), "player_playlist", 0, actions(), "disableRandomPlay");
ka->setExclusiveGroup("randomPlayGroup");
actionMenu->insert(ka);
m_randomPlayAction = new KRadioAction(i18n("Use &Random Play"), "roll", 0, actions(), "randomPlay");
m_randomPlayAction->setExclusiveGroup("randomPlayGroup");
actionMenu->insert(m_randomPlayAction);
ka = new KRadioAction(i18n("Use &Album Random Play"), "roll", 0, actions(), "albumRandomPlay");
ka->setExclusiveGroup("randomPlayGroup");
connect(ka, SIGNAL(toggled(bool)), SLOT(slotCheckAlbumNextAction(bool)));
actionMenu->insert(ka);
new KAction(i18n("&Play"), "player_play", 0, m_player, SLOT(play()), actions(), "play");
new KAction(i18n("P&ause"), "player_pause", 0, m_player, SLOT(pause()), actions(), "pause");
new KAction(i18n("&Stop"), "player_stop", 0, m_player, SLOT(stop()), actions(), "stop");
new KToolBarPopupAction(i18n("previous track", "Previous"), "player_start", KShortcut(), m_player, SLOT(back()), actions(), "back");
new KAction(i18n("next track", "&Next"), "player_end", KShortcut(), m_player, SLOT(forward()), actions(), "forward");
new KToggleAction(i18n("&Loop Playlist"), 0, KShortcut(), actions(), "loopPlaylist");
KToggleAction *resizeColumnAction =
new KToggleAction(i18n("&Resize Playlist Columns Manually"),
KShortcut(), actions(), "resizeColumnsManually");
resizeColumnAction->setCheckedState(i18n("&Resize Column Headers Automatically"));
// the following are not visible by default
new KAction(i18n("Mute"), "mute", 0, m_player, SLOT(mute()), actions(), "mute");
new KAction(i18n("Volume Up"), "volumeUp", 0, m_player, SLOT(volumeUp()), actions(), "volumeUp");
new KAction(i18n("Volume Down"), "volumeDown", 0, m_player, SLOT(volumeDown()), actions(), "volumeDown");
new KAction(i18n("Play / Pause"), "playPause", 0, m_player, SLOT(playPause()), actions(), "playPause");
new KAction(i18n("Seek Forward"), "seekForward", 0, m_player, SLOT(seekForward()), actions(), "seekForward");
new KAction(i18n("Seek Back"), "seekBack", 0, m_player, SLOT(seekBack()), actions(), "seekBack");
//////////////////////////////////////////////////
// settings menu
//////////////////////////////////////////////////
m_toggleSplashAction =
new KToggleAction(i18n("Show Splash Screen on Startup"),
KShortcut(), actions(), "showSplashScreen");
m_toggleSplashAction->setCheckedState(i18n("Hide Splash Screen on Startup"));
m_toggleSystemTrayAction =
new KToggleAction(i18n("&Dock in System Tray"),
KShortcut(), actions(), "toggleSystemTray");
m_toggleDockOnCloseAction =
new KToggleAction(i18n("&Stay in System Tray on Close"),
KShortcut(), actions(), "dockOnClose");
m_togglePopupsAction =
new KToggleAction(i18n("Popup &Track Announcement"),
KShortcut(), this, 0, actions(), "togglePopups");
new KToggleAction(i18n("Save &Play Queue on Exit"),
KShortcut(), this, 0, actions(), "saveUpcomingTracks");
connect(m_toggleSystemTrayAction, SIGNAL(toggled(bool)),
this, SLOT(slotToggleSystemTray(bool)));
m_outputSelectAction = PlayerManager::playerSelectAction(actions());
if(m_outputSelectAction)
m_outputSelectAction->setCurrentItem(0);
new KAction(i18n("&Tag Guesser..."), 0, 0, this, SLOT(slotConfigureTagGuesser()),
actions(), "tagGuesserConfig");
new KAction(i18n("&File Renamer..."), 0, 0, this, SLOT(slotConfigureFileRenamer()),
actions(), "fileRenamerConfig");
KStdAction::keyBindings(this, SLOT(slotEditKeys()), actions());
//////////////////////////////////////////////////
// just in the toolbar
//////////////////////////////////////////////////
m_sliderAction = new SliderAction(i18n("Track Position"), actions(),
"trackPositionAction");
}
void WebView::contextMenuEvent(QContextMenuEvent *event)
{
m_contextMenuHitResult = page()->mainFrame()->hitTestContent(event->pos());
if (m_contextMenuHitResult.isContentEditable())
{
// Check to see if handled by speller
if (popupSpellMenu(event))
return;
}
WebWindow *webwin = m_parentTab->webWindow();
KMenu menu(this);
KAction *sendByMailAction = new KAction(&menu);
sendByMailAction->setIcon(KIcon("mail-send"));
connect(sendByMailAction, SIGNAL(triggered(bool)), this, SLOT(sendByMail()));
// Choose right context
int resultHit = 0;
if (m_contextMenuHitResult.linkUrl().isEmpty())
resultHit = WebView::EmptySelection;
else
resultHit = WebView::LinkSelection;
if (!m_contextMenuHitResult.pixmap().isNull())
resultHit |= WebView::ImageSelection;
if (m_contextMenuHitResult.isContentSelected())
resultHit = WebView::TextSelection;
// --------------------------------------------------------------------------------
// Ok, let's start filling up the menu...
// is content editable? Add PASTE
if (m_contextMenuHitResult.isContentEditable())
{
menu.addAction(pageAction(KWebPage::Paste));
menu.addSeparator();
}
QAction *a;
// EMPTY PAGE ACTIONS -------------------------------------------------------------
if (resultHit == WebView::EmptySelection)
{
// send by mail: page url
sendByMailAction->setData(page()->currentFrame()->url());
sendByMailAction->setText(i18n("Share page URL"));
// navigation
QWebHistory *history = page()->history();
if (history->canGoBack())
{
menu.addAction(pageAction(KWebPage::Back));
}
if (history->canGoForward())
{
menu.addAction(pageAction(KWebPage::Forward));
}
menu.addAction(pageAction(KWebPage::Reload));
menu.addSeparator();
// Frame
KActionMenu *frameMenu = new KActionMenu(i18n("Current Frame"), &menu);
frameMenu->addAction(pageAction(KWebPage::OpenFrameInNewWindow));
a = new KAction(KIcon("document-print-frame"), i18n("Print Frame"), &menu);
connect(a, SIGNAL(triggered()), m_parentTab, SLOT(printFrame()));
frameMenu->addAction(a);
menu.addAction(frameMenu);
menu.addSeparator();
// Page Actions
menu.addAction(pageAction(KWebPage::SelectAll));
if (webwin)
menu.addAction(webwin->actionByName(KStandardAction::name(KStandardAction::Save)));
if (!KStandardDirs::findExe("kget").isNull() && ReKonfig::kgetList())
{
a = new KAction(KIcon("kget"), i18n("List All Links"), &menu);
connect(a, SIGNAL(triggered(bool)), page(), SLOT(downloadAllContentsWithKGet()));
menu.addAction(a);
}
if (webwin)
{
menu.addAction(webwin->actionByName("page_source"));
menu.addAction(webwin->actionByName("web_inspector"));
}
}
// LINK ACTIONS -------------------------------------------------------------------
if (resultHit & WebView::LinkSelection)
{
// send by mail: link url
sendByMailAction->setData(m_contextMenuHitResult.linkUrl());
sendByMailAction->setText(i18n("Share link"));
a = new KAction(KIcon("tab-new"), i18n("Open in New &Tab"), &menu);
a->setData(m_contextMenuHitResult.linkUrl());
connect(a, SIGNAL(triggered(bool)), this, SLOT(openLinkInNewTab()));
menu.addAction(a);
a = new KAction(KIcon("window-new"), i18n("Open in New &Window"), &menu);
a->setData(m_contextMenuHitResult.linkUrl());
connect(a, SIGNAL(triggered(bool)), this, SLOT(openLinkInNewWindow()));
menu.addAction(a);
if (!m_parentTab->isWebApp())
{
a = new KAction(KIcon("view-media-artist"), i18n("Open in Private &Window"), &menu);
a->setData(m_contextMenuHitResult.linkUrl());
connect(a, SIGNAL(triggered(bool)), this, SLOT(openLinkInPrivateWindow()));
menu.addAction(a);
}
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);
}
void KMMainView::initActions()
{
KIconSelectAction *vact = new KIconSelectAction(i18n("&View"), 0, m_actions, "view_change");
QStringList iconlst;
iconlst << "view_icon"
<< "view_detailed"
<< "view_tree";
vact->setItems(QStringList::split(',', i18n("&Icons,&List,&Tree"), false), iconlst);
vact->setCurrentItem(0);
connect(vact, SIGNAL(activated(int)), SLOT(slotChangeView(int)));
KActionMenu *stateAct = new KActionMenu(i18n("Start/Stop Printer"), "kdeprint_printstate", m_actions, "printer_state_change");
stateAct->setDelayed(false);
stateAct->insert(
new KAction(i18n("&Start Printer"), "kdeprint_enableprinter", 0, this, SLOT(slotChangePrinterState()), m_actions, "printer_start"));
stateAct->insert(new KAction(i18n("Sto&p Printer"), "kdeprint_stopprinter", 0, this, SLOT(slotChangePrinterState()), m_actions, "printer_stop"));
stateAct = new KActionMenu(i18n("Enable/Disable Job Spooling"), "kdeprint_queuestate", m_actions, "printer_spool_change");
stateAct->setDelayed(false);
stateAct->insert(
new KAction(i18n("&Enable Job Spooling"), "kdeprint_enableprinter", 0, this, SLOT(slotChangePrinterState()), m_actions, "printer_enable"));
stateAct->insert(
new KAction(i18n("&Disable Job Spooling"), "kdeprint_stopprinter", 0, this, SLOT(slotChangePrinterState()), m_actions, "printer_disable"));
new KAction(i18n("&Remove"), "edittrash", 0, this, SLOT(slotRemove()), m_actions, "printer_remove");
new KAction(i18n("&Configure..."), "configure", 0, this, SLOT(slotConfigure()), m_actions, "printer_configure");
new KAction(i18n("Add &Printer/Class..."), "kdeprint_addprinter", 0, this, SLOT(slotAdd()), m_actions, "printer_add");
new KAction(i18n("Add &Special (pseudo) Printer..."), "kdeprint_addpseudo", 0, this, SLOT(slotAddSpecial()), m_actions, "printer_add_special");
new KAction(i18n("Set as &Local Default"), "kdeprint_defaulthard", 0, this, SLOT(slotHardDefault()), m_actions, "printer_hard_default");
new KAction(i18n("Set as &User Default"), "kdeprint_defaultsoft", 0, this, SLOT(slotSoftDefault()), m_actions, "printer_soft_default");
new KAction(i18n("&Test Printer..."), "kdeprint_testprinter", 0, this, SLOT(slotTest()), m_actions, "printer_test");
new KAction(i18n("Configure &Manager..."), "kdeprint_configmgr", 0, this, SLOT(slotManagerConfigure()), m_actions, "manager_configure");
new KAction(i18n("Initialize Manager/&View"), "reload", 0, this, SLOT(slotInit()), m_actions, "view_refresh");
KIconSelectAction *dact = new KIconSelectAction(i18n("&Orientation"), 0, m_actions, "orientation_change");
iconlst.clear();
iconlst << "view_top_bottom"
<< "view_left_right";
dact->setItems(QStringList::split(',', i18n("&Vertical,&Horizontal"), false), iconlst);
dact->setCurrentItem(0);
connect(dact, SIGNAL(activated(int)), SLOT(slotChangeDirection(int)));
new KAction(i18n("R&estart Server"), "kdeprint_restartsrv", 0, this, SLOT(slotServerRestart()), m_actions, "server_restart");
new KAction(i18n("Configure &Server..."), "kdeprint_configsrv", 0, this, SLOT(slotServerConfigure()), m_actions, "server_configure");
KToggleAction *tact = new KToggleAction(i18n("Show &Toolbar"), 0, m_actions, "view_toolbar");
tact->setCheckedState(i18n("Hide &Toolbar"));
connect(tact, SIGNAL(toggled(bool)), SLOT(slotToggleToolBar(bool)));
tact = new KToggleAction(i18n("Show Me&nu Toolbar"), 0, m_actions, "view_menubar");
tact->setCheckedState(i18n("Hide Me&nu Toolbar"));
connect(tact, SIGNAL(toggled(bool)), SLOT(slotToggleMenuBar(bool)));
tact = new KToggleAction(i18n("Show Pr&inter Details"), "kdeprint_printer_infos", 0, m_actions, "view_printerinfos");
tact->setCheckedState(KGuiItem(i18n("Hide Pr&inter Details"), "kdeprint_printer_infos"));
tact->setChecked(true);
connect(tact, SIGNAL(toggled(bool)), SLOT(slotShowPrinterInfos(bool)));
tact = new KToggleAction(i18n("Toggle Printer &Filtering"), "filter", 0, m_actions, "view_pfilter");
tact->setChecked(KMManager::self()->isFilterEnabled());
connect(tact, SIGNAL(toggled(bool)), SLOT(slotToggleFilter(bool)));
new KAction(i18n("%1 &Handbook").arg("KDEPrint"), "contents", 0, this, SLOT(slotHelp()), m_actions, "invoke_help");
new KAction(i18n("%1 &Web Site").arg("KDEPrint"), "network", 0, this, SLOT(slotHelp()), m_actions, "invoke_web");
KActionMenu *mact = new KActionMenu(i18n("Pri&nter Tools"), "package_utilities", m_actions, "printer_tool");
mact->setDelayed(false);
connect(mact->popupMenu(), SIGNAL(activated(int)), SLOT(slotToolSelected(int)));
QStringList files = KGlobal::dirs()->findAllResources("data", "kdeprint/tools/*.desktop");
for(QStringList::ConstIterator it = files.begin(); it != files.end(); ++it)
{
KSimpleConfig conf(*it);
conf.setGroup("Desktop Entry");
mact->popupMenu()->insertItem(conf.readEntry("Name", "Unnamed"), mact->popupMenu()->count());
m_toollist << conf.readEntry("X-KDE-Library");
}
// add actions to the toolbar
m_actions->action("printer_add")->plug(m_toolbar);
m_actions->action("printer_add_special")->plug(m_toolbar);
m_toolbar->insertLineSeparator();
m_actions->action("printer_state_change")->plug(m_toolbar);
m_actions->action("printer_spool_change")->plug(m_toolbar);
m_toolbar->insertSeparator();
m_actions->action("printer_hard_default")->plug(m_toolbar);
m_actions->action("printer_soft_default")->plug(m_toolbar);
m_actions->action("printer_remove")->plug(m_toolbar);
m_toolbar->insertSeparator();
m_actions->action("printer_configure")->plug(m_toolbar);
m_actions->action("printer_test")->plug(m_toolbar);
m_actions->action("printer_tool")->plug(m_toolbar);
m_pactionsindex = m_toolbar->insertSeparator();
m_toolbar->insertLineSeparator();
m_actions->action("server_restart")->plug(m_toolbar);
m_actions->action("server_configure")->plug(m_toolbar);
m_toolbar->insertLineSeparator();
m_actions->action("manager_configure")->plug(m_toolbar);
m_actions->action("view_refresh")->plug(m_toolbar);
m_toolbar->insertLineSeparator();
m_actions->action("view_printerinfos")->plug(m_toolbar);
m_actions->action("view_change")->plug(m_toolbar);
m_actions->action("orientation_change")->plug(m_toolbar);
m_actions->action("view_pfilter")->plug(m_toolbar);
// add actions to the menu bar
QPopupMenu *menu = new QPopupMenu(this);
m_actions->action("printer_add")->plug(menu);
m_actions->action("printer_add_special")->plug(menu);
// m_menubar->insertItem( i18n( "Add" ), menu );
m_menubar->insertButton("wizard", 0, true, i18n("Add"));
m_menubar->getButton(0)->setPopup(menu, true);
menu = new QPopupMenu(this);
m_actions->action("printer_state_change")->plug(menu);
m_actions->action("printer_spool_change")->plug(menu);
menu->insertSeparator();
m_actions->action("printer_hard_default")->plug(menu);
m_actions->action("printer_soft_default")->plug(menu);
m_actions->action("printer_remove")->plug(menu);
menu->insertSeparator();
m_actions->action("printer_configure")->plug(menu);
m_actions->action("printer_test")->plug(menu);
m_actions->action("printer_tool")->plug(menu);
menu->insertSeparator();
// m_menubar->insertItem( i18n( "Printer" ), menu );
m_menubar->insertButton("printer1", 1, true, i18n("Printer"));
m_menubar->getButton(1)->setPopup(menu, true);
menu = new QPopupMenu(this);
m_actions->action("server_restart")->plug(menu);
m_actions->action("server_configure")->plug(menu);
// m_menubar->insertItem( i18n( "Server" ), menu );
m_menubar->insertButton("misc", 2, true, i18n("Print Server"));
m_menubar->getButton(2)->setPopup(menu, true);
menu = new QPopupMenu(this);
m_actions->action("manager_configure")->plug(menu);
m_actions->action("view_refresh")->plug(menu);
// m_menubar->insertItem( i18n( "Manager" ), menu );
m_menubar->insertButton("kdeprint_configmgr", 3, true, i18n("Print Manager"));
m_menubar->getButton(3)->setPopup(menu, true);
menu = new QPopupMenu(this);
m_actions->action("view_printerinfos")->plug(menu);
m_actions->action("view_change")->plug(menu);
m_actions->action("orientation_change")->plug(menu);
m_actions->action("view_toolbar")->plug(menu);
m_actions->action("view_menubar")->plug(menu);
menu->insertSeparator();
m_actions->action("view_pfilter")->plug(menu);
// m_menubar->insertItem( i18n( "View" ), menu );
m_menubar->insertButton("view_remove", 4, true, i18n("View"));
m_menubar->getButton(4)->setPopup(menu, true);
// m_menubar->setMinimumHeight( m_menubar->heightForWidth( 1000 ) );
menu = new QPopupMenu(this);
m_actions->action("invoke_help")->plug(menu);
m_actions->action("invoke_web")->plug(menu);
m_menubar->insertButton("help", 5, true, i18n("Documentation"));
m_menubar->getButton(5)->setPopup(menu, true);
loadPluginActions();
slotPrinterSelected(QString::null);
}
KexiReportView::KexiReportView(QWidget *parent)
: KexiView(parent), m_preRenderer(0), m_reportDocument(0) //! @todo KEXI3, m_kexi(0), m_functions(0)
{
setObjectName("KexiReportDesigner_DataView");
m_reportView = new KReportView(this);
layout()->addWidget(m_reportView);
#ifndef KEXI_MOBILE
m_pageSelector = new KexiRecordNavigator(*m_reportView->scrollArea(), m_reportView);
m_pageSelector->setInsertingButtonVisible(false);
m_pageSelector->setInsertingEnabled(false);
m_pageSelector->setLabelText(xi18nc("Page selector label", "Page:"));
m_pageSelector->setButtonToolTipText(KexiRecordNavigator::ButtonFirst, xi18n("Go to first page"));
m_pageSelector->setButtonWhatsThisText(KexiRecordNavigator::ButtonFirst, xi18n("Goes to first page"));
m_pageSelector->setButtonToolTipText(KexiRecordNavigator::ButtonPrevious, xi18n("Go to previous page"));
m_pageSelector->setButtonWhatsThisText(KexiRecordNavigator::ButtonPrevious, xi18n("Goes to previous page"));
m_pageSelector->setButtonToolTipText(KexiRecordNavigator::ButtonNext, xi18n("Go to next page"));
m_pageSelector->setButtonWhatsThisText(KexiRecordNavigator::ButtonNext, xi18n("Goes to next page"));
m_pageSelector->setButtonToolTipText(KexiRecordNavigator::ButtonLast, xi18n("Go to last page"));
m_pageSelector->setButtonWhatsThisText(KexiRecordNavigator::ButtonLast, xi18n("Goes to last page"));
m_pageSelector->setNumberFieldToolTips(xi18n("Current page number"), xi18n("Number of pages"));
m_pageSelector->setRecordHandler(this);
#endif
// -- setup local actions
QList<QAction*> viewActions;
QAction* a;
#ifndef KEXI_MOBILE
viewActions << (a = new QAction(koIcon("document-print"), xi18n("Print"), this));
a->setObjectName("print_report");
a->setToolTip(xi18n("Print report"));
a->setWhatsThis(xi18n("Prints the current report."));
connect(a, SIGNAL(triggered()), this, SLOT(slotPrintReport()));
KActionMenu *exportMenu = new KActionMenu(koIcon("document-export"), xi18nc("@title:menu","E&xport As"), this);
exportMenu->setObjectName("report_export_as");
exportMenu->setDelayed(false);
#endif
#ifdef KEXI_MOBILE
viewActions << (a = new QAction(xi18n("Export:"), this));
a->setEnabled(false); //!TODO this is a bit of a dirty way to add what looks like a label to the toolbar!
// " ", not "", is said to be needed in maemo, the icon didn't display properly without it
viewActions << (a = new QAction(koIcon("application-vnd.oasis.opendocument.text"), QLatin1String(" "), this));
#else
exportMenu->addAction(a = new QAction(koIcon("application-vnd.oasis.opendocument.text"),
xi18nc("open dialog to export as text document", "Text Document..."), this));
#endif
a->setObjectName("export_as_text_document");
a->setToolTip(xi18n("Export the report as a text document (in OpenDocument Text format)"));
a->setWhatsThis(xi18n("Exports the report as a text document (in OpenDocument Text format)."));
a->setEnabled(true);
connect(a, SIGNAL(triggered()), this, SLOT(slotExportAsTextDocument()));
#ifdef KEXI_MOBILE
viewActions << (a = new QAction(koIcon("application-pdf"), QLatin1String(" "), this));
#else
exportMenu->addAction(a = new QAction(koIcon("application-pdf"),
xi18nc("Portable Document Format...", "PDF..."), this));
#endif
a->setObjectName("export_as_pdf");
a->setToolTip(xi18n("Export as PDF"));
a->setWhatsThis(xi18n("Exports the current report as PDF."));
a->setEnabled(true);
connect(a, SIGNAL(triggered()), this, SLOT(slotExportAsPdf()));
#ifdef KEXI_MOBILE
viewActions << (a = new QAction(koIcon("application-vnd.oasis.opendocument.spreadsheet"), QLatin1String(" "), this));
#else
exportMenu->addAction(a = new QAction(koIcon("application-vnd.oasis.opendocument.spreadsheet"),
xi18nc("open dialog to export as spreadsheet", "Spreadsheet..."), this));
#endif
a->setObjectName("export_as_spreadsheet");
a->setToolTip(xi18n("Export the report as a spreadsheet (in OpenDocument Spreadsheet format)"));
a->setWhatsThis(xi18n("Exports the report as a spreadsheet (in OpenDocument Spreadsheet format)."));
a->setEnabled(true);
connect(a, SIGNAL(triggered()), this, SLOT(slotExportAsSpreadsheet()));
#ifdef KEXI_MOBILE
viewActions << (a = new QAction(koIcon("text-html"), QLatin1String(" "), this));
#else
exportMenu->addAction(a = new QAction(koIcon("text-html"),
xi18nc("open dialog to export as web page", "Web Page..."), this));
#endif
a->setObjectName("export_as_web_page");
a->setToolTip(xi18n("Export the report as a web page (in HTML format)"));
a->setWhatsThis(xi18n("Exports the report as a web page (in HTML format)."));
a->setEnabled(true);
connect(a, SIGNAL(triggered()), this, SLOT(slotExportAsWebPage()));
setViewActions(viewActions);
#ifndef KEXI_MOBILE
// setup main menu actions
QList<QAction*> mainMenuActions;
mainMenuActions << exportMenu;
setMainMenuActions(mainMenuActions);
connect(m_pageSelector, SIGNAL(nextButtonClicked()), this, SLOT(nextPage()));
connect(m_pageSelector, SIGNAL(prevButtonClicked()), this, SLOT(prevPage()));
connect(m_pageSelector, SIGNAL(firstButtonClicked()), this, SLOT(firstPage()));
connect(m_pageSelector, SIGNAL(lastButtonClicked()), this, SLOT(lastPage()));
#endif
}
void MainWindow::setupActions()
{
KAction *newDownloadAction = actionCollection()->addAction("new_download");
newDownloadAction->setText(i18n("&New Download..."));
newDownloadAction->setIcon(KIcon("document-new"));
newDownloadAction->setShortcuts(KShortcut("Ctrl+N"));
newDownloadAction->setHelpText(i18n("Opens a dialog to add a transfer to the list"));
connect(newDownloadAction, SIGNAL(triggered()), SLOT(slotNewTransfer()));
KAction *openAction = actionCollection()->addAction("import_transfers");
openAction->setText(i18n("&Import Transfers..."));
openAction->setIcon(KIcon("document-open"));
openAction->setShortcuts(KShortcut("Ctrl+I"));
openAction->setHelpText(i18n("Imports a list of transfers"));
connect(openAction, SIGNAL(triggered()), SLOT(slotImportTransfers()));
KAction *exportAction = actionCollection()->addAction("export_transfers");
exportAction->setText(i18n("&Export Transfers List..."));
exportAction->setIcon(KIcon("document-export"));
exportAction->setShortcuts(KShortcut("Ctrl+E"));
exportAction->setHelpText(i18n("Exports the current transfers into a file"));
connect(exportAction, SIGNAL(triggered()), SLOT(slotExportTransfers()));
KAction *createMetalinkAction = actionCollection()->addAction("create_metalink");
createMetalinkAction->setText(i18n("&Create a Metalink..."));
createMetalinkAction->setIcon(KIcon("journal-new"));
createMetalinkAction->setHelpText(i18n("Creates or modifies a metalink and saves it on disk"));
connect(createMetalinkAction, SIGNAL(triggered()), SLOT(slotCreateMetalink()));
KAction *priorityTop = actionCollection()->addAction("priority_top");
priorityTop->setText(i18n("Top Priority"));
priorityTop->setIcon(KIcon("arrow-up-double"));
priorityTop->setShortcuts(KShortcut("Ctrl+PgUp"));
priorityTop->setHelpText(i18n("Download selected transfer first"));
connect(priorityTop, SIGNAL(triggered()), this, SLOT(slotPriorityTop()));
KAction *priorityBottom = actionCollection()->addAction("priority_bottom");
priorityBottom->setText(i18n("Least Priority"));
priorityBottom->setIcon(KIcon("arrow-down-double"));
priorityBottom->setShortcuts(KShortcut("Ctrl+PgDown"));
priorityBottom->setHelpText(i18n("Download selected transfer last"));
connect(priorityBottom, SIGNAL(triggered()), this, SLOT(slotPriorityBottom()));
KAction *priorityUp = actionCollection()->addAction("priority_up");
priorityUp->setText(i18n("Increase Priority"));
priorityUp->setIcon(KIcon("arrow-up"));
priorityUp->setShortcuts(KShortcut("Ctrl+Up"));
priorityUp->setHelpText(i18n("Increase priority for selected transfer"));
connect(priorityUp, SIGNAL(triggered()), this, SLOT(slotPriorityUp()));
KAction *priorityDown = actionCollection()->addAction("priority_down");
priorityDown->setText(i18n("Decrease Priority"));
priorityDown->setIcon(KIcon("arrow-down"));
priorityDown->setShortcuts(KShortcut("Ctrl+Down"));
priorityDown->setHelpText(i18n("Decrease priority for selected transfer"));
connect(priorityDown, SIGNAL(triggered()), this, SLOT(slotPriorityDown()));
//FIXME: Not needed maybe because the normal delete already deletes groups?
KAction *deleteGroupAction = actionCollection()->addAction("delete_groups");
deleteGroupAction->setText(i18n("Delete Group"));
deleteGroupAction->setIcon(KIcon("edit-delete"));
deleteGroupAction->setHelpText(i18n("Delete selected group"));
connect(deleteGroupAction, SIGNAL(triggered()), SLOT(slotDeleteGroup()));
KAction *renameGroupAction = actionCollection()->addAction("rename_groups");
renameGroupAction->setText(i18n("Rename Group..."));
renameGroupAction->setIcon(KIcon("edit-rename"));
connect(renameGroupAction, SIGNAL(triggered()), SLOT(slotRenameGroup()));
KAction *setIconGroupAction = actionCollection()->addAction("seticon_groups");
setIconGroupAction->setText(i18n("Set Icon..."));
setIconGroupAction->setIcon(KIcon("preferences-desktop-icons"));
setIconGroupAction->setHelpText(i18n("Select a custom icon for the selected group"));
connect(setIconGroupAction, SIGNAL(triggered()), SLOT(slotSetIconGroup()));
m_autoPasteAction = new KToggleAction(KIcon("edit-paste"),
i18n("Auto-Paste Mode"), actionCollection());
actionCollection()->addAction("auto_paste", m_autoPasteAction);
m_autoPasteAction->setChecked(Settings::autoPaste());
m_autoPasteAction->setWhatsThis(i18n("<b>Auto paste</b> button toggles the auto-paste mode "
"on and off.\nWhen set, KGet will periodically scan "
"the clipboard for URLs and paste them automatically."));
connect(m_autoPasteAction, SIGNAL(triggered()), SLOT(slotToggleAutoPaste()));
m_konquerorIntegration = new KToggleAction(KIcon("konqueror"),
i18n("Use KGet as Konqueror Download Manager"), actionCollection());
actionCollection()->addAction("konqueror_integration", m_konquerorIntegration);
connect(m_konquerorIntegration, SIGNAL(triggered(bool)), SLOT(slotTrayKonquerorIntegration(bool)));
m_konquerorIntegration->setChecked(Settings::konquerorIntegration());
// local - Destroys all sub-windows and exits
KStandardAction::quit(this, SLOT(slotQuit()), actionCollection());
// local - Standard configure actions
KStandardAction::preferences(this, SLOT(slotPreferences()), actionCollection());
KStandardAction::configureNotifications(this, SLOT(slotConfigureNotifications()), actionCollection());
m_menubarAction = KStandardAction::showMenubar(this, SLOT(slotShowMenubar()), actionCollection());
m_menubarAction->setChecked(!menuBar()->isHidden());
// Transfer related actions
actionCollection()->addAction(KStandardAction::SelectAll, "select_all", m_viewsContainer, SLOT(selectAll()));
KAction *deleteSelectedAction = actionCollection()->addAction("delete_selected_download");
deleteSelectedAction->setText(i18nc("delete selected transfer item", "Remove Selected"));
deleteSelectedAction->setIcon(KIcon("edit-delete"));
deleteSelectedAction->setShortcuts(KShortcut("Del"));
deleteSelectedAction->setHelpText(i18n("Removes selected transfer and deletes files from disk if it's not finished"));
connect(deleteSelectedAction, SIGNAL(triggered()), SLOT(slotDeleteSelected()));
KAction *deleteAllFinishedAction = actionCollection()->addAction("delete_all_finished");
deleteAllFinishedAction->setText(i18nc("delete all finished transfers", "Remove All Finished"));
deleteAllFinishedAction->setIcon(KIcon("edit-clear-list"));
deleteAllFinishedAction->setHelpText(i18n("Removes all finished transfers and leaves all files on disk"));
connect(deleteAllFinishedAction, SIGNAL(triggered()), SLOT(slotDeleteFinished()));
KAction *deleteSelectedIncludingFilesAction = actionCollection()->addAction("delete_selected_download_including_files");
deleteSelectedIncludingFilesAction->setText(i18nc("delete selected transfer item and files", "Remove Selected and Delete Files"));
deleteSelectedIncludingFilesAction->setIcon(KIcon("edit-delete"));
deleteSelectedIncludingFilesAction->setHelpText(i18n("Removes selected transfer and deletes files from disk in any case"));
connect(deleteSelectedIncludingFilesAction, SIGNAL(triggered()), SLOT(slotDeleteSelectedIncludingFiles()));
KAction *redownloadSelectedAction = actionCollection()->addAction("redownload_selected_download");
redownloadSelectedAction->setText(i18nc("redownload selected transfer item", "Redownload Selected"));
redownloadSelectedAction->setIcon(KIcon("view-refresh"));
connect(redownloadSelectedAction, SIGNAL(triggered()), SLOT(slotRedownloadSelected()));
KAction *startAllAction = actionCollection()->addAction("start_all_download");
startAllAction->setText(i18n("Start All"));
startAllAction->setIcon(KIcon("media-seek-forward"));
startAllAction->setShortcuts(KShortcut("Ctrl+R"));
startAllAction->setHelpText(i18n("Starts / resumes all transfers"));
connect(startAllAction, SIGNAL(triggered()), SLOT(slotStartAllDownload()));
KAction *startSelectedAction = actionCollection()->addAction("start_selected_download");
startSelectedAction->setText(i18n("Start Selected"));
startSelectedAction->setIcon(KIcon("media-playback-start"));
startSelectedAction->setHelpText(i18n("Starts / resumes selected transfer"));
connect(startSelectedAction, SIGNAL(triggered()), SLOT(slotStartSelectedDownload()));
KAction *stopAllAction = actionCollection()->addAction("stop_all_download");
stopAllAction->setText(i18n("Pause All"));
stopAllAction->setIcon(KIcon("media-playback-pause"));
stopAllAction->setShortcuts(KShortcut("Ctrl+P"));
stopAllAction->setHelpText(i18n("Pauses all transfers"));
connect(stopAllAction, SIGNAL(triggered()), SLOT(slotStopAllDownload()));
KAction *stopSelectedAction = actionCollection()->addAction("stop_selected_download");
stopSelectedAction->setText(i18n("Stop Selected"));
stopSelectedAction->setIcon(KIcon("media-playback-pause"));
stopSelectedAction->setHelpText(i18n("Pauses selected transfer"));
connect(stopSelectedAction, SIGNAL(triggered()), SLOT(slotStopSelectedDownload()));
KActionMenu *startActionMenu = new KActionMenu(KIcon("media-playback-start"), i18n("Start"),
actionCollection());
actionCollection()->addAction("start_menu", startActionMenu);
startActionMenu->setDelayed(true);
startActionMenu->addAction(startSelectedAction);
startActionMenu->addAction(startAllAction);
connect(startActionMenu, SIGNAL(triggered()), SLOT(slotStartDownload()));
KActionMenu *stopActionMenu = new KActionMenu(KIcon("media-playback-pause"), i18n("Pause"),
actionCollection());
actionCollection()->addAction("stop_menu", stopActionMenu);
stopActionMenu->setDelayed(true);
stopActionMenu->addAction(stopSelectedAction);
stopActionMenu->addAction(stopAllAction);
connect(stopActionMenu, SIGNAL(triggered()), SLOT(slotStopDownload()));
KAction *openDestAction = actionCollection()->addAction("transfer_open_dest");
openDestAction->setText(i18n("Open Destination"));
openDestAction->setIcon(KIcon("document-open"));
connect(openDestAction, SIGNAL(triggered()), SLOT(slotTransfersOpenDest()));
KAction *openFileAction = actionCollection()->addAction("transfer_open_file");
openFileAction->setText(i18n("Open File"));
openFileAction->setIcon(KIcon("document-open"));
connect(openFileAction, SIGNAL(triggered()), SLOT(slotTransfersOpenFile()));
KAction *showDetailsAction = new KToggleAction(KIcon("document-properties"), i18n("Show Details"), actionCollection());
actionCollection()->addAction("transfer_show_details", showDetailsAction);
connect(showDetailsAction, SIGNAL(triggered()), SLOT(slotTransfersShowDetails()));
KAction *copyUrlAction = actionCollection()->addAction("transfer_copy_source_url");
copyUrlAction->setText(i18n("Copy URL to Clipboard"));
copyUrlAction->setIcon(KIcon("edit-copy"));
connect(copyUrlAction, SIGNAL(triggered()), SLOT(slotTransfersCopySourceUrl()));
KAction *transferHistoryAction = actionCollection()->addAction("transfer_history");
transferHistoryAction->setText(i18n("&Transfer History"));
transferHistoryAction->setIcon(KIcon("view-history"));
transferHistoryAction->setShortcuts(KShortcut("Ctrl+H"));
connect(transferHistoryAction, SIGNAL(triggered()), SLOT(slotTransferHistory()));
KAction *transferGroupSettingsAction = actionCollection()->addAction("transfer_group_settings");
transferGroupSettingsAction->setText(i18n("&Group Settings"));
transferGroupSettingsAction->setIcon(KIcon("preferences-system"));
transferGroupSettingsAction->setShortcuts(KShortcut("Ctrl+G"));
connect(transferGroupSettingsAction, SIGNAL(triggered()), SLOT(slotTransferGroupSettings()));
KAction *transferSettingsAction = actionCollection()->addAction("transfer_settings");
transferSettingsAction->setText(i18n("&Transfer Settings"));
transferSettingsAction->setIcon(KIcon("preferences-system"));
transferSettingsAction->setShortcuts(KShortcut("Ctrl+T"));
connect(transferSettingsAction, SIGNAL(triggered()), SLOT(slotTransferSettings()));
KAction *listLinksAction = actionCollection()->addAction("import_links");
listLinksAction->setText(i18n("Import &Links..."));
listLinksAction->setIcon(KIcon("view-list-text"));
listLinksAction->setShortcuts(KShortcut("Ctrl+L"));
connect(listLinksAction, SIGNAL(triggered()), SLOT(slotShowListLinks()));
//create the download finished actions which can be displayed in the toolbar
KSelectAction *downloadFinishedActions = new KSelectAction(i18n("After downloads finished action"), this);//TODO maybe with name??
actionCollection()->addAction("download_finished_actions", downloadFinishedActions);
downloadFinishedActions->setHelpText(i18n("Choose an action that is executed after all downloads have been finished."));
KAction *noAction = downloadFinishedActions->addAction(i18n("No Action"));
connect(noAction, SIGNAL(triggered()), SLOT(slotDownloadFinishedActions()));
downloadFinishedActions->addAction(noAction);
KAction *quitAction = downloadFinishedActions->addAction(i18n("Quit KGet"));
quitAction->setData(KGet::Quit);
connect(quitAction, SIGNAL(triggered()), SLOT(slotDownloadFinishedActions()));
downloadFinishedActions->addAction(quitAction);
#ifdef HAVE_KWORKSPACE
KAction *shutdownAction = downloadFinishedActions->addAction(i18n("Turn Off Computer"));
shutdownAction->setData(KGet::Shutdown);
connect(shutdownAction, SIGNAL(triggered()), SLOT(slotDownloadFinishedActions()));
downloadFinishedActions->addAction(shutdownAction);
KAction *hibernateAction = downloadFinishedActions->addAction(i18n("Hibernate Computer"));
hibernateAction->setData(KGet::Hibernate);
connect(hibernateAction, SIGNAL(triggered()), SLOT(slotDownloadFinishedActions()));
downloadFinishedActions->addAction(hibernateAction);
KAction *suspendAction = downloadFinishedActions->addAction(i18n("Suspend Computer"));
suspendAction->setData(KGet::Suspend);
connect(suspendAction, SIGNAL(triggered()), SLOT(slotDownloadFinishedActions()));
downloadFinishedActions->addAction(suspendAction);
#endif
if (Settings::afterFinishActionEnabled()) {
downloadFinishedActions->setCurrentItem(Settings::afterFinishAction() + 1);
} else {
downloadFinishedActions->setCurrentItem(0);
}
}
// TODO convert to use xmlui file
void KuickShow::initGUI( const KURL& startDir )
{
KURL startURL( startDir );
if ( !KProtocolInfo::supportsListing( startURL ) )
startURL = KURL();
fileWidget = new FileWidget( startURL, this, "MainWidget" );
setFocusProxy( fileWidget );
KActionCollection *coll = fileWidget->actionCollection();
redirectDeleteAndTrashActions(coll);
connect( fileWidget, SIGNAL( fileSelected( const KFileItem * ) ),
this, SLOT( slotSelected( const KFileItem * ) ));
connect( fileWidget, SIGNAL( fileHighlighted( const KFileItem * )),
this, SLOT( slotHighlighted( const KFileItem * ) ));
connect( fileWidget, SIGNAL( urlEntered( const KURL& )),
this, SLOT( dirSelected( const KURL& )) );
fileWidget->setAcceptDrops(true);
connect( fileWidget, SIGNAL( dropped( const KFileItem *, QDropEvent *, const KURL::List & )),
this, SLOT( slotDropped( const KFileItem *, QDropEvent *, const KURL::List &)) );
// setup actions
KAction *open = KStdAction::open( this, SLOT( slotOpenURL() ),
coll, "openURL" );
KAction *print = KStdAction::print( this, SLOT( slotPrint() ),
coll, "kuick_print" );
print->setText( i18n("Print Image...") );
KAction *configure = new KAction( i18n("Configure %1...").arg( KGlobal::instance()->aboutData()->programName() ), "configure",
KShortcut(),
this, SLOT( configuration() ),
coll, "kuick_configure" );
KAction *slide = new KAction( i18n("Start Slideshow" ), "ksslide",
KShortcut( Key_F2 ),
this, SLOT( startSlideShow() ),
coll, "kuick_slideshow" );
KAction *about = new KAction( i18n( "About KuickShow" ), "about",
KShortcut(),
this, SLOT( about() ), coll, "about" );
oneWindowAction = new KToggleAction( i18n("Open Only One Image Window"),
"window_new",
KShortcut( CTRL+Key_N ), coll,
"kuick_one window" );
m_toggleBrowserAction = new KToggleAction( i18n("Show File Browser"), KShortcut( Key_Space ), coll, "toggleBrowser" );
m_toggleBrowserAction->setCheckedState(i18n("Hide File Browser"));
connect( m_toggleBrowserAction, SIGNAL( toggled( bool ) ),
SLOT( toggleBrowser() ));
KAction *showInOther = new KAction( i18n("Show Image"), KShortcut(),
this, SLOT( slotShowInOtherWindow() ),
coll, "kuick_showInOtherWindow" );
KAction *showInSame = new KAction( i18n("Show Image in Active Window"),
KShortcut(),
this, SLOT( slotShowInSameWindow() ),
coll, "kuick_showInSameWindow" );
KAction *showFullscreen = new KAction( i18n("Show Image in Fullscreen Mode"),
KShortcut(), this, SLOT( slotShowFullscreen() ),
coll, "kuick_showFullscreen" );
KAction *quit = KStdAction::quit( this, SLOT(slotQuit()), coll, "quit");
// remove QString::null parameter -- ellis
coll->readShortcutSettings( QString::null );
m_accel = coll->accel();
// menubar
KMenuBar *mBar = menuBar();
QPopupMenu *fileMenu = new QPopupMenu( mBar, "file" );
open->plug( fileMenu );
showInOther->plug( fileMenu );
showInSame->plug( fileMenu );
showFullscreen->plug( fileMenu );
fileMenu->insertSeparator();
slide->plug( fileMenu );
print->plug( fileMenu );
fileMenu->insertSeparator();
quit->plug( fileMenu );
QPopupMenu *editMenu = new QPopupMenu( mBar, "edit" );
coll->action("mkdir")->plug( editMenu );
coll->action("delete")->plug( editMenu );
editMenu->insertSeparator();
coll->action("properties")->plug( editMenu );
// remove the Sorting submenu (and the separator below)
// from the main contextmenu
KActionMenu *sortingMenu = static_cast<KActionMenu*>( coll->action("sorting menu"));
KActionMenu *mainActionMenu = static_cast<KActionMenu*>( coll->action("popupMenu"));
QPopupMenu *mainPopup = mainActionMenu->popupMenu();
int sortingIndex = mainPopup->indexOf( sortingMenu->itemId( 0 ) );
int separatorId = mainPopup->idAt( sortingIndex + 1 );
QMenuItem *separatorItem = mainPopup->findItem( separatorId );
if ( separatorItem && separatorItem->isSeparator() )
mainPopup->removeItem( separatorId );
mainActionMenu->remove( sortingMenu );
// add the sorting menu and a separator into the View menu
KActionMenu *viewActionMenu = static_cast<KActionMenu*>( coll->action("view menu"));
viewActionMenu->popupMenu()->insertSeparator( 0 );
sortingMenu->plug( viewActionMenu->popupMenu(), 0 ); // on top of the menu
QPopupMenu *settingsMenu = new QPopupMenu( mBar, "settings" );
configure->plug( settingsMenu );
mBar->insertItem( i18n("&File"), fileMenu );
mBar->insertItem( i18n("&Edit"), editMenu );
viewActionMenu->plug( mBar );
mBar->insertItem( i18n("&Settings"), settingsMenu );
// toolbar
KToolBar *tBar = toolBar();
tBar->setText( i18n( "Main Toolbar" ) );
coll->action("up")->plug( tBar );
coll->action("back")->plug( tBar );
coll->action("forward")->plug( tBar );
coll->action("home")->plug( tBar );
coll->action("reload")->plug( tBar );
tBar->insertSeparator();
coll->action( "short view" )->plug( tBar );
coll->action( "detailed view" )->plug( tBar );
coll->action( "preview")->plug( tBar );
tBar->insertSeparator();
configure->plug( tBar );
slide->plug( tBar );
tBar->insertSeparator();
oneWindowAction->plug( tBar );
print->plug( tBar );
tBar->insertSeparator();
about->plug( tBar );
QPopupMenu *help = helpMenu( QString::null, false );
mBar->insertItem( KStdGuiItem::help().text() , help );
KStatusBar* sBar = statusBar();
sBar->insertItem( " ", URL_ITEM, 10 );
sBar->insertItem( " ", META_ITEM, 2 );
sBar->setItemAlignment(URL_ITEM, QLabel::AlignVCenter | QLabel::AlignLeft);
fileWidget->setFocus();
KConfig *kc = KGlobal::config();
kc->setGroup("SessionSettings");
bool oneWindow = kc->readBoolEntry("OpenImagesInActiveWindow", true );
oneWindowAction->setChecked( oneWindow );
tBar->show();
// Address box in address tool bar
KToolBar *addressToolBar = toolBar( "address_bar" );
const int ID_ADDRESSBAR = 1;
cmbPath = new KURLComboBox( KURLComboBox::Directories,
true, addressToolBar, "address_combo_box" );
KURLCompletion *cmpl = new KURLCompletion( KURLCompletion::DirCompletion );
cmbPath->setCompletionObject( cmpl );
cmbPath->setAutoDeleteCompletionObject( true );
addressToolBar->insertWidget( ID_ADDRESSBAR, 1, cmbPath);
addressToolBar->setItemAutoSized( ID_ADDRESSBAR );
connect( cmbPath, SIGNAL( urlActivated( const KURL& )),
this, SLOT( slotSetURL( const KURL& )));
connect( cmbPath, SIGNAL( returnPressed()),
this, SLOT( slotURLComboReturnPressed()));
fileWidget->initActions();
fileWidget->clearHistory();
dirSelected( fileWidget->url() );
setCentralWidget( fileWidget );
setupGUI( KMainWindow::Save );
coll->action( "reload" )->setShortcut( KStdAccel::reload() );
coll->action( "short view" )->setShortcut(Key_F6);
coll->action( "detailed view" )->setShortcut(Key_F7);
coll->action( "show hidden" )->setShortcut(Key_F8);
coll->action( "mkdir" )->setShortcut(Key_F10);
coll->action( "preview" )->setShortcut(Key_F11);
coll->action( "separate dirs" )->setShortcut(Key_F12);
}
void KexiFormPart::initInstanceActions()
{
//connect actions provided by widget factories
createSharedAction(Kexi::DesignViewMode, i18n("Clear Widget Contents"),
koIconName("edit-clear"), KShortcut(), "formpart_clear_contents");
createSharedAction(Kexi::DesignViewMode, i18n("Edit Tab Order..."),
koIconName("tab_order"), KShortcut(), "formpart_taborder");
//! @todo createSharedAction(Kexi::DesignViewMode, i18n("Edit Pixmap Collection"), koIconName("icons"), 0, "formpart_pixmap_collection");
//! @todo createSharedAction(Kexi::DesignViewMode, i18n("Edit Form Connections"), koIconName("connections"), 0, "formpart_connections");
// KFormDesigner::CreateLayoutCommand
KAction *action = createSharedAction(Kexi::DesignViewMode, i18n("Layout Widgets"),
QString(), KShortcut(), "formpart_layout_menu", "KActionMenu");
KActionMenu *menu = static_cast<KActionMenu*>(action);
menu->addAction(createSharedAction(Kexi::DesignViewMode, i18n("&Horizontally"),
QString(), KShortcut(), "formpart_layout_hbox"));
menu->addAction(createSharedAction(Kexi::DesignViewMode, i18n("&Vertically"),
QString(), KShortcut(), "formpart_layout_vbox"));
menu->addAction(createSharedAction(Kexi::DesignViewMode, i18n("In &Grid"),
QString(), KShortcut(), "formpart_layout_grid"));
#ifdef KEXI_SHOW_SPLITTER_WIDGET
menu->addAction(createSharedAction(Kexi::DesignViewMode, i18n("Horizontally in &Splitter"),
QString(), KShortcut(), "formpart_layout_hsplitter"));
menu->addAction(createSharedAction(Kexi::DesignViewMode, i18n("Verti&cally in Splitter"),
QString(), KShortcut(), "formpart_layout_vsplitter"));
#endif
createSharedAction(Kexi::DesignViewMode, i18n("&Break Layout"), QString(),
KShortcut(), "formpart_break_layout");
/*
createSharedAction(Kexi::DesignViewMode, i18n("Lay Out Widgets &Horizontally"), QString(), 0, "formpart_layout_hbox");
createSharedAction(Kexi::DesignViewMode, i18n("Lay Out Widgets &Vertically"), QString(), 0, "formpart_layout_vbox");
createSharedAction(Kexi::DesignViewMode, i18n("Lay Out Widgets in &Grid"), QString(), 0, "formpart_layout_grid");
*/
createSharedAction(Kexi::DesignViewMode, i18n("Bring Widget to Front"), koIconName("raise"),
KShortcut(), "formpart_format_raise");
createSharedAction(Kexi::DesignViewMode, i18n("Send Widget to Back"), koIconName("lower"),
KShortcut(), "formpart_format_lower");
#ifdef KEXI_SHOW_UNFINISHED
action = createSharedAction(Kexi::DesignViewMode, i18n("Other Widgets"), QString(),
KShortcut(), "other_widgets_menu", "KActionMenu");
#endif
action = createSharedAction(Kexi::DesignViewMode, i18n("Align Widgets Position"),
koIconName("aoleft"), KShortcut(), "formpart_align_menu", "KActionMenu");
menu = static_cast<KActionMenu*>(action);
menu->addAction(createSharedAction(Kexi::DesignViewMode, i18n("To Left"), koIconName("aoleft"),
KShortcut(), "formpart_align_to_left"));
menu->addAction(createSharedAction(Kexi::DesignViewMode, i18n("To Right"), koIconName("aoright"),
KShortcut(), "formpart_align_to_right"));
menu->addAction(createSharedAction(Kexi::DesignViewMode, i18n("To Top"), koIconName("aotop"),
KShortcut(), "formpart_align_to_top"));
menu->addAction(createSharedAction(Kexi::DesignViewMode, i18n("To Bottom"), koIconName("aobottom"),
KShortcut(), "formpart_align_to_bottom"));
menu->addAction(createSharedAction(Kexi::DesignViewMode, i18n("To Grid"), koIconName("aopos2grid"),
KShortcut(), "formpart_align_to_grid"));
action = createSharedAction(Kexi::DesignViewMode, i18n("Adjust Widgets Size"), koIconName("aogrid"),
KShortcut(), "formpart_adjust_size_menu", "KActionMenu");
menu = static_cast<KActionMenu*>(action);
menu->addAction(createSharedAction(Kexi::DesignViewMode, i18n("To Fit"), koIconName("aofit"),
KShortcut(), "formpart_adjust_to_fit"));
menu->addAction(createSharedAction(Kexi::DesignViewMode, i18n("To Grid"), koIconName("aogrid"),
KShortcut(), "formpart_adjust_size_grid"));
menu->addAction(createSharedAction(Kexi::DesignViewMode, i18n("To Shortest"), koIconName("aoshortest"),
KShortcut(), "formpart_adjust_height_small"));
menu->addAction(createSharedAction(Kexi::DesignViewMode, i18n("To Tallest"), koIconName("aotallest"),
KShortcut(), "formpart_adjust_height_big"));
menu->addAction(createSharedAction(Kexi::DesignViewMode, i18n("To Narrowest"), koIconName("aonarrowest"),
KShortcut(), "formpart_adjust_width_small"));
menu->addAction(createSharedAction(Kexi::DesignViewMode, i18n("To Widest"), koIconName("aowidest"),
KShortcut(), "formpart_adjust_width_big"));
}
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 KMJobViewer::initActions()
{
// job actions
KAction *hact = new KAction(i18n("&Hold"),"stop",0,this,SLOT(slotHold()),actionCollection(),"job_hold");
KAction *ract = new KAction(i18n("&Resume"),"run",0,this,SLOT(slotResume()),actionCollection(),"job_resume");
KAction *dact = new KAction(i18n("Remo&ve"),"edittrash",Qt::Key_Delete,this,SLOT(slotRemove()),actionCollection(),"job_remove");
KAction *sact = new KAction(i18n("Res&tart"),"redo",0,this,SLOT(slotRestart()),actionCollection(),"job_restart");
KActionMenu *mact = new KActionMenu(i18n("&Move to Printer"),"fileprint",actionCollection(),"job_move");
mact->setDelayed(false);
connect(mact->popupMenu(),SIGNAL(activated(int)),SLOT(slotMove(int)));
connect(mact->popupMenu(),SIGNAL(aboutToShow()),KMTimer::self(),SLOT(hold()));
connect(mact->popupMenu(),SIGNAL(aboutToHide()),KMTimer::self(),SLOT(release()));
connect(mact->popupMenu(),SIGNAL(aboutToShow()),SLOT(slotShowMoveMenu()));
KToggleAction *tact = new KToggleAction(i18n("&Toggle Completed Jobs"),"history",0,actionCollection(),"view_completed");
tact->setEnabled(m_manager->actions() & KMJob::ShowCompleted);
connect(tact,SIGNAL(toggled(bool)),SLOT(slotShowCompleted(bool)));
KToggleAction *uact = new KToggleAction(i18n("Show Only User Jobs"), "personal", 0, actionCollection(), "view_user_jobs");
uact->setCheckedState(KGuiItem(i18n("Hide Only User Jobs"),"personal"));
connect(uact, SIGNAL(toggled(bool)), SLOT(slotUserOnly(bool)));
m_userfield = new QLineEdit(0);
m_userfield->setText(getenv("USER"));
connect(m_userfield, SIGNAL(returnPressed()), SLOT(slotUserChanged()));
connect(uact, SIGNAL(toggled(bool)), m_userfield, SLOT(setEnabled(bool)));
m_userfield->setEnabled(false);
m_userfield->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
KWidgetAction *ufact = new KWidgetAction(m_userfield, i18n("User Name"), 0, 0, 0, actionCollection(), "view_username");
if (!m_pop)
{
m_pop = new QPopupMenu(this);
connect(m_pop,SIGNAL(aboutToShow()),KMTimer::self(),SLOT(hold()));
connect(m_pop,SIGNAL(aboutToHide()),KMTimer::self(),SLOT(release()));
hact->plug(m_pop);
ract->plug(m_pop);
m_pop->insertSeparator();
dact->plug(m_pop);
mact->plug(m_pop);
m_pop->insertSeparator();
sact->plug(m_pop);
}
// Filter actions
KActionMenu *fact = new KActionMenu(i18n("&Select Printer"), "kdeprint_printer", actionCollection(), "filter_modify");
fact->setDelayed(false);
connect(fact->popupMenu(),SIGNAL(activated(int)),SLOT(slotPrinterSelected(int)));
connect(fact->popupMenu(),SIGNAL(aboutToShow()),KMTimer::self(),SLOT(hold()));
connect(fact->popupMenu(),SIGNAL(aboutToHide()),KMTimer::self(),SLOT(release()));
connect(fact->popupMenu(),SIGNAL(aboutToShow()),SLOT(slotShowPrinterMenu()));
if (!m_standalone)
{
KToolBar *toolbar = toolBar();
hact->plug(toolbar);
ract->plug(toolbar);
toolbar->insertSeparator();
dact->plug(toolbar);
mact->plug(toolbar);
toolbar->insertSeparator();
sact->plug(toolbar);
toolbar->insertSeparator();
tact->plug(toolbar);
uact->plug(toolbar);
ufact->plug(toolbar);
}
else
{ // stand-alone application
KStdAction::quit(kapp,SLOT(quit()),actionCollection());
KStdAction::close(this,SLOT(slotClose()),actionCollection());
KStdAction::preferences(this, SLOT(slotConfigure()), actionCollection());
// refresh action
new KAction(i18n("Refresh"),"reload",0,this,SLOT(slotRefresh()),actionCollection(),"refresh");
// create status bar
KStatusBar *statusbar = statusBar();
m_stickybox = new QCheckBox( i18n( "Keep window permanent" ), statusbar );
statusbar->addWidget( m_stickybox, 1, false );
statusbar->insertItem(" " + i18n("Max.: %1").arg(i18n("Unlimited"))+ " ", 0, 0, true);
statusbar->setItemFixed(0);
updateStatusBar();
createGUI();
}
loadPluginActions();
slotSelectionChanged();
}
/**
* Constructor. Connect all of the object and the job control.
*/
KAudioCreator::KAudioCreator( QWidget* parent, const char* name) :
KMainWindow(parent, name)
{
janusWidget = new KJanusWidget(this, name, KJanusWidget::Tabbed);
setCentralWidget(janusWidget);
QVBox *frame = janusWidget->addVBoxPage(i18n("&CD Tracks"), QString::null, SmallIcon("cdaudio_unmount", 32));
tracks = new TracksImp(frame, "Tracks");
ripper = new Ripper ( frame, "Rip" );
encoder = new Encoder( frame, "Encoder" );
frame = janusWidget->addVBoxPage( i18n("&Jobs"), QString::null, SmallIcon( "run", 32 ) );
jobQue = new JobQueImp( frame, "Que" );
resize(500, 440);
/*KAction *eject = */new KAction( i18n("&Eject CD"), 0, tracks,
SLOT( eject() ), actionCollection(), "eject" );
(void)new KAction( i18n("&Configure KAudioCreator..."), 0, this,
SLOT( showSettings() ), actionCollection(), "configure_kaudiocreator" );
KAction *selectAll = new KAction( i18n( "Select &All Tracks"), 0, tracks,
SLOT( selectAllTracks() ), actionCollection(), "select_all" ) ;
KAction *deselectAll = new KAction( i18n( "Deselect &All Tracks"), 0, tracks,
SLOT( deselectAllTracks() ), actionCollection(), "deselect_all" );
selectAll->setEnabled( false );
deselectAll->setEnabled( false );
KActionMenu *actActionMenu = new KActionMenu( i18n("Rip &Selection"), "rip", actionCollection(), "rip" );
actActionMenu->setDelayed(true); //needed for checking "all accounts"
actActionMenu->setEnabled( false );
connect( actActionMenu, SIGNAL( activated() ), tracks, SLOT( startSession() ) );
ripMenu = actActionMenu->popupMenu();
connect( ripMenu, SIGNAL( activated(int) ), this, SLOT( slotRipSelection(int)) );
connect( ripMenu, SIGNAL( aboutToShow() ), this, SLOT( getRipMenu()) );
KAction *rip = new KAction( i18n( "Rip &Selection" ), 0, tracks,
SLOT( startSession() ), actionCollection(), "rip_selected" );
rip->setEnabled( false );
connect( jobQue, SIGNAL( removeJob(int) ), this, SLOT( updateStatus() ) );
connect( jobQue, SIGNAL( removeJob(int) ), ripper, SLOT( removeJob(int) ) );
connect( jobQue, SIGNAL( removeJob(int) ), encoder, SLOT( removeJob(int)) );
connect( ripper, SIGNAL( updateProgress(int, int) ) , jobQue, SLOT( updateProgress(int,int) ) );
connect( ripper, SIGNAL( addJob(Job*, const QString &) ), jobQue, SLOT( addJob(Job*, const QString &)) );
connect( ripper, SIGNAL( eject(const QString &) ) , tracks, SLOT( ejectDevice(const QString &)) );
connect( ripper, SIGNAL( encodeWav(Job *) ) , encoder, SLOT( encodeWav(Job *)) );
connect( ripper, SIGNAL( jobsChanged() ) , this, SLOT( updateStatus() ) );
connect( encoder, SIGNAL( updateProgress(int, int) ) , jobQue, SLOT( updateProgress(int,int)) );
connect( encoder, SIGNAL( addJob(Job*, const QString&)), jobQue, SLOT( addJob(Job*, const QString &)) );
connect( encoder, SIGNAL( jobsChanged() ) , this, SLOT( updateStatus() ) );
connect( tracks, SIGNAL( hasCD(bool) ) , this, SLOT( hasCD(bool) ) );
connect( tracks, SIGNAL( ripTrack(Job *) ), ripper, SLOT( ripTrack(Job *)) );
connect( tracks, SIGNAL( hasTracks(bool) ), rip, SLOT( setEnabled(bool)) );
connect( tracks, SIGNAL( hasTracks(bool) ), actActionMenu, SLOT( setEnabled(bool)) );
connect( tracks, SIGNAL( hasTracks(bool) ), deselectAll, SLOT( setEnabled(bool)) );
connect( tracks, SIGNAL( hasTracks(bool) ), selectAll, SLOT( setEnabled(bool)) );
(void)new KAction(i18n("Remove &Completed Jobs"), 0, jobQue,
SLOT(clearDoneJobs()), actionCollection(), "clear_done_jobs" );
KAction *edit = new KAction(i18n("&Edit Album..."), 0, tracks,
SLOT(editInformation()), actionCollection(), "edit_cd");
connect(tracks, SIGNAL(hasCD(bool)), edit, SLOT(setEnabled(bool)));
edit->setEnabled( false );
(void)new KAction(i18n("Encode &File..."), 0, this,
SLOT(encodeFile()), actionCollection(), "encode_file");
KAction *cddb = new KAction(i18n("&CDDB Lookup"), 0, tracks,
SLOT(performCDDB()), actionCollection(), "cddb_now");
connect(tracks, SIGNAL(hasCD(bool)), cddb, SLOT(setEnabled(bool)));
cddb->setEnabled( false );
KStdAction::configureNotifications(this, SLOT(configureNotifications()),
actionCollection());
KStdAction::quit( this, SLOT(close()), actionCollection(), "quit" );
// Init statusbar
statusBar()->insertItem(i18n("No Audio CD detected"), 0 );
hasCD(tracks->hasCD());
setupGUI();
}
void KexiFormPart::initInstanceActions()
{
//connect actions provided by widget factories
createSharedAction(Kexi::DesignViewMode, xi18n("Clear Widget Contents"),
koIconName("edit-clear"), QKeySequence(), "formpart_clear_contents");
createSharedAction(Kexi::DesignViewMode, xi18n("Edit Tab Order..."),
koIconName("tab_order"), QKeySequence(), "formpart_taborder");
//! @todo createSharedAction(Kexi::DesignViewMode, xi18n("Edit Pixmap Collection"), koIconName("icons"), 0, "formpart_pixmap_collection");
//! @todo createSharedAction(Kexi::DesignViewMode, xi18n("Edit Form Connections"), koIconName("connections"), 0, "formpart_connections");
createSharedAction(Kexi::DesignViewMode, xi18n("Bring Widget to Front"), koIconName("raise"),
QKeySequence(), "formpart_format_raise");
createSharedAction(Kexi::DesignViewMode, xi18n("Send Widget to Back"), koIconName("lower"),
QKeySequence(), "formpart_format_lower");
#ifdef KEXI_SHOW_UNFINISHED
action = createSharedAction(Kexi::DesignViewMode, futureI18n("Other Widgets"), QString(),
QKeySequence(), "other_widgets_menu", "KActionMenu");
#endif
QAction *action = createSharedAction(Kexi::DesignViewMode, xi18n("Align Widgets Position"),
koIconName("aoleft"), QKeySequence(), "formpart_align_menu", "KActionMenu");
KActionMenu *menu = static_cast<KActionMenu*>(action);
menu->addAction(createSharedAction(Kexi::DesignViewMode, xi18n("To Left"), koIconName("aoleft"),
QKeySequence(), "formpart_align_to_left"));
menu->addAction(createSharedAction(Kexi::DesignViewMode, xi18n("To Right"), koIconName("aoright"),
QKeySequence(), "formpart_align_to_right"));
menu->addAction(createSharedAction(Kexi::DesignViewMode, xi18n("To Top"), koIconName("aotop"),
QKeySequence(), "formpart_align_to_top"));
menu->addAction(createSharedAction(Kexi::DesignViewMode, xi18n("To Bottom"), koIconName("aobottom"),
QKeySequence(), "formpart_align_to_bottom"));
menu->addAction(createSharedAction(Kexi::DesignViewMode, xi18n("To Grid"), koIconName("aopos2grid"),
QKeySequence(), "formpart_align_to_grid"));
action = createSharedAction(Kexi::DesignViewMode, xi18n("Adjust Widgets Size"), koIconName("aogrid"),
QKeySequence(), "formpart_adjust_size_menu", "KActionMenu");
menu = static_cast<KActionMenu*>(action);
menu->addAction(createSharedAction(Kexi::DesignViewMode, xi18n("To Fit"), koIconName("aofit"),
QKeySequence(), "formpart_adjust_to_fit"));
menu->addAction(createSharedAction(Kexi::DesignViewMode, xi18n("To Grid"), koIconName("aogrid"),
QKeySequence(), "formpart_adjust_size_grid"));
menu->addAction(createSharedAction(Kexi::DesignViewMode, xi18n("To Shortest"), koIconName("aoshortest"),
QKeySequence(), "formpart_adjust_height_small"));
menu->addAction(createSharedAction(Kexi::DesignViewMode, xi18n("To Tallest"), koIconName("aotallest"),
QKeySequence(), "formpart_adjust_height_big"));
menu->addAction(createSharedAction(Kexi::DesignViewMode, xi18n("To Narrowest"), koIconName("aonarrowest"),
QKeySequence(), "formpart_adjust_width_small"));
menu->addAction(createSharedAction(Kexi::DesignViewMode, xi18n("To Widest"), koIconName("aowidest"),
QKeySequence(), "formpart_adjust_width_big"));
}
KateFileSelector::KateFileSelector( KateMainWindow *mainWindow,
KateViewManager *viewManager,
QWidget * parent, const char * name )
: QVBox (parent, name),
mainwin(mainWindow),
viewmanager(viewManager)
{
mActionCollection = new KActionCollection( this );
QtMsgHandler oldHandler = qInstallMsgHandler( silenceQToolBar );
KateFileSelectorToolBarParent *tbp=new KateFileSelectorToolBarParent(this);
toolbar = new KateFileSelectorToolBar(tbp);
tbp->setToolBar(toolbar);
toolbar->setMovingEnabled(false);
toolbar->setFlat(true);
qInstallMsgHandler( oldHandler );
cmbPath = new KURLComboBox( KURLComboBox::Directories, true, this, "path combo" );
cmbPath->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed ));
KURLCompletion* cmpl = new KURLCompletion(KURLCompletion::DirCompletion);
cmbPath->setCompletionObject( cmpl );
cmbPath->setAutoDeleteCompletionObject( true );
cmbPath->listBox()->installEventFilter( this );
dir = new KDirOperator(KURL(), this, "operator");
dir->setView(KFile::/* Simple */Detail);
dir->view()->setSelectionMode(KFile::Extended);
connect ( dir, SIGNAL( viewChanged(KFileView *) ),
this, SLOT( selectorViewChanged(KFileView *) ) );
setStretchFactor(dir, 2);
KActionCollection *coll = dir->actionCollection();
// some shortcuts of diroperator that clashes with Kate
coll->action( "delete" )->setShortcut( KShortcut( ALT + Key_Delete ) );
coll->action( "reload" )->setShortcut( KShortcut( ALT + Key_F5 ) );
coll->action( "back" )->setShortcut( KShortcut( ALT + SHIFT + Key_Left ) );
coll->action( "forward" )->setShortcut( KShortcut( ALT + SHIFT + Key_Right ) );
// some consistency - reset up for dir too
coll->action( "up" )->setShortcut( KShortcut( ALT + SHIFT + Key_Up ) );
coll->action( "home" )->setShortcut( KShortcut( CTRL + ALT + Key_Home ) );
// bookmarks action!
KActionMenu *acmBookmarks = new KActionMenu( i18n("Bookmarks"), "bookmark",
mActionCollection, "bookmarks" );
acmBookmarks->setDelayed( false );
bookmarkHandler = new KBookmarkHandler( this, acmBookmarks->popupMenu() );
QHBox* filterBox = new QHBox(this);
btnFilter = new QToolButton( filterBox );
btnFilter->setIconSet( SmallIconSet("filter" ) );
btnFilter->setToggleButton( true );
filter = new KHistoryCombo( true, filterBox, "filter");
filter->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed ));
filterBox->setStretchFactor(filter, 2);
connect( btnFilter, SIGNAL( clicked() ), this, SLOT( btnFilterClick() ) );
connect( filter, SIGNAL( activated(const QString&) ),
SLOT( slotFilterChange(const QString&) ) );
connect( filter, SIGNAL( returnPressed(const QString&) ),
filter, SLOT( addToHistory(const QString&) ) );
// kaction for the dir sync method
acSyncDir = new KAction( i18n("Current Document Folder"), "curfiledir", 0,
this, SLOT( setActiveDocumentDir() ), mActionCollection, "sync_dir" );
toolbar->setIconText( KToolBar::IconOnly );
toolbar->setIconSize( 16 );
toolbar->setEnableContextMenu( false );
connect( cmbPath, SIGNAL( urlActivated( const KURL& )),
this, SLOT( cmbPathActivated( const KURL& ) ));
connect( cmbPath, SIGNAL( returnPressed( const QString& )),
this, SLOT( cmbPathReturnPressed( const QString& ) ));
connect(dir, SIGNAL(urlEntered(const KURL&)),
this, SLOT(dirUrlEntered(const KURL&)) );
connect(dir, SIGNAL(finishedLoading()),
this, SLOT(dirFinishedLoading()) );
// enable dir sync button if current doc has a valid URL
connect ( viewmanager, SIGNAL( viewChanged() ),
this, SLOT( kateViewChanged() ) );
// Connect the bookmark handler
connect( bookmarkHandler, SIGNAL( openURL( const QString& )),
this, SLOT( setDir( const QString& ) ) );
waitingUrl = QString::null;
// whatsthis help
QWhatsThis::add( cmbPath,
i18n("<p>Here you can enter a path for a folder to display."
"<p>To go to a folder previously entered, press the arrow on "
"the right and choose one. <p>The entry has folder "
"completion. Right-click to choose how completion should behave.") );
QWhatsThis::add( filter,
i18n("<p>Here you can enter a name filter to limit which files are displayed."
"<p>To clear the filter, toggle off the filter button to the left."
"<p>To reapply the last filter used, toggle on the filter button." ) );
QWhatsThis::add( btnFilter,
i18n("<p>This button clears the name filter when toggled off, or "
"reapplies the last filter used when toggled on.") );
}
void WebView::editableContentActionPopupMenu(KParts::BrowserExtension::ActionGroupMap& partGroupMap)
{
QList<QAction*> editableContentActions;
KActionMenu* menu = new KActionMenu(i18nc("Text direction", "Direction"), this);
QActionGroup* group = new QActionGroup(this);
group->setExclusive(true);
QAction *action = m_actionCollection->addAction(QL1S("text-direction-default"), m_part->browserExtension(), SLOT(slotTextDirectionChanged()));
action->setText(i18n("Default"));
action->setCheckable(true);
action->setData(QWebPage::SetTextDirectionDefault);
action->setEnabled(pageAction(QWebPage::SetTextDirectionDefault)->isEnabled());
action->setCheckable(pageAction(QWebPage::SetTextDirectionDefault)->isChecked());
action->setActionGroup(group);
menu->addAction(action);
action = m_actionCollection->addAction(QL1S("text-direction-left-to-right"), m_part->browserExtension(), SLOT(slotTextDirectionChanged()));
action->setText(i18n("Left to right"));
action->setCheckable(true);
action->setData(QWebPage::SetTextDirectionLeftToRight);
action->setEnabled(pageAction(QWebPage::SetTextDirectionLeftToRight)->isEnabled());
action->setChecked(pageAction(QWebPage::SetTextDirectionLeftToRight)->isChecked());
action->setActionGroup(group);
menu->addAction(action);
action = m_actionCollection->addAction(QL1S("text-direction-right-to-left"), m_part->browserExtension(), SLOT(slotTextDirectionChanged()));
action->setText(i18n("Right to left"));
action->setCheckable(true);
action->setData(QWebPage::SetTextDirectionRightToLeft);
action->setEnabled(pageAction(QWebPage::SetTextDirectionRightToLeft)->isEnabled());
action->setChecked(pageAction(QWebPage::SetTextDirectionRightToLeft)->isChecked());
action->setActionGroup(group);
menu->addAction(action);
editableContentActions.append(menu);
action = new QAction(m_actionCollection);
action->setSeparator(true);
editableContentActions.append(action);
action = m_actionCollection->addAction(KStandardAction::Copy, QL1S("copy"), m_part->browserExtension(), SLOT(copy()));
action->setEnabled(pageAction(QWebPage::Copy)->isEnabled());
editableContentActions.append(action);
action = m_actionCollection->addAction(KStandardAction::Cut, QL1S("cut"), m_part->browserExtension(), SLOT(cut()));
action->setEnabled(pageAction(QWebPage::Cut)->isEnabled());
editableContentActions.append(action);
action = m_actionCollection->addAction(KStandardAction::Paste, QL1S("paste"), m_part->browserExtension(), SLOT(paste()));
action->setEnabled(pageAction(QWebPage::Paste)->isEnabled());
editableContentActions.append(action);
action = new QAction(m_actionCollection);
action->setSeparator(true);
editableContentActions.append(action);
const bool hasContent = (!m_result.element().evaluateJavaScript(QL1S("this.value")).toString().isEmpty());
action = m_actionCollection->addAction(KStandardAction::SelectAll, QL1S("selectall"), m_part->browserExtension(), SLOT(slotSelectAll()));
action->setEnabled((pageAction(QWebPage::SelectAll)->isEnabled() && hasContent));
editableContentActions.append(action);
if (showSpellCheckAction(m_result.element())) {
action = new QAction(m_actionCollection);
action->setSeparator(true);
editableContentActions.append(action);
action = m_actionCollection->addAction(KStandardAction::Spelling, QL1S("spelling"), m_part->browserExtension(), SLOT(slotCheckSpelling()));
action->setText(i18n("Check Spelling..."));
action->setEnabled(hasContent);
editableContentActions.append(action);
const bool hasSelection = (hasContent && m_result.isContentSelected());
action = m_actionCollection->addAction(KStandardAction::Spelling, QL1S("spellcheckSelection"), m_part->browserExtension(), SLOT(slotSpellCheckSelection()));
action->setText(i18n("Spellcheck selection..."));
action->setEnabled(hasSelection);
editableContentActions.append(action);
}
if (settings()->testAttribute(QWebSettings::DeveloperExtrasEnabled)) {
if (!m_webInspector) {
m_webInspector = new QWebInspector;
m_webInspector->setPage(page());
connect(page(), SIGNAL(destroyed()), m_webInspector, SLOT(deleteLater()));
}
action = new QAction(m_actionCollection);
action->setSeparator(true);
editableContentActions.append(action);
editableContentActions.append(pageAction(QWebPage::InspectElement));
}
partGroupMap.insert("editactions" , editableContentActions);
}
void KNewFileMenuPrivate::fillMenu()
{
QMenu* menu = q->menu();
menu->clear();
m_menuDev->menu()->clear();
m_newDirAction = 0;
QSet<QString> seenTexts;
// these shall be put at special positions
QAction* linkURL = 0;
QAction* linkApp = 0;
QAction* linkPath = 0;
KNewFileMenuSingleton* s = kNewMenuGlobals;
int i = 1;
KNewFileMenuSingleton::EntryList::iterator templ = s->templatesList->begin();
const KNewFileMenuSingleton::EntryList::iterator templ_end = s->templatesList->end();
for (; templ != templ_end; ++templ, ++i)
{
KNewFileMenuSingleton::Entry& entry = *templ;
if (entry.entryType != KNewFileMenuSingleton::Separator) {
// There might be a .desktop for that one already, if it's a kdelnk
// This assumes we read .desktop files before .kdelnk files ...
// In fact, we skip any second item that has the same text as another one.
// Duplicates in a menu look bad in any case.
const bool bSkip = seenTexts.contains(entry.text);
if (bSkip) {
kDebug(1203) << "skipping" << entry.filePath;
} else {
seenTexts.insert(entry.text);
//const KNewFileMenuSingleton::Entry entry = templatesList->at(i-1);
const QString templatePath = entry.templatePath;
// The best way to identify the "Create Directory", "Link to Location", "Link to Application" was the template
if (templatePath.endsWith("emptydir")) {
QAction * act = new QAction(q);
m_newDirAction = act;
act->setIcon(KIcon(entry.icon));
act->setText(entry.text);
act->setActionGroup(m_newMenuGroup);
menu->addAction(act);
QAction *sep = new QAction(q);
sep->setSeparator(true);
menu->addAction(sep);
} else {
if (!m_supportedMimeTypes.isEmpty()) {
bool keep = false;
// We need to do mimetype filtering, for real files.
const bool createSymlink = entry.templatePath == "__CREATE_SYMLINK__";
if (createSymlink) {
keep = true;
} else if (!KDesktopFile::isDesktopFile(entry.templatePath)) {
// Determine mimetype on demand
KMimeType::Ptr mime;
if (entry.mimeType.isEmpty()) {
mime = KMimeType::findByPath(entry.templatePath);
if (mime) {
//kDebug() << entry.templatePath << "is" << mime->name();
entry.mimeType = mime->name();
} else {
entry.mimeType = KMimeType::defaultMimeType();
}
} else {
mime = KMimeType::mimeType(entry.mimeType);
}
Q_FOREACH(const QString& supportedMime, m_supportedMimeTypes) {
if (mime && mime->is(supportedMime)) {
keep = true;
break;
}
}
}
if (!keep) {
//kDebug() << "Not keeping" << entry.templatePath;
continue;
}
}
QAction * act = new QAction(q);
act->setData(i);
act->setIcon(KIcon(entry.icon));
act->setText(entry.text);
act->setActionGroup(m_newMenuGroup);
//kDebug() << templatePath << entry.filePath;
if (templatePath.endsWith("/URL.desktop")) {
linkURL = act;
} else if (templatePath.endsWith("/Program.desktop")) {
linkApp = act;
} else if (entry.filePath.endsWith("/linkPath.desktop")) {
linkPath = act;
} else if (KDesktopFile::isDesktopFile(templatePath)) {
KDesktopFile df(templatePath);
if (df.readType() == "FSDevice")
m_menuDev->menu()->addAction(act);
else
menu->addAction(act);
}
else
{
menu->addAction(act);
}
}
}
} else { // Separate system from personal templates
void MainWindow::setupActions()
{
// File menu actions
KStandardAction::quit(qApp, SLOT(quit()), actionCollection());
m_recent = KStandardAction::openRecent(this, SLOT(openScript(QUrl)), 0);
actionCollection()->addAction("openrecentscript", m_recent);
QAction *newQueryTab= new QAction(QIcon::fromTheme("tab-new"), tr("New Query"), this);
actionCollection()->addAction("newquerytab", newQueryTab);
connect(newQueryTab, &QAction::triggered, this, &MainWindow::newQueryTab);
QAction *newScriptTab = new QAction(QIcon::fromTheme("document-new"), tr("New Script"), this);
actionCollection()->addAction("newscripttab", newScriptTab);
connect(newScriptTab, &QAction::triggered, this, &MainWindow::newBlankScriptTab);
QAction *openScript = new QAction(QIcon::fromTheme("document-open"), tr("Open Script..."), this);
actionCollection()->addAction("openscript", openScript);
connect(openScript, &QAction::triggered, this, &MainWindow::openScriptDialog);
QAction *saveScript = new QAction(QIcon::fromTheme("document-save"), tr("Save Script"), this);
actionCollection()->addAction("savescript", saveScript);
connect(saveScript, &QAction::triggered, this, &MainWindow::saveScript);
saveScript->setEnabled(false);
QAction *saveScriptAs = new QAction(QIcon::fromTheme("document-save-as"), tr("Save Script As..."), this);
actionCollection()->addAction("savescriptas", saveScriptAs);
connect(saveScriptAs, &QAction::triggered, this, &MainWindow::saveScriptAs);
saveScriptAs->setEnabled(false);
// Export submenu
KActionMenu *exportmenu = new KActionMenu(QIcon::fromTheme("document-export-table"), tr("Export results"), this);
actionCollection()->addAction("resultexportmenu", exportmenu);
QActionGroup *exportgroup = Exporters::instance().multiTableActions(this);
for(QAction *a : exportgroup->actions())
exportmenu->addAction(a);
connect(exportgroup, SIGNAL(triggered(QAction*)),
this, SLOT(exportResults(QAction*)));
// Edit menu actions
KStandardAction::find(this, SLOT(search()), actionCollection());
KStandardAction::findNext(this, SLOT(findNext()), actionCollection());
KStandardAction::findPrev(this, SLOT(findPrev()), actionCollection());
QAction *clearResultView = new QAction(tr("Clear results"), this);
actionCollection()->addAction("resultsclear", clearResultView);
connect(clearResultView, &QAction::triggered, this, &MainWindow::clearResults);
// Settings menu actions
QAction *showTableDock = new QAction(tr("Show Tables"), this);
showTableDock->setCheckable(true);
actionCollection()->addAction("showtables", showTableDock);
QAction *showDatabaseDock = new QAction(tr("Show Databases"), this);
showDatabaseDock->setCheckable(true);
actionCollection()->addAction("showdatabases", showDatabaseDock);
// Other actions
QAction *newConnection = new QAction(tr("New Connection"), this);
actionCollection()->addAction("newconnection", newConnection);
connect(newConnection, &QAction::triggered, this, &MainWindow::newConnection);
}
