VCWidgetSelection::VCWidgetSelection(QList<int> filters, QWidget *parent)
    : QDialog(parent)
    , m_filters(filters)
{
    setupUi(this);

    m_tree->setRootIsDecorated(false);
    m_tree->setSelectionMode(QAbstractItemView::SingleSelection);
    m_tree->setAllColumnsShowFocus(true);

    connect(m_tree, SIGNAL(itemSelectionChanged()),
            this, SLOT(slotItemSelectionChanged()));
    connect(m_tree, SIGNAL(itemDoubleClicked(QTreeWidgetItem*,int)),
            this, SLOT(slotItemDoubleClicked(QTreeWidgetItem*)));

    updateWidgetsTree();

    slotItemSelectionChanged();
}
Beispiel #2
0
Datei: qt4.cpp Projekt: m8a/uim
void UimPrefDialog::createMainWidgets()
{
    QVBoxLayout *mainVLayout = new QVBoxLayout( this );
    mainVLayout->setMargin( 6 );

    QSplitter *mainSplitter = new QSplitter( this );

    /* ListView */
    m_groupListView = new QTreeWidget( mainSplitter );
    m_groupListView->setRootIsDecorated( false );
    m_groupListView->setHeaderLabel( _("Group") );
    m_groupListView->setSelectionMode( QAbstractItemView::SingleSelection );
    connect( m_groupListView, SIGNAL(itemSelectionChanged()),
                      this, SLOT(slotItemSelectionChanged()) );

    /* Contents Frame */
    m_rightSideWidget = new QScrollArea( mainSplitter );
    m_rightSideWidget->setWidgetResizable( true );
    m_groupWidgetStack = new QStackedWidget;

    /* Buttons */
    QWidget *buttonHWidget = new QWidget( this );
    buttonHWidget->setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed);
    QHBoxLayout *buttonHLayout = new QHBoxLayout( buttonHWidget );
    buttonHLayout->setMargin( 6 );
    buttonHLayout->setSpacing( 6 );
    QPushButton *defaultButton = new QPushButton( _("Defaults"), buttonHWidget );
    connect( defaultButton, SIGNAL(clicked()),
                      this, SLOT(slotSetDefault()) );
    QPushButton *okButton = new QPushButton( _("OK"), buttonHWidget );
    connect( okButton, SIGNAL(clicked()),
                      this, SLOT(slotOK()) );
    m_applyButton = new QPushButton( _("Apply"), buttonHWidget );
    m_applyButton->setEnabled( false );
    connect( m_applyButton, SIGNAL(clicked()),
                      this, SLOT(slotApply()) );
    QPushButton *cancelButton = new QPushButton( _("Cancel"), buttonHWidget );
    connect( cancelButton, SIGNAL(clicked()),
                      this, SLOT(slotCancel()) );
    buttonHLayout->addWidget( defaultButton );
    buttonHLayout->addStretch();
    buttonHLayout->addWidget( okButton );
    buttonHLayout->addWidget( m_applyButton );
    buttonHLayout->addWidget( cancelButton );

    QFrame *separator = new QFrame( this );
    separator->setFrameShape( QFrame::HLine );
    separator->setFrameShadow( QFrame::Sunken );
    mainVLayout->setMargin( 0 );
    mainVLayout->addWidget( mainSplitter );
    mainVLayout->addWidget( separator );
    mainVLayout->addWidget( buttonHWidget );

    mainSplitter->setStretchFactor( 1, 1 );
}
ChannelModifierEditor::ChannelModifierEditor(Doc *doc, QString modifier, QWidget *parent)
    : QDialog(parent)
    , m_doc(doc)
{
    Q_ASSERT(doc != NULL);

    setupUi(this);

    m_view = new ChannelModifierGraphicsView(this);
    m_view->setRenderHint(QPainter::Antialiasing);
    m_view->setAcceptDrops(true);
    m_view->setAlignment(Qt::AlignLeft | Qt::AlignTop);
    m_view->setBackgroundBrush(QBrush(QColor(11, 11, 11, 255), Qt::SolidPattern));

    m_mainGrid->addWidget(m_view, 2, 0);

    m_origDMXSpin->setEnabled(false);
    m_modifiedDMXSpin->setEnabled(false);
    m_deleteHandlerButton->setEnabled(false);

    connect(m_view, SIGNAL(itemClicked(uchar,uchar)),
            this, SLOT(slotHandlerClicked(uchar,uchar)));
    connect(m_view, SIGNAL(itemDMXMapChanged(uchar,uchar)),
            this, SLOT(slotItemDMXChanged(uchar,uchar)));
    connect(m_view, SIGNAL(viewClicked(QMouseEvent*)),
            this, SLOT(slotViewClicked()));

    connect(m_templatesTree, SIGNAL(itemSelectionChanged()),
            this, SLOT(slotItemSelectionChanged()));

    connect(m_origDMXSpin, SIGNAL(valueChanged(int)),
            this, SLOT(slotOriginalDMXValueChanged(int)));
    connect(m_modifiedDMXSpin, SIGNAL(valueChanged(int)),
            this, SLOT(slotModifiedDMXValueChanged(int)));

    connect(m_addHandlerButton, SIGNAL(clicked()),
            this, SLOT(slotAddHandlerClicked()));
    connect(m_deleteHandlerButton, SIGNAL(clicked()),
            this, SLOT(slotRemoveHandlerClicked()));
    connect(m_saveButton, SIGNAL(clicked()),
            this, SLOT(slotSaveClicked()));

    connect(m_unsetButton, SIGNAL(clicked()),
            this, SLOT(slotUnsetClicked()));

    updateModifiersList(modifier);
}
Beispiel #4
0
IgnoreListEditor::IgnoreListEditor(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::IgnoreListEditor)
{
    ui->setupUi(this);

    ui->descriptionLabel->setText(tr("Files or directories matching a pattern will not be synchronized.\n\n"
                                     "Checked items will also be deleted if they prevent a directory from "
                                     "being removed. This is useful for meta data."));

    MirallConfigFile cfgFile;
    readIgnoreFile(cfgFile.excludeFile(MirallConfigFile::SystemScope), true);
    readIgnoreFile(cfgFile.excludeFile(MirallConfigFile::UserScope), false);

    connect(this, SIGNAL(accepted()), SLOT(slotUpdateLocalIgnoreList()));
    ui->removePushButton->setEnabled(false);
    connect(ui->listWidget, SIGNAL(itemSelectionChanged()), SLOT(slotItemSelectionChanged()));
    connect(ui->listWidget, SIGNAL(itemActivated(QListWidgetItem*)), SLOT(slotItemChanged(QListWidgetItem*)));
    connect(ui->removePushButton, SIGNAL(clicked()), SLOT(slotRemoveCurrentItem()));
    connect(ui->addPushButton, SIGNAL(clicked()), SLOT(slotAddPattern()));
    connect(ui->listWidget, SIGNAL(itemDoubleClicked(QListWidgetItem*)), SLOT(slotEditPattern(QListWidgetItem*)));
}
int FunctionSelection::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDialog::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: slotNewScene(); break;
        case 1: slotNewChaser(); break;
        case 2: slotNewEFX(); break;
        case 3: slotNewCollection(); break;
        case 4: slotItemSelectionChanged(); break;
        case 5: slotItemDoubleClicked((*reinterpret_cast< QTreeWidgetItem*(*)>(_a[1]))); break;
        case 6: slotCollectionChecked((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 7: slotEFXChecked((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 8: slotChaserChecked((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 9: slotSceneChecked((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 10: accept(); break;
        default: ;
        }
        _id -= 11;
    }
    return _id;
}
AirfieldSelectionList::AirfieldSelectionList( QWidget *parent ) :
 QWidget(parent)
{
  setObjectName( "AirfieldSelectionList" );
  setWindowTitle(tr("Airfield Selection"));
  setWindowFlags( Qt::Tool );
  setWindowModality( Qt::WindowModal );
  setAttribute(Qt::WA_DeleteOnClose);

  if( parent )
    {
      resize( parent->size() );
    }

  QHBoxLayout* mainLayout = new QHBoxLayout( this );

  m_airfieldTreeWidget = new QTreeWidget( this );

  mainLayout->addWidget( m_airfieldTreeWidget );

  m_airfieldTreeWidget->setRootIsDecorated( false );
  m_airfieldTreeWidget->setItemsExpandable( false );
  m_airfieldTreeWidget->setSortingEnabled( true );
  m_airfieldTreeWidget->setSelectionMode( QAbstractItemView::SingleSelection );
  m_airfieldTreeWidget->setSelectionBehavior( QAbstractItemView::SelectRows );
  m_airfieldTreeWidget->setAlternatingRowColors(true);
  m_airfieldTreeWidget->setColumnCount( 1 );
  m_airfieldTreeWidget->setFocusPolicy( Qt::StrongFocus );
  m_airfieldTreeWidget->setUniformRowHeights(true);
  m_airfieldTreeWidget->setHeaderLabel( tr( "Airfields" ) );

  connect( m_airfieldTreeWidget, SIGNAL(itemSelectionChanged()),
           SLOT(slotItemSelectionChanged()) );

  // Set additional space per row
  RowDelegate* rowDelegate = new RowDelegate( m_airfieldTreeWidget, 10 );
  m_airfieldTreeWidget->setItemDelegate( rowDelegate );

  QTreeWidgetItem* headerItem = m_airfieldTreeWidget->headerItem();
  headerItem->setTextAlignment( 0, Qt::AlignCenter );

  m_airfieldTreeWidget->setVerticalScrollMode( QAbstractItemView::ScrollPerPixel );
  m_airfieldTreeWidget->setHorizontalScrollMode( QAbstractItemView::ScrollPerPixel );

#ifdef ANDROID
  QScrollBar* lvsb = m_airfieldTreeWidget->verticalScrollBar();
  lvsb->setStyleSheet( Layout::getCbSbStyle() );
#endif

#ifdef QSCROLLER
  QScroller::grabGesture(m_airfieldTreeWidget->viewport(), QScroller::LeftMouseButtonGesture);
#endif

#ifdef QTSCROLLER
  QtScroller::grabGesture(m_airfieldTreeWidget->viewport(), QtScroller::LeftMouseButtonGesture);
#endif

  QVBoxLayout* groupLayout = new QVBoxLayout;

  m_groupBox = new QGroupBox( tr("Search Airfield"));
  m_groupBox->setLayout( groupLayout );
  mainLayout->addWidget( m_groupBox );

  m_searchInput = new QLineEdit;
  groupLayout->addWidget( m_searchInput );

  Qt::InputMethodHints imh = (m_searchInput->inputMethodHints() | Qt::ImhNoPredictiveText);
  m_searchInput->setInputMethodHints(imh);

#ifndef ANDROID
  m_searchInput->setToolTip( tr("Enter a search string, to navigate to a certain list entry.") );
#endif

  connect( m_searchInput, SIGNAL(returnPressed()),
           MainWindow::mainWindow(), SLOT(slotCloseSip()) );

  connect( m_searchInput, SIGNAL(textEdited(const QString&)),
           SLOT(slotTextEdited(const QString&)) );

  QHBoxLayout* clearLayout = new QHBoxLayout;
  clearLayout->setSpacing(0);
  clearLayout->addStretch(5);
  QPushButton* clearButton = new QPushButton(tr("Clear"));

#ifndef ANDROID
  clearButton->setToolTip( tr("Click Clear to remove the search string.") );
#endif

  clearLayout->addWidget( clearButton );
  groupLayout->addLayout( clearLayout );
  groupLayout->addStretch(5);

  connect( clearButton, SIGNAL(clicked()), SLOT(slotClearSearchEntry()));

  QPushButton *cancel = new QPushButton(this);
  cancel->setIcon(QIcon(GeneralConfig::instance()->loadPixmap("cancel.png")));
  cancel->setIconSize(QSize(Layout::getButtonSize(12), Layout::getButtonSize(12)));
  cancel->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::QSizePolicy::Preferred);

  connect( cancel, SIGNAL(clicked()), SLOT(slotReject()) );

  m_ok = new QPushButton(this);
  m_ok->setIcon(QIcon(GeneralConfig::instance()->loadPixmap("ok.png")));
  m_ok->setIconSize(QSize(Layout::getButtonSize(12), Layout::getButtonSize(12)));
  m_ok->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::QSizePolicy::Preferred);
  m_ok->setEnabled( false );

  connect( m_ok, SIGNAL(clicked()), SLOT(slotAccept()) );

  QVBoxLayout *buttonBox = new QVBoxLayout;
  buttonBox->setSpacing(0);
  buttonBox->addStretch(2);
  buttonBox->addWidget(cancel, 1);
  buttonBox->addSpacing(30);
  buttonBox->addWidget(m_ok, 1);
  buttonBox->addStretch(2);
  mainLayout->addLayout(buttonBox);
}
Beispiel #7
0
void QueueMgrWindow::setupConnections()
{
    // -- Assigned tools list connections -----------------------------------

    connect(d->assignedList, SIGNAL(signalToolSelected(BatchToolSet)),
            d->toolSettings, SLOT(slotToolSelected(BatchToolSet)));

    connect(d->assignedList, SIGNAL(signalAssignedToolsChanged(AssignedBatchTools)),
            d->queuePool, SLOT(slotAssignedToolsChanged(AssignedBatchTools)));

    connect(d->toolSettings, SIGNAL(signalSettingsChanged(BatchToolSet)),
            d->assignedList, SLOT(slotSettingsChanged(BatchToolSet)));

    connect(d->assignedList, SIGNAL(signalAssignedToolsChanged(AssignedBatchTools)),
            this, SLOT(slotAssignedToolsChanged(AssignedBatchTools)));

    connect(d->toolsView, SIGNAL(signalAssignTools(QMap<int,QString>)),
            d->assignedList, SLOT(slotAssignTools(QMap<int,QString>)));

    // -- Queued Items list connections -------------------------------------

    connect(d->queuePool, SIGNAL(signalQueueSelected(int,QueueSettings,AssignedBatchTools)),
            d->queueSettingsView, SLOT(slotQueueSelected(int,QueueSettings,AssignedBatchTools)));

    connect(d->queuePool, SIGNAL(signalQueueSelected(int,QueueSettings,AssignedBatchTools)),
            d->assignedList, SLOT(slotQueueSelected(int,QueueSettings,AssignedBatchTools)));

    connect(d->queueSettingsView, SIGNAL(signalSettingsChanged(QueueSettings)),
            d->queuePool, SLOT(slotSettingsChanged(QueueSettings)));

    connect(d->queueSettingsView, SIGNAL(signalSettingsChanged(QueueSettings)),
            this, SLOT(slotQueueContentsChanged()));

    connect(d->queuePool, SIGNAL(signalQueueSelected(int,QueueSettings,AssignedBatchTools)),
            this, SLOT(slotQueueContentsChanged()));

    connect(d->queuePool, SIGNAL(signalQueuePoolChanged()),
            this, SLOT(slotQueueContentsChanged()));

    connect(d->queuePool, SIGNAL(signalQueueContentsChanged()),
            this, SLOT(slotQueueContentsChanged()));

    connect(d->queuePool, SIGNAL(signalItemSelectionChanged()),
            this, SLOT(slotItemSelectionChanged()));

    // -- Multithreaded interface connections -------------------------------

    connect(d->thread, SIGNAL(signalStarting(Digikam::ActionData)),
            this, SLOT(slotAction(Digikam::ActionData)));

    connect(d->thread, SIGNAL(signalFinished(Digikam::ActionData)),
            this, SLOT(slotAction(Digikam::ActionData)));

    connect(d->thread, SIGNAL(signalQueueProcessed()),
            this, SLOT(slotQueueProcessed()));

    // -- GUI connections ---------------------------------------------------

    connect(d->toolsView, SIGNAL(signalHistoryEntryClicked(int,qlonglong)),
            this, SLOT(slotHistoryEntryClicked(int,qlonglong)));

    connect(d->toolsView, SIGNAL(signalAssignQueueSettings(QString)),
            this, SLOT(slotAssignQueueSettings(QString)));
}
Smb4KConfigPageAuthentication::Smb4KConfigPageAuthentication(QWidget *parent) : QTabWidget(parent)
{
  m_entries_displayed = false;
  m_loading_details = false;
  m_default_login = false;
  m_undo_removal = false;
  m_maybe_changed = false;
  m_auth_info = 0;
  
  //
  // General tab
  // 
  QWidget *general_tab          = new QWidget(this);

  QGridLayout *general_layout   = new QGridLayout(general_tab);
  general_layout->setSpacing(5);
  general_layout->setMargin(0);
  
  QGroupBox *password_box  = new QGroupBox(i18n("Password Storage"), general_tab);

  QGridLayout *pass_layout = new QGridLayout(password_box);
  pass_layout->setSpacing(5);

  QCheckBox *use_wallet    = new QCheckBox(Smb4KSettings::self()->useWalletItem()->label(),
                             password_box);
  use_wallet->setObjectName("kcfg_UseWallet");

  pass_layout->addWidget(use_wallet, 0, 0, 0);

  // Default login box
  QGroupBox *default_box   = new QGroupBox(i18n("Default Login"), general_tab);
  default_box->setObjectName("DefaultLoginBox");

  QGridLayout *def_layout  = new QGridLayout(default_box);
  def_layout->setSpacing(5);

  QCheckBox *default_auth  = new QCheckBox(Smb4KSettings::self()->useDefaultLoginItem()->label(),
                             default_box);
  default_auth->setObjectName("kcfg_UseDefaultLogin");

  def_layout->addWidget(default_auth, 0, 0, 1, 2, 0);

  QSpacerItem *spacer = new QSpacerItem(10, 10, QSizePolicy::Preferred, QSizePolicy::Expanding);

  general_layout->addWidget(password_box, 0, 0, 0);
  general_layout->addWidget(default_box, 1, 0, 0);
  general_layout->addItem(spacer, 2, 0, 1, 1, 0);

  connect(use_wallet,   SIGNAL(toggled(bool)),
           this,         SLOT(slotKWalletButtonToggled(bool)));

  connect(default_auth, SIGNAL(toggled(bool)),
           this,         SLOT(slotDefaultLoginToggled(bool)));

  slotKWalletButtonToggled(use_wallet->isChecked());
  slotDefaultLoginToggled(default_auth->isChecked());
  
  insertTab(GeneralTab, general_tab, i18n("General Settings"));
  
  //
  // Logins tab
  //
  QWidget *logins_tab        = new QWidget(this);
  
  QGridLayout *logins_layout = new QGridLayout(logins_tab);
  logins_layout->setSpacing(5);
  logins_layout->setMargin(0);
  
  // The list view that shows the wallet entriea
  m_entries_widget = new QListWidget(logins_tab);
  m_entries_widget->setDragDropMode(QListWidget::NoDragDrop);
  m_entries_widget->setSelectionMode(QListWidget::SingleSelection);
  m_entries_widget->setContextMenuPolicy(Qt::CustomContextMenu);
  m_entries_widget->viewport()->installEventFilter(this);
  
  // Load button
  KGuiItem load_item = KGuiItem(i18n("Load"), "document-open",
                                i18n("Load the entries stored in the wallet."),
                                i18n("The login information that was stored by Smb4K will be loaded from the wallet. "
                                      "If you chose to not use the wallet, pressing this button will have no effect."));
  m_load_button = new QPushButton(logins_tab);
  KGuiItem::assign(m_load_button, load_item);
  
  // The Save button
  KGuiItem save_item = KGuiItem(i18n("Save"), "document-save-all",
                                 i18n("Save the entries to the wallet."),
                                 i18n("All modifications you applied are saved to the wallet."));
  m_save_button = new QPushButton(logins_tab);
  KGuiItem::assign(m_save_button, save_item);
  
  m_details_box = new QCheckBox(i18n("Show details"), logins_tab);
  m_details_box->setToolTip(i18n("Show the details of the selected entry."));
  m_details_box->setWhatsThis(i18n("Marking this check box will show the details of the selected login information below."));
  m_details_box->setEnabled(false);
  
  m_details_widget = new QTableWidget(logins_tab);
  m_details_widget->setContextMenuPolicy(Qt::CustomContextMenu);
  m_details_widget->horizontalHeader()->setVisible(false);
  m_details_widget->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
  m_details_widget->verticalHeader()->setVisible(false);
  m_details_widget->verticalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
  m_details_widget->viewport()->installEventFilter(this);
  m_details_widget->setEnabled(false);
  
  logins_layout->addWidget(m_entries_widget, 0, 0, 4, 1, 0);
  logins_layout->addWidget(m_load_button, 0, 2, 0);
  logins_layout->addWidget(m_save_button, 1, 2, 0);
  logins_layout->addWidget(m_details_box, 2, 1, 1, 2, 0);
  logins_layout->addWidget(m_details_widget, 3, 1, 1, 2, 0);
  
  m_collection = new KActionCollection(logins_tab);  
  QAction *remove_action = new QAction(KDE::icon("edit-delete"), i18n("Remove"), this);
  QAction *clear_action = new QAction(KDE::icon("edit-clear-list"), i18n("Clear List"), this);
  QAction *edit_action = new QAction(KDE::icon("edit-rename"), i18n("Edit"), this);
  QAction *undo_details_action = new QAction(KDE::icon("edit-undo"), i18n("Undo"), this);
  QAction *undo_list_action = new QAction(KDE::icon("edit-undo"), i18n("Undo"), this);
  
  m_collection->addAction("remove_action", remove_action);
  m_collection->addAction("clear_action", clear_action);
  m_collection->addAction("edit_action", edit_action);
  m_collection->addAction("undo_details_action", undo_details_action);
  m_collection->addAction("undo_list_action", undo_list_action);

  remove_action->setEnabled(false);
  clear_action->setEnabled(false);
  edit_action->setEnabled(false);
  undo_details_action->setEnabled(false);
  undo_list_action->setEnabled(false);
  
  m_collection->addAction("remove_action", remove_action);
  m_collection->addAction("clear_action", clear_action);
  m_collection->addAction("edit_action", edit_action);
  m_collection->addAction("undo_details_action", undo_details_action);
  m_collection->addAction("undo_list_action", undo_list_action);
  
  m_entries_menu = new KActionMenu(m_entries_widget);
  m_entries_menu->addAction(remove_action);
  m_entries_menu->addAction(clear_action);
  m_entries_menu->addAction(undo_list_action);
  
  m_details_menu = new KActionMenu(m_details_widget);
  m_details_menu->addAction(edit_action);
  m_details_menu->addAction(undo_details_action);
  
  connect(m_load_button,    SIGNAL(clicked(bool)),
           this,             SIGNAL(loadWalletEntries()));
  
  connect(m_save_button,    SIGNAL(clicked(bool)),
           this,             SIGNAL(saveWalletEntries()));
           
  connect(m_save_button,    SIGNAL(clicked(bool)),
           this,             SLOT(slotSaveClicked(bool)));
  
  connect(m_details_box,    SIGNAL(clicked(bool)),
           this,             SLOT(slotDetailsClicked(bool)));
           
  connect(m_entries_widget, SIGNAL(itemSelectionChanged()),
           this,             SLOT(slotItemSelectionChanged()));
           
  connect(m_entries_widget, SIGNAL(customContextMenuRequested(QPoint)),
           this,             SLOT(slotShowListWidgetContextMenu(QPoint)));
           
  connect(m_details_widget, SIGNAL(cellChanged(int,int)),
           this,             SLOT(slotDetailsChanged(int,int)));
           
  connect(m_details_widget, SIGNAL(customContextMenuRequested(QPoint)),
           this,             SLOT(slotShowTableWidgetContextMenu(QPoint)));
           
  connect(remove_action,    SIGNAL(triggered(bool)),
           this,             SLOT(slotRemoveActionTriggered(bool)));
           
  connect(clear_action,     SIGNAL(triggered(bool)),
           this,             SLOT(slotClearActionTriggered(bool)));
           
  connect(undo_list_action, SIGNAL(triggered(bool)),
           this,             SLOT(slotUndoListActionTriggered(bool)));
           
  connect(edit_action,      SIGNAL(triggered(bool)),
           this,             SLOT(slotEditActionTriggered(bool)));
           
  connect(undo_details_action, SIGNAL(triggered(bool)),
           this,             SLOT(slotUndoDetailsActionTriggered(bool)));
           
  m_load_button->setFocus();
  
  insertTab(WalletEntriesTab, logins_tab, i18n("Wallet Entries"));
}