net.sf.keystore_explorer.gui.KseFrame.java Source code

Java tutorial

Introduction

Here is the source code for net.sf.keystore_explorer.gui.KseFrame.java

Source

/*
 * Copyright 2004 - 2013 Wayne Grant
 *           2013 - 2016 Kai Kramer           2013 - 2016 Kai Kramer
 *
 * This file is part of KeyStore Explorer.
 *
 * KeyStore Explorer is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * KeyStore Explorer is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with KeyStore Explorer.  If not, see <http://www.gnu.org/licenses/>.
 */
package net.sf.keystore_explorer.gui;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Image;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Toolkit;
import java.awt.dnd.DnDConstants;
import java.awt.dnd.DragSource;
import java.awt.event.ActionEvent;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.File;
import java.security.GeneralSecurityException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.PrivateKey;
import java.security.Provider;
import java.security.cert.Certificate;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.ResourceBundle;

import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.BorderFactory;
import javax.swing.ButtonGroup;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JCheckBoxMenuItem;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPopupMenu;
import javax.swing.JRadioButtonMenuItem;
import javax.swing.JScrollPane;
import javax.swing.JTabbedPane;
import javax.swing.JTable;
import javax.swing.JToolBar;
import javax.swing.KeyStroke;
import javax.swing.ListSelectionModel;
import javax.swing.RowSorter;
import javax.swing.ScrollPaneConstants;
import javax.swing.SwingUtilities;
import javax.swing.WindowConstants;
import javax.swing.border.CompoundBorder;
import javax.swing.border.EmptyBorder;
import javax.swing.border.MatteBorder;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.plaf.TabbedPaneUI;
import javax.swing.table.TableColumn;
import javax.swing.table.TableModel;
import javax.swing.table.TableRowSorter;

import com.jgoodies.looks.HeaderStyle;
import com.jgoodies.looks.Options;

import static net.sf.keystore_explorer.crypto.keystore.KeyStoreType.BKS;
import static net.sf.keystore_explorer.crypto.keystore.KeyStoreType.BKS_V1;
import static net.sf.keystore_explorer.crypto.keystore.KeyStoreType.JCEKS;
import static net.sf.keystore_explorer.crypto.keystore.KeyStoreType.JKS;
import static net.sf.keystore_explorer.crypto.keystore.KeyStoreType.HTKS;
import static net.sf.keystore_explorer.crypto.keystore.KeyStoreType.PKCS12;

import net.sf.keystore_explorer.ApplicationSettings;
import net.sf.keystore_explorer.KSE;
import net.sf.keystore_explorer.crypto.CryptoException;
import net.sf.keystore_explorer.crypto.Password;
import net.sf.keystore_explorer.crypto.keystore.KeyStoreType;
import net.sf.keystore_explorer.crypto.keystore.KeyStoreUtil;
import net.sf.keystore_explorer.gui.actions.AboutAction;
import net.sf.keystore_explorer.gui.actions.AppendToCertificateChainAction;
import net.sf.keystore_explorer.gui.actions.ChangeTypeAction;
import net.sf.keystore_explorer.gui.actions.CheckUpdateAction;
import net.sf.keystore_explorer.gui.actions.CloseAction;
import net.sf.keystore_explorer.gui.actions.CloseAllAction;
import net.sf.keystore_explorer.gui.actions.CloseOthersAction;
import net.sf.keystore_explorer.gui.actions.CopyAction;
import net.sf.keystore_explorer.gui.actions.CopyKeyPairAction;
import net.sf.keystore_explorer.gui.actions.CopyTrustedCertificateAction;
import net.sf.keystore_explorer.gui.actions.CryptographyStrengthAction;
import net.sf.keystore_explorer.gui.actions.CutAction;
import net.sf.keystore_explorer.gui.actions.CutKeyPairAction;
import net.sf.keystore_explorer.gui.actions.CutTrustedCertificateAction;
import net.sf.keystore_explorer.gui.actions.DeleteKeyAction;
import net.sf.keystore_explorer.gui.actions.DeleteKeyPairAction;
import net.sf.keystore_explorer.gui.actions.DeleteTrustedCertificateAction;
import net.sf.keystore_explorer.gui.actions.DetectFileTypeAction;
import net.sf.keystore_explorer.gui.actions.ExamineClipboardAction;
import net.sf.keystore_explorer.gui.actions.ExamineFileAction;
import net.sf.keystore_explorer.gui.actions.ExamineSslAction;
import net.sf.keystore_explorer.gui.actions.ExitAction;
import net.sf.keystore_explorer.gui.actions.ExportKeyPairAction;
import net.sf.keystore_explorer.gui.actions.ExportKeyPairCertificateChainAction;
import net.sf.keystore_explorer.gui.actions.ExportKeyPairPrivateKeyAction;
import net.sf.keystore_explorer.gui.actions.ExportKeyPairPublicKeyAction;
import net.sf.keystore_explorer.gui.actions.ExportTrustedCertificateAction;
import net.sf.keystore_explorer.gui.actions.ExportTrustedCertificatePublicKeyAction;
import net.sf.keystore_explorer.gui.actions.GenerateCsrAction;
import net.sf.keystore_explorer.gui.actions.GenerateKeyPairAction;
import net.sf.keystore_explorer.gui.actions.GenerateSecretKeyAction;
import net.sf.keystore_explorer.gui.actions.HelpAction;
import net.sf.keystore_explorer.gui.actions.ImportCaReplyFromClipboardAction;
import net.sf.keystore_explorer.gui.actions.ImportCaReplyFromFileAction;
import net.sf.keystore_explorer.gui.actions.ImportKeyPairAction;
import net.sf.keystore_explorer.gui.actions.ImportTrustedCertificateAction;
import net.sf.keystore_explorer.gui.actions.JarsAction;
import net.sf.keystore_explorer.gui.actions.KeyDetailsAction;
import net.sf.keystore_explorer.gui.actions.KeyPairCertificateChainDetailsAction;
import net.sf.keystore_explorer.gui.actions.KeyPairPrivateKeyDetailsAction;
import net.sf.keystore_explorer.gui.actions.KeyPairPublicKeyDetailsAction;
import net.sf.keystore_explorer.gui.actions.NewAction;
import net.sf.keystore_explorer.gui.actions.OpenAction;
import net.sf.keystore_explorer.gui.actions.OpenCaCertificatesAction;
import net.sf.keystore_explorer.gui.actions.OpenDefaultAction;
import net.sf.keystore_explorer.gui.actions.OpenMsCapiAction;
import net.sf.keystore_explorer.gui.actions.OpenPkcs11Action;
import net.sf.keystore_explorer.gui.actions.PasteAction;
import net.sf.keystore_explorer.gui.actions.PreferencesAction;
import net.sf.keystore_explorer.gui.actions.PropertiesAction;
import net.sf.keystore_explorer.gui.actions.RedoAction;
import net.sf.keystore_explorer.gui.actions.RemoveFromCertificateChainAction;
import net.sf.keystore_explorer.gui.actions.RenameKeyAction;
import net.sf.keystore_explorer.gui.actions.RenameKeyPairAction;
import net.sf.keystore_explorer.gui.actions.RenameTrustedCertificateAction;
import net.sf.keystore_explorer.gui.actions.SaveAction;
import net.sf.keystore_explorer.gui.actions.SaveAllAction;
import net.sf.keystore_explorer.gui.actions.SaveAsAction;
import net.sf.keystore_explorer.gui.actions.SecurityProvidersAction;
import net.sf.keystore_explorer.gui.actions.SetKeyPairPasswordAction;
import net.sf.keystore_explorer.gui.actions.SetKeyPasswordAction;
import net.sf.keystore_explorer.gui.actions.SetPasswordAction;
import net.sf.keystore_explorer.gui.actions.ShowHideStatusBarAction;
import net.sf.keystore_explorer.gui.actions.ShowHideToolBarAction;
import net.sf.keystore_explorer.gui.actions.SignCsrAction;
import net.sf.keystore_explorer.gui.actions.SignJarAction;
import net.sf.keystore_explorer.gui.actions.SignMidletAction;
import net.sf.keystore_explorer.gui.actions.SignNewKeyPairAction;
import net.sf.keystore_explorer.gui.actions.SystemInformationAction;
import net.sf.keystore_explorer.gui.actions.TabStyleScrollAction;
import net.sf.keystore_explorer.gui.actions.TabStyleWrapAction;
import net.sf.keystore_explorer.gui.actions.TipOfTheDayAction;
import net.sf.keystore_explorer.gui.actions.TrustedCertificateDetailsAction;
import net.sf.keystore_explorer.gui.actions.TrustedCertificatePublicKeyDetailsAction;
import net.sf.keystore_explorer.gui.actions.UndoAction;
import net.sf.keystore_explorer.gui.actions.UnlockKeyAction;
import net.sf.keystore_explorer.gui.actions.UnlockKeyPairAction;
import net.sf.keystore_explorer.gui.actions.WebsiteAction;
import net.sf.keystore_explorer.gui.dnd.DragEntry;
import net.sf.keystore_explorer.gui.dnd.DragKeyPairEntry;
import net.sf.keystore_explorer.gui.dnd.DragTrustedCertificateEntry;
import net.sf.keystore_explorer.gui.dnd.KeyStoreEntryDragGestureListener;
import net.sf.keystore_explorer.gui.error.DError;
import net.sf.keystore_explorer.gui.quickstart.JQuickStartPane;
import net.sf.keystore_explorer.gui.statusbar.StatusBar;
import net.sf.keystore_explorer.gui.statusbar.StatusBarChangeHandler;
import net.sf.keystore_explorer.utilities.buffer.Buffer;
import net.sf.keystore_explorer.utilities.history.KeyStoreHistory;
import net.sf.keystore_explorer.utilities.history.KeyStoreState;
import net.sf.keystore_explorer.utilities.os.OperatingSystem;

/**
 * KeyStore Explorer application frame. Wraps an actual JFrame.
 *
 */
public final class KseFrame implements StatusBar {

    private static ResourceBundle res = ResourceBundle.getBundle("net/sf/keystore_explorer/gui/resources");

    static final String KSE_UPDATE_CHECK_DISABLED = "kse.update.disabled";

    // Default KeyStores tabbed pane width - dictates width of this frame
    public static final int DEFAULT_WIDTH = 700;

    // Default KeyStores tabbed pane - dictates height of this frame
    public static final int DEFAULT_HEIGHT = 450;

    // Maximum number of recent files to maintain in file menu
    public static final int RECENT_FILES_SIZE = 6;

    private ArrayList<KeyStoreHistory> histories = new ArrayList<KeyStoreHistory>();
    private ArrayList<JTable> keyStoreTables = new ArrayList<JTable>();
    private JFrame frame = new JFrame();
    private ApplicationSettings applicationSettings = ApplicationSettings.getInstance();

    //
    // Menu bar controls
    //

    private JMenu jmFile;
    private JMenuItem jmiNew;
    private JMenuItem jmiOpen;
    private JMenu jmOpenSpecial;
    private JMenuItem jmiOpenDefaultKeyStore;
    private JMenuItem jmiOpenCaCertificatesKeyStore;
    private JMenuItem jmiOpenPkcs11KeyStore;
    private JMenuItem jmiOpenMsCapiKeyStore;
    private JMenuItem jmiClose;
    private JMenuItem jmiCloseAll;
    private JMenuItem jmiSave;
    private JMenuItem jmiSaveAs;
    private JMenuItem jmiSaveAll;
    private JMenuRecentFiles jmrfRecentFiles;
    private JMenuItem jmiExit;

    private JMenu jmEdit;
    private JMenuItem jmiUndo;
    private JMenuItem jmiRedo;
    private JMenuItem jmiCut;
    private JMenuItem jmiCopy;
    private JMenuItem jmiPaste;

    private JMenu jmView;
    private JCheckBoxMenuItem jcbmiShowHideToolBar;
    private JCheckBoxMenuItem jcbmiShowHideStatusBar;
    private JMenu jmTabStyle;
    private JRadioButtonMenuItem jrbmiTabStyleWrap;
    private JRadioButtonMenuItem jrbmiTabStyleScroll;

    private JMenu jmTools;
    private JMenuItem jmiGenerateKeyPair;
    private JMenuItem jmiGenerateSecretKey;
    private JMenuItem jmiImportTrustedCertificate;
    private JMenuItem jmiImportKeyPair;
    private JMenu jmChangeType;
    private JRadioButtonMenuItem jrbmiChangeTypeJks;
    private JRadioButtonMenuItem jrbmiChangeTypeHTks;
    private JRadioButtonMenuItem jrbmiChangeTypeJceks;
    private JRadioButtonMenuItem jrbmiChangeTypePkcs12;
    private JRadioButtonMenuItem jrbmiChangeTypeBksV1;
    private JRadioButtonMenuItem jrbmiChangeTypeBks;
    private JRadioButtonMenuItem jrbmiChangeTypeUber;
    private JMenuItem jmiSetPassword;
    private JMenuItem jmiProperties;
    private JMenuItem jmiPreferences;

    private JMenu jmExamine;
    private JMenuItem jmiExamineFile;
    private JMenuItem jmiExamineClipboard;
    private JMenuItem jmiExamineSsl;
    private JMenuItem jmiDetectFileType;

    private JMenu jmHelp;
    private JMenuItem jmiHelp;
    private JMenuItem jmiTipOfTheDay;
    private JMenu jmOnlineResources;
    private JMenuItem jmiWebsite;
    private JMenuItem jmiSourceforge;
    private JMenuItem jmiSfBugs;
    private JMenuItem jmiCheckUpdate;
    private JMenuItem jmiSecurityProviders;
    private JMenuItem jmiSystemInformation;
    private JMenuItem jmiCryptographyStrength;
    private JMenuItem jmiJars;
    private JMenuItem jmiAbout;

    //
    // Tool Bar controls
    //

    private JToolBar jtbToolBar;
    private JButton jbNew;
    private JButton jbOpen;
    private JButton jbSave;
    private JButton jbUndo;
    private JButton jbRedo;
    private JButton jbCut;
    private JButton jbCopy;
    private JButton jbPaste;
    private JButton jbGenerateKeyPair;
    private JButton jbGenerateSecretKey;
    private JButton jbImportTrustedCertificate;
    private JButton jbImportKeyPair;
    private JButton jbSetPassword;
    private JButton jbProperties;
    private JButton jbExamineFile;
    private JButton jbExamineClipboard;
    private JButton jbExamineSsl;
    private JButton jbHelp;

    //
    // Pop-up menu controls
    //

    private JPopupMenu jpmKeyStoreTab;
    private JMenuItem jmiKeyStoreTabSave;
    private JMenuItem jmiKeyStoreTabSaveAll;
    private JMenuItem jmiKeyStoreTabPaste;
    private JMenuItem jmiKeyStoreTabClose;
    private JMenuItem jmiKeyStoreTabCloseOthers;
    private JMenuItem jmiKeyStoreTabCloseAll;
    private JMenuItem jmiKeyStoreTabProperties;

    private JPopupMenu jpmKeyStore;
    private JMenuItem jmiKeyStoreGenerateKeyPair;
    private JMenuItem jmiKeyStoreGenerateSecretKey;
    private JMenuItem jmiKeyStoreImportTrustedCertificate;
    private JMenuItem jmiKeyStoreImportKeyPair;
    private JMenu jmKeyStoreChangeType;
    private JRadioButtonMenuItem jrbmiKeyStoreChangeTypeJks;
    private JRadioButtonMenuItem jrbmiKeyStoreChangeTypeJceks;
    private JRadioButtonMenuItem jrbmiKeyStoreChangeTypePkcs12;
    private JRadioButtonMenuItem jrbmiKeyStoreChangeTypeBksV1;
    private JRadioButtonMenuItem jrbmiKeyStoreChangeTypeBks;
    private JRadioButtonMenuItem jrbmiKeyStoreChangeTypeUber;
    private JMenuItem jmiKeyStoreSetPassword;
    private JMenuItem jmiKeyStoreProperties;

    private JPopupMenu jpmKeyPair;
    private JMenu jmKeyPairDetails;
    private JMenuItem jmiKeyPairCertificateChainDetails;
    private JMenuItem jmiKeyPairPrivateKeyDetails;
    private JMenuItem jmiKeyPairPublicKeyDetails;
    private JMenuItem jmiKeyPairCut;
    private JMenuItem jmiKeyPairCopy;
    private JMenu jmKeyPairExport;
    private JMenuItem jmiKeyPairExport;
    private JMenuItem jmiKeyPairExportCertificateChain;
    private JMenuItem jmiKeyPairExportPrivateKey;
    private JMenuItem jmiKeyPairExportPublicKey;
    private JMenuItem jmiKeyPairGenerateCsr;
    private JMenu jmKeyPairImportCaReply;
    private JMenuItem jmiKeyPairImportCaReplyFile;
    private JMenuItem jmiKeyPairImportCaReplyClipboard;
    private JMenu jmKeyPairEditCertChain;
    private JMenuItem jmiKeyPairEditCertChainAppendCert;
    private JMenuItem jmiKeyPairEditCertChainRemoveCert;
    private JMenu jmKeyPairSign;
    private JMenuItem jmiKeyPairSignCsr;
    private JMenuItem jmiKeyPairSignJar;
    private JMenuItem jmiKeyPairSignMidlet;
    private JMenuItem jmiKeyPairSignNewKeyPair;
    private JMenuItem jmiKeyPairUnlock;
    private JMenuItem jmiKeyPairSetPassword;
    private JMenuItem jmiKeyPairDelete;
    private JMenuItem jmiKeyPairRename;

    private JPopupMenu jpmTrustedCertificate;
    private JMenu jmTrustedCertificateDetails;
    private JMenuItem jmiTrustedCertificateDetails;
    private JMenuItem jmiTrustedCertificatePublicKeyDetails;
    private JMenuItem jmiTrustedCertificateCut;
    private JMenuItem jmiTrustedCertificateCopy;
    private JMenu jmTrustedCertificateExport;
    private JMenuItem jmiTrustedCertificateExport;
    private JMenuItem jmiTrustedCertificateExportPublicKey;
    private JMenuItem jmiTrustedCertificateDelete;
    private JMenuItem jmiTrustedCertificateRename;

    private JPopupMenu jpmKey;

    private JMenuItem jmiKeyDetails;
    private JMenuItem jmiKeyUnlock;
    private JMenuItem jmiKeySetPassword;
    private JMenuItem jmiKeyDelete;
    private JMenuItem jmiKeyRename;

    //
    // Main display controls
    //

    private JKeyStoreTabbedPane jkstpKeyStores;
    private JQuickStartPane jQuickStart;

    //
    // Status bar controls
    //

    private JLabel jlStatusBar;

    //
    // Actions - these are shared between menus and tool bar
    //

    private final NewAction newAction = new NewAction(this);
    private final OpenAction openAction = new OpenAction(this);
    private final OpenDefaultAction openDefaultKeyStoreAction = new OpenDefaultAction(this);
    private final OpenCaCertificatesAction openCaCertificatesKeyStoreAction = new OpenCaCertificatesAction(this);
    private final OpenPkcs11Action openPkcs11KeyStoreAction = new OpenPkcs11Action(this);
    private final OpenMsCapiAction openMsCapiAction = new OpenMsCapiAction(this);
    private final SaveAction saveAction = new SaveAction(this);
    private final SaveAsAction saveAsAction = new SaveAsAction(this);
    private final SaveAllAction saveAllAction = new SaveAllAction(this);
    private final CloseAction closeAction = new CloseAction(this);
    private final CloseOthersAction closeOthersAction = new CloseOthersAction(this);
    private final CloseAllAction closeAllAction = new CloseAllAction(this);
    private final ExitAction exitAction = new ExitAction(this);
    private final UndoAction undoAction = new UndoAction(this);
    private final RedoAction redoAction = new RedoAction(this);
    private final CutAction cutAction = new CutAction(this);
    private final CopyAction copyAction = new CopyAction(this);
    private final PasteAction pasteAction = new PasteAction(this);
    private final ShowHideToolBarAction showHideToolBarAction = new ShowHideToolBarAction(this);
    private final ShowHideStatusBarAction showHideStatusBarAction = new ShowHideStatusBarAction(this);
    private final TabStyleWrapAction tabStyleWrapAction = new TabStyleWrapAction(this);
    private final TabStyleScrollAction tabStyleScrollAction = new TabStyleScrollAction(this);
    private final GenerateKeyPairAction generateKeyPairAction = new GenerateKeyPairAction(this);
    private final GenerateSecretKeyAction generateSecretKeyAction = new GenerateSecretKeyAction(this);
    private final ImportTrustedCertificateAction importTrustedCertificateAction = new ImportTrustedCertificateAction(
            this);
    private final ImportKeyPairAction importKeyPairAction = new ImportKeyPairAction(this);
    private final SetPasswordAction setPasswordAction = new SetPasswordAction(this);
    private final ChangeTypeAction changeTypeJksAction = new ChangeTypeAction(this, KeyStoreType.JKS);
    private final ChangeTypeAction changeTypeHTksAction = new ChangeTypeAction(this, KeyStoreType.HTKS);
    private final ChangeTypeAction changeTypeJceksAction = new ChangeTypeAction(this, KeyStoreType.JCEKS);
    private final ChangeTypeAction changeTypePkcs12Action = new ChangeTypeAction(this, KeyStoreType.PKCS12);
    private final ChangeTypeAction changeTypeBksV1Action = new ChangeTypeAction(this, KeyStoreType.BKS_V1);
    private final ChangeTypeAction changeTypeBksAction = new ChangeTypeAction(this, KeyStoreType.BKS);
    private final ChangeTypeAction changeTypeUberAction = new ChangeTypeAction(this, KeyStoreType.UBER);
    private final PropertiesAction propertiesAction = new PropertiesAction(this);
    private final PreferencesAction preferencesAction = new PreferencesAction(this);
    private final ExamineFileAction examineFileAction = new ExamineFileAction(this);
    private final ExamineClipboardAction examineClipboardAction = new ExamineClipboardAction(this);
    private final ExamineSslAction examineSslAction = new ExamineSslAction(this);
    private final DetectFileTypeAction detectFileTypeAction = new DetectFileTypeAction(this);
    private final HelpAction helpAction = new HelpAction(this);
    private final TipOfTheDayAction tipOfTheDayAction = new TipOfTheDayAction(this);
    private final WebsiteAction websiteAction = new WebsiteAction(this, WebsiteAction.Target.MAIN);
    private final WebsiteAction gitHubProjectSiteAction = new WebsiteAction(this, WebsiteAction.Target.GITHUB);
    private final WebsiteAction gitHubIssueTrackerAction = new WebsiteAction(this,
            WebsiteAction.Target.ISSUE_TRACKER);
    private final CheckUpdateAction checkUpdateAction = new CheckUpdateAction(this);
    private final SecurityProvidersAction securityProvidersAction = new SecurityProvidersAction(this);
    private final SystemInformationAction systemInformationAction = new SystemInformationAction(this);
    private final CryptographyStrengthAction cryptographyStrengthAction = new CryptographyStrengthAction(this);
    private final JarsAction jarsAction = new JarsAction(this);
    private final AboutAction aboutAction = new AboutAction(this);
    private final KeyPairCertificateChainDetailsAction keyPairCertificateChainDetailsAction = new KeyPairCertificateChainDetailsAction(
            this);
    private final KeyPairPrivateKeyDetailsAction keyPairPrivateKeyDetailsAction = new KeyPairPrivateKeyDetailsAction(
            this);
    private final KeyPairPublicKeyDetailsAction keyPairPublicKeyDetailsAction = new KeyPairPublicKeyDetailsAction(
            this);
    private final CutKeyPairAction cutKeyPairAction = new CutKeyPairAction(this);
    private final CopyKeyPairAction copyKeyPairAction = new CopyKeyPairAction(this);
    private final ExportKeyPairAction exportKeyPairAction = new ExportKeyPairAction(this);
    private final ExportKeyPairCertificateChainAction exportKeyPairCertificateChainAction = new ExportKeyPairCertificateChainAction(
            this);
    private final ExportKeyPairPrivateKeyAction exportKeyPairPrivateKeyAction = new ExportKeyPairPrivateKeyAction(
            this);
    private final ExportKeyPairPublicKeyAction exportKeyPairPublicKeyAction = new ExportKeyPairPublicKeyAction(
            this);
    private final GenerateCsrAction generateCsrAction = new GenerateCsrAction(this);
    private final ImportCaReplyFromFileAction importCaReplyFromFileAction = new ImportCaReplyFromFileAction(this);
    private final ImportCaReplyFromClipboardAction importCaReplyFromClipboardAction = new ImportCaReplyFromClipboardAction(
            this);
    private final AppendToCertificateChainAction appendToCertificateChainAction = new AppendToCertificateChainAction(
            this);
    private final RemoveFromCertificateChainAction removeFromCertificateChainAction = new RemoveFromCertificateChainAction(
            this);
    private final SignCsrAction signCsrAction = new SignCsrAction(this);
    private final SignJarAction signJarAction = new SignJarAction(this);
    private final SignMidletAction signMidletAction = new SignMidletAction(this);
    private final SignNewKeyPairAction signNewKeyPairAction = new SignNewKeyPairAction(this);
    private final UnlockKeyPairAction unlockKeyPairAction = new UnlockKeyPairAction(this);
    private final SetKeyPairPasswordAction setKeyPairPasswordAction = new SetKeyPairPasswordAction(this);
    private final DeleteKeyPairAction deleteKeyPairAction = new DeleteKeyPairAction(this);
    private final RenameKeyPairAction renameKeyPairAction = new RenameKeyPairAction(this);
    private final TrustedCertificateDetailsAction trustedCertificateDetailsAction = new TrustedCertificateDetailsAction(
            this);
    private final TrustedCertificatePublicKeyDetailsAction trustedCertificatePublicKeyDetailsAction = new TrustedCertificatePublicKeyDetailsAction(
            this);
    private final CutTrustedCertificateAction cutTrustedCertificateAction = new CutTrustedCertificateAction(this);
    private final CopyTrustedCertificateAction copyTrustedCertificateAction = new CopyTrustedCertificateAction(
            this);
    private final ExportTrustedCertificateAction exportTrustedCertificateAction = new ExportTrustedCertificateAction(
            this);
    private final ExportTrustedCertificatePublicKeyAction exportTrustedCertificatePublicKeyAction = new ExportTrustedCertificatePublicKeyAction(
            this);
    private final DeleteTrustedCertificateAction deleteTrustedCertificateAction = new DeleteTrustedCertificateAction(
            this);
    private final RenameTrustedCertificateAction renameTrustedCertificateAction = new RenameTrustedCertificateAction(
            this);
    private final KeyDetailsAction keyDetailsAction = new KeyDetailsAction(this);
    private final UnlockKeyAction unlockKeyAction = new UnlockKeyAction(this);
    private final SetKeyPasswordAction setKeyPasswordAction = new SetKeyPasswordAction(this);
    private final DeleteKeyAction deleteKeyAction = new DeleteKeyAction(this);
    private final RenameKeyAction renameKeyAction = new RenameKeyAction(this);

    //
    // Action map keys - map input to action
    //

    private static final String CUT_KEY = "CUT_KEY";
    private static final String COPY_KEY = "COPY_KEY";
    private static final String PASTE_KEY = "PASTE_KEY";

    KseFrame() {
        initComponents();
    }

    /**
     * Get underlying JFrame.
     *
     * @return Underlying frame
     */
    public JFrame getUnderlyingFrame() {
        return frame;
    }

    /**
     * Get application settings.
     *
     * @return Application settings
     */
    public ApplicationSettings getApplicationSettings() {
        return applicationSettings;
    }

    void display() {
        frame.setVisible(true);

        if (applicationSettings.getShowTipsOnStartUp()) {
            tipOfTheDayAction.showTipOfTheDay();
        }
    }

    private void initComponents() {
        initStatusBar();
        initMenu();
        initToolBar();
        initMainPane();
        initKeyStoreTabPopupMenu();
        initKeyStorePopupMenu();
        initKeyStoreEntryPopupMenus();

        // Handle application close
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent evt) {
                exitAction.exitApplication();
            }
        });
        frame.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);

        updateApplicationTitle();
        frame.pack();

        initApplicationPosition();
        initApplicationIcons();

        updateControls(false);
    }

    private void initApplicationPosition() {
        Rectangle sizeAndPosition = applicationSettings.getSizeAndPosition();

        int xPos = sizeAndPosition.x;
        int yPos = sizeAndPosition.y;

        if (xPos <= 0 || yPos <= 0) {
            frame.setLocationRelativeTo(null);
        } else {
            frame.setLocation(new Point(xPos, yPos));
        }

        if (!SwingUtilities.isRectangleContainingRectangle(
                new Rectangle(Toolkit.getDefaultToolkit().getScreenSize()), frame.getBounds())) {
            jQuickStart.setPreferredSize(new Dimension(DEFAULT_WIDTH, DEFAULT_HEIGHT));
            frame.setLocationRelativeTo(null);
        }
    }

    private void initApplicationIcons() {
        // Adds many different sizes to give each OS flexibility in choosing a
        // suitable icon for display
        ArrayList<Image> icons = new ArrayList<Image>();
        icons.add(Toolkit.getDefaultToolkit()
                .createImage(getClass().getResource(res.getString("KseFrame.Icon.image.16x16"))));
        icons.add(Toolkit.getDefaultToolkit()
                .createImage(getClass().getResource(res.getString("KseFrame.Icon.image.24x24"))));
        icons.add(Toolkit.getDefaultToolkit()
                .createImage(getClass().getResource(res.getString("KseFrame.Icon.image.32x32"))));
        icons.add(Toolkit.getDefaultToolkit()
                .createImage(getClass().getResource(res.getString("KseFrame.Icon.image.48x48"))));
        icons.add(Toolkit.getDefaultToolkit()
                .createImage(getClass().getResource(res.getString("KseFrame.Icon.image.128x128"))));
        icons.add(Toolkit.getDefaultToolkit()
                .createImage(getClass().getResource(res.getString("KseFrame.Icon.image.256x256"))));
        icons.add(Toolkit.getDefaultToolkit()
                .createImage(getClass().getResource(res.getString("KseFrame.Icon.image.512x512"))));

        frame.setIconImages(icons);
    }

    private void initMenu() {
        JMenuBar jmbMenuBar = new JMenuBar();

        jmFile = new JMenu(res.getString("KseFrame.jmFile.text"));
        PlatformUtil.setMnemonic(jmFile, res.getString("KseFrame.jmFile.mnemonic").charAt(0));

        jmiNew = new JMenuItem(newAction);
        PlatformUtil.setMnemonic(jmiNew, res.getString("KseFrame.jmiNew.mnemonic").charAt(0));
        jmiNew.setToolTipText(null);
        new StatusBarChangeHandler(jmiNew, (String) newAction.getValue(Action.LONG_DESCRIPTION), this);
        jmFile.add(jmiNew);

        jmiOpen = new JMenuItem(openAction);
        PlatformUtil.setMnemonic(jmiOpen, res.getString("KseFrame.jmiOpen.mnemonic").charAt(0));
        jmiOpen.setToolTipText(null);
        new StatusBarChangeHandler(jmiOpen, (String) openAction.getValue(Action.LONG_DESCRIPTION), this);
        jmFile.add(jmiOpen);

        jmOpenSpecial = new JMenu(res.getString("KseFrame.jmOpenSpecial.text"));
        jmOpenSpecial.setIcon(new ImageIcon(Toolkit.getDefaultToolkit()
                .createImage(getClass().getResource(res.getString("KseFrame.jmOpenSpecial.image")))));
        PlatformUtil.setMnemonic(jmOpenSpecial, res.getString("KseFrame.jmOpenSpecial.mnemonic").charAt(0));
        jmFile.add(jmOpenSpecial);

        jmiOpenDefaultKeyStore = new JMenuItem(openDefaultKeyStoreAction);
        PlatformUtil.setMnemonic(jmiOpenDefaultKeyStore,
                res.getString("KseFrame.jmiOpenDefaultKeyStore.mnemonic").charAt(0));
        jmiOpenDefaultKeyStore.setToolTipText(null);
        new StatusBarChangeHandler(jmiOpenDefaultKeyStore,
                (String) openDefaultKeyStoreAction.getValue(Action.LONG_DESCRIPTION), this);
        jmOpenSpecial.add(jmiOpenDefaultKeyStore);

        jmiOpenCaCertificatesKeyStore = new JMenuItem(openCaCertificatesKeyStoreAction);
        PlatformUtil.setMnemonic(jmiOpenCaCertificatesKeyStore,
                res.getString("KseFrame.jmiOpenCaCertificatesKeyStore.mnemonic").charAt(0));
        jmiOpenCaCertificatesKeyStore.setToolTipText(null);
        new StatusBarChangeHandler(jmiOpenCaCertificatesKeyStore,
                (String) openCaCertificatesKeyStoreAction.getValue(Action.LONG_DESCRIPTION), this);
        jmOpenSpecial.add(jmiOpenCaCertificatesKeyStore);

        jmiOpenPkcs11KeyStore = new JMenuItem(openPkcs11KeyStoreAction);
        PlatformUtil.setMnemonic(jmiOpenPkcs11KeyStore,
                res.getString("KseFrame.jmiOpenPkcs11KeyStore.mnemonic").charAt(0));
        jmiOpenPkcs11KeyStore.setToolTipText(null);
        new StatusBarChangeHandler(jmiOpenPkcs11KeyStore,
                (String) openPkcs11KeyStoreAction.getValue(Action.LONG_DESCRIPTION), this);
        jmOpenSpecial.add(jmiOpenPkcs11KeyStore);

        jmiOpenMsCapiKeyStore = new JMenuItem(openMsCapiAction);
        PlatformUtil.setMnemonic(jmiOpenMsCapiKeyStore,
                res.getString("KseFrame.jmiOpenPkcs11KeyStore.mnemonic").charAt(0));
        jmiOpenMsCapiKeyStore.setToolTipText(null);
        new StatusBarChangeHandler(jmiOpenMsCapiKeyStore,
                (String) openMsCapiAction.getValue(Action.LONG_DESCRIPTION), this);
        // show menu item for MSCAPI Windows-MY only on Windows
        if (OperatingSystem.isWindows()) {
            jmOpenSpecial.add(jmiOpenMsCapiKeyStore);
        }

        jmFile.addSeparator();

        jmiClose = new JMenuItem(closeAction);
        PlatformUtil.setMnemonic(jmiClose, res.getString("KseFrame.jmiClose.mnemonic").charAt(0));
        jmiClose.setToolTipText(null);
        new StatusBarChangeHandler(jmiClose, (String) closeAction.getValue(Action.LONG_DESCRIPTION), this);
        jmFile.add(jmiClose);

        jmiCloseAll = new JMenuItem(closeAllAction);
        PlatformUtil.setMnemonic(jmiCloseAll, res.getString("KseFrame.jmiCloseAll.mnemonic").charAt(0));
        jmiCloseAll.setToolTipText(null);
        new StatusBarChangeHandler(jmiCloseAll, (String) closeAllAction.getValue(Action.LONG_DESCRIPTION), this);
        jmFile.add(jmiCloseAll);

        jmFile.addSeparator();

        jmiSave = new JMenuItem(saveAction);
        PlatformUtil.setMnemonic(jmiSave, res.getString("KseFrame.jmiSave.mnemonic").charAt(0));
        jmiSave.setToolTipText(null);
        new StatusBarChangeHandler(jmiSave, (String) saveAction.getValue(Action.LONG_DESCRIPTION), this);
        jmFile.add(jmiSave);

        jmiSaveAs = new JMenuItem(saveAsAction);
        PlatformUtil.setMnemonic(jmiSaveAs, res.getString("KseFrame.jmiSaveAs.mnemonic").charAt(0));
        jmiSaveAs.setDisplayedMnemonicIndex(5);
        jmiSaveAs.setToolTipText(null);
        new StatusBarChangeHandler(jmiSaveAs, (String) saveAsAction.getValue(Action.LONG_DESCRIPTION), this);
        jmFile.add(jmiSaveAs);

        jmiSaveAll = new JMenuItem(saveAllAction);
        PlatformUtil.setMnemonic(jmiSaveAll, res.getString("KseFrame.jmiSaveAll.mnemonic").charAt(0));
        jmiSaveAll.setToolTipText(null);
        new StatusBarChangeHandler(jmiSaveAll, (String) saveAllAction.getValue(Action.LONG_DESCRIPTION), this);
        jmFile.add(jmiSaveAll);

        jmFile.addSeparator();

        jmrfRecentFiles = new JMenuRecentFiles(res.getString("KseFrame.jmrfRecentFiles.text"), RECENT_FILES_SIZE);
        jmrfRecentFiles.setIcon(new ImageIcon(Toolkit.getDefaultToolkit()
                .createImage(getClass().getResource(res.getString("KseFrame.jmrfRecentFiles.image")))));
        PlatformUtil.setMnemonic(jmrfRecentFiles, res.getString("KseFrame.jmrfRecentFiles.mnemonic").charAt(0));
        jmrfRecentFiles.putClientProperty(Options.NO_ICONS_KEY, Boolean.TRUE); // For the benefit of the plastic L&F
        jmFile.add(jmrfRecentFiles);

        File[] recentFiles = applicationSettings.getRecentFiles();

        for (int i = recentFiles.length - 1; i >= 0; i--) {
            jmrfRecentFiles.add(createRecentFileMenuItem(jmrfRecentFiles, recentFiles[i]));
        }

        if (!OperatingSystem.isMacOs()) {
            jmFile.addSeparator();

            jmiExit = new JMenuItem(exitAction);
            PlatformUtil.setMnemonic(jmiExit, res.getString("KseFrame.jmiExit.mnemonic").charAt(0));
            jmiExit.setToolTipText(null);
            new StatusBarChangeHandler(jmiExit, (String) exitAction.getValue(Action.LONG_DESCRIPTION), this);
            jmFile.add(jmiExit);
        }

        jmEdit = new JMenu(res.getString("KseFrame.jmEdit.text"));
        PlatformUtil.setMnemonic(jmEdit, res.getString("KseFrame.jmEdit.mnemonic").charAt(0));

        jmiUndo = new JMenuItem(undoAction);
        PlatformUtil.setMnemonic(jmiUndo, res.getString("KseFrame.jmiUndo.mnemonic").charAt(0));
        jmiUndo.setToolTipText(null);
        new StatusBarChangeHandler(jmiUndo, (String) undoAction.getValue(Action.LONG_DESCRIPTION), this);
        jmEdit.add(jmiUndo);

        jmiRedo = new JMenuItem(redoAction);
        PlatformUtil.setMnemonic(jmiRedo, res.getString("KseFrame.jmiRedo.mnemonic").charAt(0));
        jmiRedo.setToolTipText(null);
        new StatusBarChangeHandler(jmiRedo, (String) redoAction.getValue(Action.LONG_DESCRIPTION), this);
        jmEdit.add(jmiRedo);

        jmEdit.addSeparator();

        jmiCut = new JMenuItem(cutAction);
        PlatformUtil.setMnemonic(jmiCut, res.getString("KseFrame.jmiCut.mnemonic").charAt(0));
        jmiCut.setToolTipText(null);
        new StatusBarChangeHandler(jmiCut, (String) cutAction.getValue(Action.LONG_DESCRIPTION), this);
        jmEdit.add(jmiCut);

        jmiCopy = new JMenuItem(copyAction);
        PlatformUtil.setMnemonic(jmiCopy, res.getString("KseFrame.jmiCopy.mnemonic").charAt(0));
        jmiCopy.setToolTipText(null);
        new StatusBarChangeHandler(jmiCopy, (String) copyAction.getValue(Action.LONG_DESCRIPTION), this);
        jmEdit.add(jmiCopy);

        jmiPaste = new JMenuItem(pasteAction);
        PlatformUtil.setMnemonic(jmiPaste, res.getString("KseFrame.jmiPaste.mnemonic").charAt(0));
        jmiPaste.setToolTipText(null);
        new StatusBarChangeHandler(jmiPaste, (String) pasteAction.getValue(Action.LONG_DESCRIPTION), this);
        jmEdit.add(jmiPaste);

        jmView = new JMenu(res.getString("KseFrame.jmView.text"));
        PlatformUtil.setMnemonic(jmView, res.getString("KseFrame.jmView.mnemonic").charAt(0));

        boolean showToolBar = applicationSettings.getShowToolBar();

        jcbmiShowHideToolBar = new JCheckBoxMenuItem(showHideToolBarAction);
        jcbmiShowHideToolBar.setState(showToolBar);
        PlatformUtil.setMnemonic(jcbmiShowHideToolBar,
                res.getString("KseFrame.jcbmiShowHideToolBar.mnemonic").charAt(0));
        jcbmiShowHideToolBar.setToolTipText(null);
        new StatusBarChangeHandler(jcbmiShowHideToolBar,
                (String) showHideToolBarAction.getValue(Action.LONG_DESCRIPTION), this);
        jmView.add(jcbmiShowHideToolBar);

        jcbmiShowHideStatusBar = new JCheckBoxMenuItem(showHideStatusBarAction);
        jcbmiShowHideStatusBar.setState(applicationSettings.getShowStatusBar());
        PlatformUtil.setMnemonic(jcbmiShowHideStatusBar,
                res.getString("KseFrame.jcbmiShowHideStatusBar.mnemonic").charAt(0));
        jcbmiShowHideStatusBar.setToolTipText(null);
        new StatusBarChangeHandler(jcbmiShowHideStatusBar,
                (String) showHideStatusBarAction.getValue(Action.LONG_DESCRIPTION), this);
        jmView.add(jcbmiShowHideStatusBar);

        jmView.addSeparator();

        jmTabStyle = new JMenu(res.getString("KseFrame.jmTabStyle.text"));
        jmTabStyle.setIcon(new ImageIcon(Toolkit.getDefaultToolkit()
                .createImage(getClass().getResource(res.getString("KseFrame.jmTabStyle.image")))));
        PlatformUtil.setMnemonic(jmTabStyle, res.getString("KseFrame.jmTabStyle.mnemonic").charAt(0));
        jmView.add(jmTabStyle);

        jrbmiTabStyleWrap = new JRadioButtonMenuItem(tabStyleWrapAction);
        PlatformUtil.setMnemonic(jrbmiTabStyleWrap, res.getString("KseFrame.jrbmiTabStyleWrap.mnemonic").charAt(0));
        jrbmiTabStyleWrap.setToolTipText(null);
        new StatusBarChangeHandler(jrbmiTabStyleWrap, (String) tabStyleWrapAction.getValue(Action.LONG_DESCRIPTION),
                this);
        jmTabStyle.add(jrbmiTabStyleWrap);

        jrbmiTabStyleScroll = new JRadioButtonMenuItem(tabStyleScrollAction);
        PlatformUtil.setMnemonic(jrbmiTabStyleScroll,
                res.getString("KseFrame.jrbmiTabStyleScroll.mnemonic").charAt(0));
        jrbmiTabStyleScroll.setToolTipText(null);
        new StatusBarChangeHandler(jrbmiTabStyleScroll,
                (String) tabStyleScrollAction.getValue(Action.LONG_DESCRIPTION), this);
        jmTabStyle.add(jrbmiTabStyleScroll);

        ButtonGroup bgTabStyles = new ButtonGroup();
        bgTabStyles.add(jrbmiTabStyleWrap);
        bgTabStyles.add(jrbmiTabStyleScroll);

        int tabLayout = applicationSettings.getTabLayout();

        if (tabLayout == JTabbedPane.WRAP_TAB_LAYOUT) {
            jrbmiTabStyleWrap.setSelected(true);
        } else {
            jrbmiTabStyleScroll.setSelected(true);
        }

        jmTools = new JMenu(res.getString("KseFrame.jmTools.text"));
        PlatformUtil.setMnemonic(jmTools, res.getString("KseFrame.jmTools.mnemonic").charAt(0));

        jmiGenerateKeyPair = new JMenuItem(generateKeyPairAction);
        PlatformUtil.setMnemonic(jmiGenerateKeyPair,
                res.getString("KseFrame.jmiGenerateKeyPair.mnemonic").charAt(0));
        jmiGenerateKeyPair.setToolTipText(null);
        new StatusBarChangeHandler(jmiGenerateKeyPair,
                (String) generateKeyPairAction.getValue(Action.LONG_DESCRIPTION), this);
        jmTools.add(jmiGenerateKeyPair);

        jmiGenerateSecretKey = new JMenuItem(generateSecretKeyAction);
        PlatformUtil.setMnemonic(jmiGenerateSecretKey,
                res.getString("KseFrame.jmiGenerateSecretKey.mnemonic").charAt(0));
        jmiGenerateSecretKey.setToolTipText(null);
        new StatusBarChangeHandler(jmiGenerateSecretKey,
                (String) generateSecretKeyAction.getValue(Action.LONG_DESCRIPTION), this);
        jmTools.add(jmiGenerateSecretKey);

        jmiImportTrustedCertificate = new JMenuItem(importTrustedCertificateAction);
        PlatformUtil.setMnemonic(jmiImportTrustedCertificate,
                res.getString("KseFrame.jmiImportTrustedCertificate.mnemonic").charAt(0));
        jmiImportTrustedCertificate.setToolTipText(null);
        new StatusBarChangeHandler(jmiImportTrustedCertificate,
                (String) importTrustedCertificateAction.getValue(Action.LONG_DESCRIPTION), this);
        jmTools.add(jmiImportTrustedCertificate);

        jmiImportKeyPair = new JMenuItem(importKeyPairAction);
        PlatformUtil.setMnemonic(jmiImportKeyPair, res.getString("KseFrame.jmiImportKeyPair.mnemonic").charAt(0));
        jmiImportKeyPair.setToolTipText(null);
        new StatusBarChangeHandler(jmiImportKeyPair, (String) importKeyPairAction.getValue(Action.LONG_DESCRIPTION),
                this);
        jmTools.add(jmiImportKeyPair);

        jmTools.addSeparator();

        jmiSetPassword = new JMenuItem(setPasswordAction);
        PlatformUtil.setMnemonic(jmiSetPassword, res.getString("KseFrame.jmiSetPassword.mnemonic").charAt(0));
        jmiSetPassword.setToolTipText(null);
        new StatusBarChangeHandler(jmiSetPassword, (String) setPasswordAction.getValue(Action.LONG_DESCRIPTION),
                this);
        jmTools.add(jmiSetPassword);

        jmChangeType = new JMenu(res.getString("KseFrame.jmChangeType.text"));
        jmChangeType.setIcon(new ImageIcon(Toolkit.getDefaultToolkit()
                .createImage(getClass().getResource(res.getString("KseFrame.jmChangeType.image")))));
        PlatformUtil.setMnemonic(jmChangeType, res.getString("KseFrame.jmChangeType.mnemonic").charAt(0));
        jmChangeType.setEnabled(false);
        jmChangeType.putClientProperty(Options.NO_ICONS_KEY, Boolean.TRUE); // For the benefit of the plastic L&F
        jmTools.add(jmChangeType);

        jrbmiChangeTypeJks = new JRadioButtonMenuItem(changeTypeJksAction);
        PlatformUtil.setMnemonic(jrbmiChangeTypeJks,
                res.getString("KseFrame.jrbmiChangeTypeJks.mnemonic").charAt(0));
        jrbmiChangeTypeJks.setToolTipText(null);
        new StatusBarChangeHandler(jrbmiChangeTypeJks,
                (String) changeTypeJksAction.getValue(Action.LONG_DESCRIPTION), this);
        jmChangeType.add(jrbmiChangeTypeJks);

        jrbmiChangeTypeHTks = new JRadioButtonMenuItem(changeTypeHTksAction);
        PlatformUtil.setMnemonic(jrbmiChangeTypeHTks,
                res.getString("KseFrame.jrbmiChangeTypeJks.mnemonic").charAt(0));
        jrbmiChangeTypeHTks.setToolTipText(null);
        new StatusBarChangeHandler(jrbmiChangeTypeHTks,
                (String) changeTypeHTksAction.getValue(Action.LONG_DESCRIPTION), this);
        jmChangeType.add(jrbmiChangeTypeHTks);

        jrbmiChangeTypeJceks = new JRadioButtonMenuItem(changeTypeJceksAction);
        PlatformUtil.setMnemonic(jrbmiChangeTypeJceks,
                res.getString("KseFrame.jrbmiChangeTypeJceks.mnemonic").charAt(0));
        jrbmiChangeTypeJceks.setToolTipText(null);
        new StatusBarChangeHandler(jrbmiChangeTypeJceks,
                (String) changeTypeJceksAction.getValue(Action.LONG_DESCRIPTION), this);
        jmChangeType.add(jrbmiChangeTypeJceks);

        jrbmiChangeTypePkcs12 = new JRadioButtonMenuItem(changeTypePkcs12Action);
        PlatformUtil.setMnemonic(jrbmiChangeTypePkcs12,
                res.getString("KseFrame.jrbmiChangeTypePkcs12.mnemonic").charAt(0));
        jrbmiChangeTypePkcs12.setToolTipText(null);
        new StatusBarChangeHandler(jrbmiChangeTypePkcs12,
                (String) changeTypePkcs12Action.getValue(Action.LONG_DESCRIPTION), this);
        jmChangeType.add(jrbmiChangeTypePkcs12);

        jrbmiChangeTypeBksV1 = new JRadioButtonMenuItem(changeTypeBksV1Action);
        PlatformUtil.setMnemonic(jrbmiChangeTypeBksV1,
                res.getString("KseFrame.jrbmiChangeTypeBksV1.mnemonic").charAt(0));
        jrbmiChangeTypeBksV1.setToolTipText(null);
        new StatusBarChangeHandler(jrbmiChangeTypeBksV1,
                (String) changeTypeBksV1Action.getValue(Action.LONG_DESCRIPTION), this);
        jmChangeType.add(jrbmiChangeTypeBksV1);

        jrbmiChangeTypeBks = new JRadioButtonMenuItem(changeTypeBksAction);
        PlatformUtil.setMnemonic(jrbmiChangeTypeBks,
                res.getString("KseFrame.jrbmiChangeTypeBks.mnemonic").charAt(0));
        jrbmiChangeTypeBks.setToolTipText(null);
        new StatusBarChangeHandler(jrbmiChangeTypeBks,
                (String) changeTypeBksAction.getValue(Action.LONG_DESCRIPTION), this);
        jmChangeType.add(jrbmiChangeTypeBks);

        jrbmiChangeTypeUber = new JRadioButtonMenuItem(changeTypeUberAction);
        PlatformUtil.setMnemonic(jrbmiChangeTypeUber,
                res.getString("KseFrame.jrbmiChangeTypeUber.mnemonic").charAt(0));
        jrbmiChangeTypeUber.setToolTipText(null);
        new StatusBarChangeHandler(jrbmiChangeTypeUber,
                (String) changeTypeUberAction.getValue(Action.LONG_DESCRIPTION), this);
        jmChangeType.add(jrbmiChangeTypeUber);

        ButtonGroup changeTypeGroup = new ButtonGroup();
        changeTypeGroup.add(jrbmiChangeTypeJks);
        changeTypeGroup.add(jrbmiChangeTypeJceks);
        changeTypeGroup.add(jrbmiChangeTypePkcs12);
        changeTypeGroup.add(jrbmiChangeTypeBks);
        changeTypeGroup.add(jrbmiChangeTypeBksV1);
        changeTypeGroup.add(jrbmiChangeTypeUber);

        jmiProperties = new JMenuItem(propertiesAction);
        PlatformUtil.setMnemonic(jmiProperties, res.getString("KseFrame.jmiProperties.mnemonic").charAt(0));
        jmiProperties.setToolTipText(null);
        new StatusBarChangeHandler(jmiProperties, (String) propertiesAction.getValue(Action.LONG_DESCRIPTION),
                this);
        jmTools.add(jmiProperties);

        if (!OperatingSystem.isMacOs()) {
            jmTools.addSeparator();

            jmiPreferences = new JMenuItem(preferencesAction);
            PlatformUtil.setMnemonic(jmiPreferences, res.getString("KseFrame.jmiPreferences.mnemonic").charAt(0));
            jmiPreferences.setToolTipText(null);
            new StatusBarChangeHandler(jmiPreferences, (String) preferencesAction.getValue(Action.LONG_DESCRIPTION),
                    this);
            jmTools.add(jmiPreferences);
        }

        jmExamine = new JMenu(res.getString("KseFrame.jmExamine.text"));
        PlatformUtil.setMnemonic(jmExamine, res.getString("KseFrame.jmExamine.mnemonic").charAt(0));

        jmiExamineFile = new JMenuItem(examineFileAction);
        PlatformUtil.setMnemonic(jmiExamineFile, res.getString("KseFrame.jmiExamineFile.mnemonic").charAt(0));
        jmiExamineFile.setToolTipText(null);
        new StatusBarChangeHandler(jmiExamineFile, (String) examineFileAction.getValue(Action.LONG_DESCRIPTION),
                this);
        jmExamine.add(jmiExamineFile);

        jmiExamineClipboard = new JMenuItem(examineClipboardAction);
        PlatformUtil.setMnemonic(jmiExamineClipboard,
                res.getString("KseFrame.jmiExamineClipboard.mnemonic").charAt(0));
        jmiExamineClipboard.setToolTipText(null);
        new StatusBarChangeHandler(jmiExamineClipboard,
                (String) examineClipboardAction.getValue(Action.LONG_DESCRIPTION), this);
        jmExamine.add(jmiExamineClipboard);

        jmiExamineSsl = new JMenuItem(examineSslAction);
        PlatformUtil.setMnemonic(jmiExamineSsl, res.getString("KseFrame.jmiExamineSsl.mnemonic").charAt(0));
        jmiExamineSsl.setToolTipText(null);
        new StatusBarChangeHandler(jmiExamineSsl, (String) examineSslAction.getValue(Action.LONG_DESCRIPTION),
                this);
        jmExamine.add(jmiExamineSsl);

        jmExamine.addSeparator();

        jmiDetectFileType = new JMenuItem(detectFileTypeAction);
        PlatformUtil.setMnemonic(jmiDetectFileType, res.getString("KseFrame.jmiDetectFileType.mnemonic").charAt(0));
        jmiDetectFileType.setToolTipText(null);
        new StatusBarChangeHandler(jmiDetectFileType,
                (String) detectFileTypeAction.getValue(Action.LONG_DESCRIPTION), this);
        jmExamine.add(jmiDetectFileType);

        jmHelp = new JMenu(res.getString("KseFrame.jmHelp.text"));
        PlatformUtil.setMnemonic(jmHelp, res.getString("KseFrame.jmHelp.mnemonic").charAt(0));

        jmiHelp = new JMenuItem(helpAction);
        PlatformUtil.setMnemonic(jmiHelp, res.getString("KseFrame.jmiHelp.mnemonic").charAt(0));
        jmiHelp.setToolTipText(null);
        new StatusBarChangeHandler(jmiHelp, (String) helpAction.getValue(Action.LONG_DESCRIPTION), this);
        jmHelp.add(jmiHelp);

        jmiTipOfTheDay = new JMenuItem(tipOfTheDayAction);
        PlatformUtil.setMnemonic(jmiTipOfTheDay, res.getString("KseFrame.jmiTipOfTheDay.mnemonic").charAt(0));
        jmiTipOfTheDay.setToolTipText(null);
        new StatusBarChangeHandler(jmiTipOfTheDay, (String) tipOfTheDayAction.getValue(Action.LONG_DESCRIPTION),
                this);
        jmHelp.add(jmiTipOfTheDay);

        jmHelp.addSeparator();

        jmOnlineResources = new JMenu(res.getString("KseFrame.jmOnlineResources.text"));
        jmOnlineResources.setIcon(new ImageIcon(Toolkit.getDefaultToolkit()
                .createImage(getClass().getResource(res.getString("KseFrame.jmOnlineResources.image")))));
        PlatformUtil.setMnemonic(jmOnlineResources, res.getString("KseFrame.jmOnlineResources.mnemonic").charAt(0));
        jmHelp.add(jmOnlineResources);

        jmiWebsite = new JMenuItem(websiteAction);
        PlatformUtil.setMnemonic(jmiWebsite, res.getString("KseFrame.jmiWebsite.mnemonic").charAt(0));
        jmiWebsite.setToolTipText(null);
        new StatusBarChangeHandler(jmiWebsite, (String) websiteAction.getValue(Action.LONG_DESCRIPTION), this);
        jmOnlineResources.add(jmiWebsite);

        jmiSourceforge = new JMenuItem(gitHubProjectSiteAction);
        PlatformUtil.setMnemonic(jmiSourceforge, res.getString("KseFrame.jmiSourceforge.mnemonic").charAt(0));
        jmiSourceforge.setToolTipText(null);
        new StatusBarChangeHandler(jmiSourceforge,
                (String) gitHubProjectSiteAction.getValue(Action.LONG_DESCRIPTION), this);
        jmOnlineResources.add(jmiSourceforge);

        jmiSfBugs = new JMenuItem(gitHubIssueTrackerAction);
        PlatformUtil.setMnemonic(jmiSfBugs, res.getString("KseFrame.jmiSfBugs.mnemonic").charAt(0));
        jmiSfBugs.setToolTipText(null);
        new StatusBarChangeHandler(jmiSfBugs, (String) gitHubIssueTrackerAction.getValue(Action.LONG_DESCRIPTION),
                this);
        jmOnlineResources.add(jmiSfBugs);

        jmiCheckUpdate = new JMenuItem(checkUpdateAction);
        PlatformUtil.setMnemonic(jmiCheckUpdate, res.getString("KseFrame.jmiCheckUpdate.mnemonic").charAt(0));
        jmiCheckUpdate.setToolTipText(null);
        new StatusBarChangeHandler(jmiCheckUpdate, (String) checkUpdateAction.getValue(Action.LONG_DESCRIPTION),
                this);
        // no update checks if KSE was packaged as rpm
        if (!Boolean.getBoolean(KSE_UPDATE_CHECK_DISABLED)) {
            jmOnlineResources.add(jmiCheckUpdate);
        }

        jmiSecurityProviders = new JMenuItem(securityProvidersAction);
        PlatformUtil.setMnemonic(jmiSecurityProviders,
                res.getString("KseFrame.jmiSecurityProviders.mnemonic").charAt(0));
        jmiSecurityProviders.setToolTipText(null);
        new StatusBarChangeHandler(jmiSecurityProviders,
                (String) securityProvidersAction.getValue(Action.LONG_DESCRIPTION), this);
        jmHelp.add(jmiSecurityProviders);

        jmiCryptographyStrength = new JMenuItem(cryptographyStrengthAction);
        PlatformUtil.setMnemonic(jmiCryptographyStrength,
                res.getString("KseFrame.jmiCryptographyStrength.mnemonic").charAt(0));
        jmiCryptographyStrength.setToolTipText(null);
        new StatusBarChangeHandler(jmiCryptographyStrength,
                (String) cryptographyStrengthAction.getValue(Action.LONG_DESCRIPTION), this);
        jmHelp.add(jmiCryptographyStrength);

        jmiJars = new JMenuItem(jarsAction);
        PlatformUtil.setMnemonic(jmiJars, res.getString("KseFrame.jmiJars.mnemonic").charAt(0));
        jmiJars.setToolTipText(null);
        new StatusBarChangeHandler(jmiJars, (String) jarsAction.getValue(Action.LONG_DESCRIPTION), this);
        jmHelp.add(jmiJars);

        jmiSystemInformation = new JMenuItem(systemInformationAction);
        PlatformUtil.setMnemonic(jmiSystemInformation,
                res.getString("KseFrame.jmiSystemInformation.mnemonic").charAt(0));
        jmiSystemInformation.setToolTipText(null);
        new StatusBarChangeHandler(jmiSystemInformation,
                (String) systemInformationAction.getValue(Action.LONG_DESCRIPTION), this);
        jmHelp.add(jmiSystemInformation);

        if (!OperatingSystem.isMacOs()) {
            jmHelp.addSeparator();

            jmiAbout = new JMenuItem(aboutAction);
            PlatformUtil.setMnemonic(jmiAbout, res.getString("KseFrame.jmiAbout.mnemonic").charAt(0));
            jmiAbout.setToolTipText(null);
            new StatusBarChangeHandler(jmiAbout, (String) aboutAction.getValue(Action.LONG_DESCRIPTION), this);
            jmHelp.add(jmiAbout);
        }

        jmbMenuBar.add(jmFile);
        jmbMenuBar.add(jmEdit);
        jmbMenuBar.add(jmView);
        jmbMenuBar.add(jmTools);
        jmbMenuBar.add(jmExamine);
        jmbMenuBar.add(jmHelp);

        jmbMenuBar.putClientProperty(Options.HEADER_STYLE_KEY, HeaderStyle.BOTH);

        frame.setJMenuBar(jmbMenuBar);
    }

    private JMenuItemRecentFile createRecentFileMenuItem(JMenuRecentFiles jmRecentFiles, File recentFile) {
        JMenuItemRecentFile jmirfNew = new JMenuItemRecentFile(jmRecentFiles, recentFile);
        jmirfNew.addActionListener(new RecentKeyStoreFileActionListener(recentFile, this));

        new StatusBarChangeHandler(jmirfNew,
                MessageFormat.format(res.getString("KseFrame.recentfile.statusbar"), recentFile), this);
        return jmirfNew;
    }

    private void initToolBar() {
        jbNew = new JButton();
        jbNew.setAction(newAction);
        jbNew.setText(null);
        PlatformUtil.setMnemonic(jbNew, 0);
        jbNew.setFocusable(false);
        jbNew.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent evt) {
                setStatusBarText((String) newAction.getValue(Action.LONG_DESCRIPTION));
            }

            @Override
            public void mouseExited(MouseEvent evt) {
                setDefaultStatusBarText();
            }
        });

        jbOpen = new JButton();
        jbOpen.setAction(openAction);
        jbOpen.setText(null);
        PlatformUtil.setMnemonic(jbOpen, 0);
        jbOpen.setFocusable(false);
        jbOpen.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent evt) {
                setStatusBarText((String) openAction.getValue(Action.LONG_DESCRIPTION));
            }

            @Override
            public void mouseExited(MouseEvent evt) {
                setDefaultStatusBarText();
            }
        });

        jbSave = new JButton();
        jbSave.setAction(saveAction);
        jbSave.setText(null);
        PlatformUtil.setMnemonic(jbSave, 0);
        jbSave.setFocusable(false);
        jbSave.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent evt) {
                setStatusBarText((String) saveAction.getValue(Action.LONG_DESCRIPTION));
            }

            @Override
            public void mouseExited(MouseEvent evt) {
                setDefaultStatusBarText();
            }
        });

        jbUndo = new JButton();
        jbUndo.setAction(undoAction);
        jbUndo.setText(null);
        PlatformUtil.setMnemonic(jbUndo, 0);
        jbUndo.setHideActionText(true); // Ensure text is not displayed when
        // changed dynamically
        // later on action
        jbUndo.setFocusable(false);
        jbUndo.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent evt) {
                setStatusBarText((String) undoAction.getValue(Action.LONG_DESCRIPTION));
            }

            @Override
            public void mouseExited(MouseEvent evt) {
                setDefaultStatusBarText();
            }
        });

        jbRedo = new JButton();
        jbRedo.setAction(redoAction);
        jbRedo.setText(null);
        PlatformUtil.setMnemonic(jbRedo, 0);
        jbRedo.setHideActionText(true); // Ensure text is not displayed when
        // changed dynamically
        // later on action
        jbRedo.setFocusable(false);
        jbRedo.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent evt) {
                setStatusBarText((String) redoAction.getValue(Action.LONG_DESCRIPTION));
            }

            @Override
            public void mouseExited(MouseEvent evt) {
                setDefaultStatusBarText();
            }
        });

        jbCut = new JButton();
        jbCut.setAction(cutAction);
        jbCut.setText(null);
        PlatformUtil.setMnemonic(jbCut, 0);
        jbCut.setFocusable(false);
        jbCut.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent evt) {
                setStatusBarText((String) cutAction.getValue(Action.LONG_DESCRIPTION));
            }

            @Override
            public void mouseExited(MouseEvent evt) {
                setDefaultStatusBarText();
            }
        });

        jbCopy = new JButton();
        jbCopy.setAction(copyAction);
        jbCopy.setText(null);
        PlatformUtil.setMnemonic(jbCopy, 0);
        jbCopy.setFocusable(false);
        jbCopy.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent evt) {
                setStatusBarText((String) copyAction.getValue(Action.LONG_DESCRIPTION));
            }

            @Override
            public void mouseExited(MouseEvent evt) {
                setDefaultStatusBarText();
            }
        });

        jbPaste = new JButton();
        jbPaste.setAction(pasteAction);
        jbPaste.setText(null);
        PlatformUtil.setMnemonic(jbPaste, 0);
        jbPaste.setFocusable(false);
        jbPaste.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent evt) {
                setStatusBarText((String) pasteAction.getValue(Action.LONG_DESCRIPTION));
            }

            @Override
            public void mouseExited(MouseEvent evt) {
                setDefaultStatusBarText();
            }
        });

        jbGenerateKeyPair = new JButton();
        jbGenerateKeyPair.setAction(generateKeyPairAction);
        jbGenerateKeyPair.setText(null);
        PlatformUtil.setMnemonic(jbGenerateKeyPair, 0);
        jbGenerateKeyPair.setFocusable(false);
        jbGenerateKeyPair.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent evt) {
                setStatusBarText((String) generateKeyPairAction.getValue(Action.LONG_DESCRIPTION));
            }

            @Override
            public void mouseExited(MouseEvent evt) {
                setDefaultStatusBarText();
            }
        });

        jbGenerateSecretKey = new JButton();
        jbGenerateSecretKey.setAction(generateSecretKeyAction);
        jbGenerateSecretKey.setText(null);
        PlatformUtil.setMnemonic(jbGenerateSecretKey, 0);
        jbGenerateSecretKey.setFocusable(false);
        jbGenerateSecretKey.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent evt) {
                setStatusBarText((String) generateSecretKeyAction.getValue(Action.LONG_DESCRIPTION));
            }

            @Override
            public void mouseExited(MouseEvent evt) {
                setDefaultStatusBarText();
            }
        });

        jbImportTrustedCertificate = new JButton();
        jbImportTrustedCertificate.setAction(importTrustedCertificateAction);
        jbImportTrustedCertificate.setText(null);
        PlatformUtil.setMnemonic(jbImportTrustedCertificate, 0);
        jbImportTrustedCertificate.setFocusable(false);
        jbImportTrustedCertificate.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent evt) {
                setStatusBarText((String) importTrustedCertificateAction.getValue(Action.LONG_DESCRIPTION));
            }

            @Override
            public void mouseExited(MouseEvent evt) {
                setDefaultStatusBarText();
            }
        });

        jbImportKeyPair = new JButton();
        jbImportKeyPair.setAction(importKeyPairAction);
        jbImportKeyPair.setText(null);
        PlatformUtil.setMnemonic(jbImportKeyPair, 0);
        jbImportKeyPair.setFocusable(false);
        jbImportKeyPair.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent evt) {
                setStatusBarText((String) importKeyPairAction.getValue(Action.LONG_DESCRIPTION));
            }

            @Override
            public void mouseExited(MouseEvent evt) {
                setDefaultStatusBarText();
            }
        });

        jbSetPassword = new JButton();
        jbSetPassword.setAction(setPasswordAction);
        jbSetPassword.setText(null);
        PlatformUtil.setMnemonic(jbSetPassword, 0);
        jbSetPassword.setFocusable(false);
        jbSetPassword.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent evt) {
                setStatusBarText((String) setPasswordAction.getValue(Action.LONG_DESCRIPTION));
            }

            @Override
            public void mouseExited(MouseEvent evt) {
                setDefaultStatusBarText();
            }
        });

        jbProperties = new JButton();
        jbProperties.setAction(propertiesAction);
        jbProperties.setText(null);
        PlatformUtil.setMnemonic(jbProperties, 0);
        jbProperties.setFocusable(false);
        jbProperties.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent evt) {
                setStatusBarText((String) propertiesAction.getValue(Action.LONG_DESCRIPTION));
            }

            @Override
            public void mouseExited(MouseEvent evt) {
                setDefaultStatusBarText();
            }
        });

        jbExamineFile = new JButton();
        jbExamineFile.setAction(examineFileAction);
        jbExamineFile.setText(null);
        PlatformUtil.setMnemonic(jbExamineFile, 0);
        jbExamineFile.setFocusable(false);
        jbExamineFile.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent evt) {
                setStatusBarText((String) examineFileAction.getValue(Action.LONG_DESCRIPTION));
            }

            @Override
            public void mouseExited(MouseEvent evt) {
                setDefaultStatusBarText();
            }
        });

        jbExamineClipboard = new JButton();
        jbExamineClipboard.setAction(examineClipboardAction);
        jbExamineClipboard.setText(null);
        PlatformUtil.setMnemonic(jbExamineClipboard, 0);
        jbExamineClipboard.setFocusable(false);
        jbExamineClipboard.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent evt) {
                setStatusBarText((String) examineClipboardAction.getValue(Action.LONG_DESCRIPTION));
            }

            @Override
            public void mouseExited(MouseEvent evt) {
                setDefaultStatusBarText();
            }
        });

        jbExamineSsl = new JButton();
        jbExamineSsl.setAction(examineSslAction);
        jbExamineSsl.setText(null);
        PlatformUtil.setMnemonic(jbExamineSsl, 0);
        jbExamineSsl.setFocusable(false);
        jbExamineSsl.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent evt) {
                setStatusBarText((String) examineSslAction.getValue(Action.LONG_DESCRIPTION));
            }

            @Override
            public void mouseExited(MouseEvent evt) {
                setDefaultStatusBarText();
            }
        });

        jbHelp = new JButton();
        jbHelp.setAction(helpAction);
        jbHelp.setText(null);
        PlatformUtil.setMnemonic(jbHelp, 0);
        jbHelp.setFocusable(false);
        jbHelp.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent evt) {
                setStatusBarText((String) helpAction.getValue(Action.LONG_DESCRIPTION));
            }

            @Override
            public void mouseExited(MouseEvent evt) {
                setDefaultStatusBarText();
            }
        });

        jtbToolBar = new JToolBar();

        // If using Windows need a bottom line on the toolbar to seperate it
        // from the main view
        if (LnfUtil.usingWindowsLnf() || LnfUtil.usingWindowsClassicLnf()) {
            jtbToolBar.setBorder(new MatteBorder(0, 0, 1, 0, Color.LIGHT_GRAY));
        }

        jtbToolBar.setFloatable(false);
        jtbToolBar.setRollover(true);
        jtbToolBar.setName(KSE.getApplicationName());

        jtbToolBar.add(jbNew);
        jtbToolBar.add(jbOpen);
        jtbToolBar.add(jbSave);

        jtbToolBar.addSeparator();

        jtbToolBar.add(jbUndo);
        jtbToolBar.add(jbRedo);

        jtbToolBar.addSeparator();

        jtbToolBar.add(jbCut);
        jtbToolBar.add(jbCopy);
        jtbToolBar.add(jbPaste);

        jtbToolBar.addSeparator();

        jtbToolBar.add(jbGenerateKeyPair);
        jtbToolBar.add(jbGenerateSecretKey);
        jtbToolBar.add(jbImportTrustedCertificate);
        jtbToolBar.add(jbImportKeyPair);
        jtbToolBar.add(jbSetPassword);
        jtbToolBar.add(jbProperties);

        jtbToolBar.addSeparator();

        jtbToolBar.add(jbExamineFile);
        jtbToolBar.add(jbExamineClipboard);
        jtbToolBar.add(jbExamineSsl);

        jtbToolBar.addSeparator();

        jtbToolBar.add(jbHelp);

        jtbToolBar.putClientProperty(Options.HEADER_STYLE_KEY, HeaderStyle.BOTH);

        if (applicationSettings.getShowToolBar()) {
            frame.getContentPane().add(jtbToolBar, BorderLayout.NORTH);
        }
    }

    private void initMainPane() {

        // Displays Quick Start pane initially and KeyStore tabbed pane when at
        // least one KeyStore is open

        jQuickStart = new JQuickStartPane(this);

        jkstpKeyStores = new JKeyStoreTabbedPane(this);

        int tabLayout = applicationSettings.getTabLayout();
        jkstpKeyStores.setTabLayoutPolicy(tabLayout);

        jkstpKeyStores.setBorder(new EmptyBorder(3, 3, 3, 3));

        jkstpKeyStores.addChangeListener(new ChangeListener() {
            @Override
            public void stateChanged(ChangeEvent evt) {
                // Update controls as selected KeyStore is changed
                updateControls(false);
            }
        });

        jkstpKeyStores.addMouseListener(new MouseAdapter() {
            @Override
            public void mousePressed(MouseEvent evt) {
                maybeShowKeyStoreTabPopup(evt);
            }

            @Override
            public void mouseReleased(MouseEvent evt) {
                maybeShowKeyStoreTabPopup(evt);
            }

            @Override
            public void mouseClicked(MouseEvent evt) {
                // Close tab if it is middle-clicked
                if (evt.getButton() == MouseEvent.BUTTON2) {
                    closeAction.closeActiveKeyStore();
                }
            }
        });

        Rectangle sizeAndPosition = applicationSettings.getSizeAndPosition();
        int width = sizeAndPosition.width;
        int height = sizeAndPosition.height;

        if (width <= 0 || height <= 0) {
            jQuickStart.setPreferredSize(new Dimension(DEFAULT_WIDTH, DEFAULT_HEIGHT));
        } else {
            jQuickStart.setPreferredSize(new Dimension(width, height));
        }

        frame.getContentPane().add(jQuickStart, BorderLayout.CENTER);
    }

    private JScrollPane wrapKeyStoreTableInScrollPane(JTable jtKeyStore) {

        jtKeyStore.setOpaque(true);
        jtKeyStore.setShowGrid(false);
        jtKeyStore.setFillsViewportHeight(true);
        JScrollPane jspKeyStoreTable = PlatformUtil.createScrollPane(
                ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED, ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);

        jspKeyStoreTable.setViewportView(jtKeyStore);
        jspKeyStoreTable.setBorder(BorderFactory.createEtchedBorder());
        jspKeyStoreTable.setFocusable(false);

        return jspKeyStoreTable;
    }

    private JTable createEmptyKeyStoreTable() {
        KeyStoreTableModel ksModel = new KeyStoreTableModel();
        final JTable jtKeyStore = new JKseTable(ksModel);

        RowSorter<TableModel> sorter = new TableRowSorter<TableModel>(ksModel);
        jtKeyStore.setRowSorter(sorter);

        jtKeyStore.setShowGrid(false);
        jtKeyStore.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
        jtKeyStore.getTableHeader().setReorderingAllowed(false);
        jtKeyStore.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
        jtKeyStore.setRowHeight(Math.max(18, jtKeyStore.getRowHeight())); // min. height of 18 because of 16x16 icons

        // Register cut, copy and paste actions with the relevant keystrokes
        jtKeyStore.getInputMap().put((KeyStroke) cutAction.getValue(Action.ACCELERATOR_KEY), CUT_KEY);
        jtKeyStore.getActionMap().put(CUT_KEY, cutAction);

        jtKeyStore.getInputMap().put((KeyStroke) copyAction.getValue(Action.ACCELERATOR_KEY), COPY_KEY);
        jtKeyStore.getActionMap().put(COPY_KEY, copyAction);

        jtKeyStore.getInputMap().put((KeyStroke) pasteAction.getValue(Action.ACCELERATOR_KEY), PASTE_KEY);
        jtKeyStore.getActionMap().put(PASTE_KEY, pasteAction);

        // open keystore entry details when user presses enter key
        KeyStroke enter = KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0);
        jtKeyStore.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(enter, "Enter");
        jtKeyStore.getActionMap().put("Enter", new AbstractAction() {
            @Override
            public void actionPerformed(ActionEvent ae) {
                try {
                    int selectedRow = jtKeyStore.getSelectedRow();
                    if (selectedRow != -1) {
                        CursorUtil.setCursorBusy(frame);
                        showSelectedEntryDetails(jtKeyStore, selectedRow);
                    }
                } finally {
                    CursorUtil.setCursorFree(frame);
                }
            }
        });

        // Add DnD source support to KeyStore
        DragSource ds = DragSource.getDefaultDragSource();
        ds.createDefaultDragGestureRecognizer(jtKeyStore, DnDConstants.ACTION_MOVE,
                new KeyStoreEntryDragGestureListener(this));

        // Add custom renderers for headers and cells
        for (int i = 0; i < jtKeyStore.getColumnCount(); i++) {
            TableColumn column = jtKeyStore.getColumnModel().getColumn(i);
            column.setHeaderRenderer(new KeyStoreTableHeadRend(jtKeyStore.getTableHeader().getDefaultRenderer()));
            column.setCellRenderer(new KeyStoreTableCellRend());
        }

        // Make the first three columns small and not resizable as they hold icons
        TableColumn typeCol = jtKeyStore.getColumnModel().getColumn(0);
        typeCol.setResizable(false);
        typeCol.setMinWidth(28);
        typeCol.setMaxWidth(28);
        typeCol.setPreferredWidth(28);

        TableColumn statusCol = jtKeyStore.getColumnModel().getColumn(1);
        statusCol.setResizable(false);
        statusCol.setMinWidth(28);
        statusCol.setMaxWidth(28);
        statusCol.setPreferredWidth(28);

        TableColumn certExpiredCol = jtKeyStore.getColumnModel().getColumn(2);
        certExpiredCol.setResizable(false);
        certExpiredCol.setMinWidth(28);
        certExpiredCol.setMaxWidth(28);
        certExpiredCol.setPreferredWidth(28);

        jtKeyStore.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseClicked(MouseEvent evt) {
                maybeShowSelectedEntryDetails(evt);
            }

            @Override
            public void mousePressed(MouseEvent evt) {
                maybeShowSelectedEntryPopupMenu(evt);
            }

            @Override
            public void mouseReleased(MouseEvent evt) {
                maybeShowSelectedEntryPopupMenu(evt);
            }
        });

        jtKeyStore.addKeyListener(new KeyAdapter() {
            boolean deleteLastPressed = false;

            @Override
            public void keyPressed(KeyEvent evt) {
                // Record delete pressed on non-Macs
                if (!OperatingSystem.isMacOs()) {
                    deleteLastPressed = evt.getKeyCode() == KeyEvent.VK_DELETE;
                }
            }

            @Override
            public void keyReleased(KeyEvent evt) {
                // Delete on non-Mac if delete was pressed and is now released
                if (!OperatingSystem.isMacOs() && deleteLastPressed && evt.getKeyCode() == KeyEvent.VK_DELETE) {
                    deleteLastPressed = false;
                    handleDeleteSelectedEntry();
                }
            }

            @Override
            public void keyTyped(KeyEvent evt) {
                // Delete on Mac if back space typed
                if (OperatingSystem.isMacOs() && evt.getKeyChar() == 0x08) {
                    handleDeleteSelectedEntry();
                }
            }
        });

        return jtKeyStore;
    }

    private void handleDeleteSelectedEntry() {
        KeyStoreHistory history = getActiveKeyStoreHistory();
        KeyStore keyStore = history.getCurrentState().getKeyStore();
        String alias = getSelectedEntryAlias();

        try {
            if (KeyStoreUtil.isKeyPairEntry(alias, keyStore)) {
                deleteKeyPairAction.deleteSelectedEntry();
            } else if (KeyStoreUtil.isTrustedCertificateEntry(alias, keyStore)) {
                deleteTrustedCertificateAction.deleteSelectedEntry();
            } else {
                deleteKeyAction.deleteSelectedEntry();
            }
        } catch (Exception ex) {
            DError.displayError(frame, ex);
        }
    }

    private void initStatusBar() {
        jlStatusBar = new JLabel();

        int rightPadding = 3;

        if (OperatingSystem.isMacOs()) {
            rightPadding = 15; // Allow extra padding in the grow box status bar
            // if using Mac OS
        }

        jlStatusBar.setBorder(new CompoundBorder(new MatteBorder(1, 0, 0, 0, Color.LIGHT_GRAY),
                new EmptyBorder(3, 3, 3, rightPadding)));

        setDefaultStatusBarText();

        if (applicationSettings.getShowStatusBar()) {
            frame.getContentPane().add(jlStatusBar, BorderLayout.SOUTH);
        }
    }

    private void initKeyStoreTabPopupMenu() {
        jpmKeyStoreTab = new JPopupMenu();

        jmiKeyStoreTabSave = new JMenuItem(saveAction);
        jmiKeyStoreTabSave.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyStoreTabSave, (String) saveAction.getValue(Action.LONG_DESCRIPTION), this);
        jpmKeyStoreTab.add(jmiKeyStoreTabSave);

        jmiKeyStoreTabSaveAll = new JMenuItem(saveAllAction);
        jmiKeyStoreTabSaveAll.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyStoreTabSaveAll, (String) saveAllAction.getValue(Action.LONG_DESCRIPTION),
                this);
        jpmKeyStoreTab.add(jmiKeyStoreTabSaveAll);

        jpmKeyStoreTab.addSeparator();

        jmiKeyStoreTabPaste = new JMenuItem(pasteAction);
        jmiKeyStoreTabPaste.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyStoreTabPaste, (String) pasteAction.getValue(Action.LONG_DESCRIPTION),
                this);
        jpmKeyStoreTab.add(jmiKeyStoreTabPaste);

        jpmKeyStoreTab.addSeparator();

        jmiKeyStoreTabClose = new JMenuItem(closeAction);
        jmiKeyStoreTabClose.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyStoreTabClose, (String) closeAction.getValue(Action.LONG_DESCRIPTION),
                this);
        jpmKeyStoreTab.add(jmiKeyStoreTabClose);

        jmiKeyStoreTabCloseOthers = new JMenuItem(closeOthersAction);
        jmiKeyStoreTabCloseOthers.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyStoreTabCloseOthers,
                (String) closeOthersAction.getValue(Action.LONG_DESCRIPTION), this);
        jpmKeyStoreTab.add(jmiKeyStoreTabCloseOthers);

        jmiKeyStoreTabCloseAll = new JMenuItem(closeAllAction);
        jmiKeyStoreTabCloseAll.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyStoreTabCloseAll,
                (String) closeAllAction.getValue(Action.LONG_DESCRIPTION), this);
        jpmKeyStoreTab.add(jmiKeyStoreTabCloseAll);

        jpmKeyStoreTab.addSeparator();

        jmiKeyStoreTabProperties = new JMenuItem(propertiesAction);
        jmiKeyStoreTabProperties.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyStoreTabProperties,
                (String) propertiesAction.getValue(Action.LONG_DESCRIPTION), this);
        jpmKeyStoreTab.add(jmiKeyStoreTabProperties);
    }

    private void initKeyStorePopupMenu() {
        jpmKeyStore = new JPopupMenu();

        jmiKeyStoreGenerateKeyPair = new JMenuItem(generateKeyPairAction);
        PlatformUtil.setMnemonic(jmiGenerateKeyPair,
                res.getString("KseFrame.jmiGenerateKeyPair.mnemonic").charAt(0));
        jmiKeyStoreGenerateKeyPair.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyStoreGenerateKeyPair,
                (String) generateKeyPairAction.getValue(Action.LONG_DESCRIPTION), this);
        jpmKeyStore.add(jmiKeyStoreGenerateKeyPair);

        jmiKeyStoreGenerateSecretKey = new JMenuItem(generateSecretKeyAction);
        PlatformUtil.setMnemonic(jmiKeyStoreGenerateSecretKey,
                res.getString("KseFrame.jmiGenerateSecretKey.mnemonic").charAt(0));
        jmiKeyStoreGenerateSecretKey.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyStoreGenerateSecretKey,
                (String) generateSecretKeyAction.getValue(Action.LONG_DESCRIPTION), this);
        jpmKeyStore.add(jmiKeyStoreGenerateSecretKey);

        jmiKeyStoreImportTrustedCertificate = new JMenuItem(importTrustedCertificateAction);
        PlatformUtil.setMnemonic(jmiKeyStoreImportTrustedCertificate,
                res.getString("KseFrame.jmiImportTrustedCertificate.mnemonic").charAt(0));
        jmiKeyStoreImportTrustedCertificate.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyStoreImportTrustedCertificate,
                (String) importTrustedCertificateAction.getValue(Action.LONG_DESCRIPTION), this);
        jpmKeyStore.add(jmiKeyStoreImportTrustedCertificate);

        jmiKeyStoreImportKeyPair = new JMenuItem(importKeyPairAction);
        PlatformUtil.setMnemonic(jmiKeyStoreImportKeyPair,
                res.getString("KseFrame.jmiImportKeyPair.mnemonic").charAt(0));
        jmiKeyStoreImportKeyPair.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyStoreImportKeyPair,
                (String) importKeyPairAction.getValue(Action.LONG_DESCRIPTION), this);
        jpmKeyStore.add(jmiKeyStoreImportKeyPair);

        jpmKeyStore.addSeparator();

        jmiKeyStoreSetPassword = new JMenuItem(setPasswordAction);
        PlatformUtil.setMnemonic(jmiKeyStoreSetPassword,
                res.getString("KseFrame.jmiSetPassword.mnemonic").charAt(0));
        jmiKeyStoreSetPassword.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyStoreSetPassword,
                (String) setPasswordAction.getValue(Action.LONG_DESCRIPTION), this);
        jpmKeyStore.add(jmiKeyStoreSetPassword);

        jmKeyStoreChangeType = new JMenu(res.getString("KseFrame.jmChangeType.text"));
        jmKeyStoreChangeType.setIcon(new ImageIcon(Toolkit.getDefaultToolkit()
                .createImage(getClass().getResource(res.getString("KseFrame.jmChangeType.image")))));
        PlatformUtil.setMnemonic(jmKeyStoreChangeType, res.getString("KseFrame.jmChangeType.mnemonic").charAt(0));
        jmKeyStoreChangeType.putClientProperty(Options.NO_ICONS_KEY, Boolean.TRUE); // For the benefit of the plastic L&F
        jpmKeyStore.add(jmKeyStoreChangeType);

        jrbmiKeyStoreChangeTypeJks = new JRadioButtonMenuItem(changeTypeJksAction);
        PlatformUtil.setMnemonic(jrbmiKeyStoreChangeTypeJks,
                res.getString("KseFrame.jrbmiChangeTypeJks.mnemonic").charAt(0));
        jrbmiKeyStoreChangeTypeJks.setToolTipText(null);
        new StatusBarChangeHandler(jrbmiKeyStoreChangeTypeJks,
                (String) changeTypeJksAction.getValue(Action.LONG_DESCRIPTION), this);
        jmKeyStoreChangeType.add(jrbmiKeyStoreChangeTypeJks);

        jrbmiKeyStoreChangeTypeJceks = new JRadioButtonMenuItem(changeTypeJceksAction);
        PlatformUtil.setMnemonic(jrbmiKeyStoreChangeTypeJceks,
                res.getString("KseFrame.jrbmiChangeTypeJceks.mnemonic").charAt(0));
        jrbmiKeyStoreChangeTypeJceks.setToolTipText(null);
        new StatusBarChangeHandler(jrbmiKeyStoreChangeTypeJceks,
                (String) changeTypeJceksAction.getValue(Action.LONG_DESCRIPTION), this);
        jmKeyStoreChangeType.add(jrbmiKeyStoreChangeTypeJceks);

        jrbmiKeyStoreChangeTypePkcs12 = new JRadioButtonMenuItem(changeTypePkcs12Action);
        PlatformUtil.setMnemonic(jrbmiKeyStoreChangeTypePkcs12,
                res.getString("KseFrame.jrbmiChangeTypePkcs12.mnemonic").charAt(0));
        jrbmiKeyStoreChangeTypePkcs12.setToolTipText(null);
        new StatusBarChangeHandler(jrbmiKeyStoreChangeTypePkcs12,
                (String) changeTypePkcs12Action.getValue(Action.LONG_DESCRIPTION), this);
        jmKeyStoreChangeType.add(jrbmiKeyStoreChangeTypePkcs12);

        jrbmiKeyStoreChangeTypeBksV1 = new JRadioButtonMenuItem(changeTypeBksV1Action);
        PlatformUtil.setMnemonic(jrbmiKeyStoreChangeTypeBksV1,
                res.getString("KseFrame.jrbmiChangeTypeBksV1.mnemonic").charAt(0));
        jrbmiKeyStoreChangeTypeBksV1.setToolTipText(null);
        new StatusBarChangeHandler(jrbmiKeyStoreChangeTypeBksV1,
                (String) changeTypeBksV1Action.getValue(Action.LONG_DESCRIPTION), this);
        jmKeyStoreChangeType.add(jrbmiKeyStoreChangeTypeBksV1);

        jrbmiKeyStoreChangeTypeBks = new JRadioButtonMenuItem(changeTypeBksAction);
        PlatformUtil.setMnemonic(jrbmiKeyStoreChangeTypeBks,
                res.getString("KseFrame.jrbmiChangeTypeBks.mnemonic").charAt(0));
        jrbmiKeyStoreChangeTypeBks.setToolTipText(null);
        new StatusBarChangeHandler(jrbmiKeyStoreChangeTypeBks,
                (String) changeTypeBksAction.getValue(Action.LONG_DESCRIPTION), this);
        jmKeyStoreChangeType.add(jrbmiKeyStoreChangeTypeBks);

        jrbmiKeyStoreChangeTypeUber = new JRadioButtonMenuItem(changeTypeUberAction);
        PlatformUtil.setMnemonic(jrbmiKeyStoreChangeTypeUber,
                res.getString("KseFrame.jrbmiChangeTypeUber.mnemonic").charAt(0));
        jrbmiKeyStoreChangeTypeUber.setToolTipText(null);
        new StatusBarChangeHandler(jrbmiKeyStoreChangeTypeUber,
                (String) changeTypeUberAction.getValue(Action.LONG_DESCRIPTION), this);
        jmKeyStoreChangeType.add(jrbmiKeyStoreChangeTypeUber);

        ButtonGroup changeTypeGroup = new ButtonGroup();
        changeTypeGroup.add(jrbmiKeyStoreChangeTypeJks);
        changeTypeGroup.add(jrbmiKeyStoreChangeTypeJceks);
        changeTypeGroup.add(jrbmiKeyStoreChangeTypePkcs12);
        changeTypeGroup.add(jrbmiKeyStoreChangeTypeBks);
        changeTypeGroup.add(jrbmiKeyStoreChangeTypeBksV1);
        changeTypeGroup.add(jrbmiKeyStoreChangeTypeUber);

        jmiKeyStoreProperties = new JMenuItem(propertiesAction);
        PlatformUtil.setMnemonic(jmiKeyStoreProperties, res.getString("KseFrame.jmiProperties.mnemonic").charAt(0));
        jmiKeyStoreProperties.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyStoreProperties,
                (String) propertiesAction.getValue(Action.LONG_DESCRIPTION), this);
        jpmKeyStore.add(jmiKeyStoreProperties);
    }

    private void initKeyStoreEntryPopupMenus() {
        jpmKeyPair = new JPopupMenu();

        jmKeyPairDetails = new JMenu(res.getString("KseFrame.jmKeyPairDetails.text"));
        jmKeyPairDetails.setIcon(new ImageIcon(Toolkit.getDefaultToolkit()
                .createImage(getClass().getResource(res.getString("KseFrame.jmKeyPairDetails.image")))));

        jmiKeyPairCertificateChainDetails = new JMenuItem(keyPairCertificateChainDetailsAction);
        jmiKeyPairCertificateChainDetails.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyPairCertificateChainDetails,
                (String) keyPairCertificateChainDetailsAction.getValue(Action.LONG_DESCRIPTION), this);

        jmiKeyPairPrivateKeyDetails = new JMenuItem(keyPairPrivateKeyDetailsAction);
        jmiKeyPairPrivateKeyDetails.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyPairPrivateKeyDetails,
                (String) keyPairPrivateKeyDetailsAction.getValue(Action.LONG_DESCRIPTION), this);

        jmiKeyPairPublicKeyDetails = new JMenuItem(keyPairPublicKeyDetailsAction);
        jmiKeyPairPublicKeyDetails.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyPairPublicKeyDetails,
                (String) keyPairPublicKeyDetailsAction.getValue(Action.LONG_DESCRIPTION), this);

        jmiKeyPairCut = new JMenuItem(cutKeyPairAction);
        jmiKeyPairCut.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyPairCut, (String) cutKeyPairAction.getValue(Action.LONG_DESCRIPTION),
                this);

        jmiKeyPairCopy = new JMenuItem(copyKeyPairAction);
        jmiKeyPairCopy.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyPairCopy, (String) copyKeyPairAction.getValue(Action.LONG_DESCRIPTION),
                this);

        jmKeyPairExport = new JMenu(res.getString("KseFrame.jmKeyPairExport.text"));
        jmKeyPairExport.setIcon(new ImageIcon(Toolkit.getDefaultToolkit()
                .createImage(getClass().getResource(res.getString("KseFrame.jmKeyPairExport.image")))));

        jmiKeyPairExport = new JMenuItem(exportKeyPairAction);
        jmiKeyPairExport.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyPairExport, (String) exportKeyPairAction.getValue(Action.LONG_DESCRIPTION),
                this);

        jmiKeyPairExportCertificateChain = new JMenuItem(exportKeyPairCertificateChainAction);
        jmiKeyPairExportCertificateChain.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyPairExportCertificateChain,
                (String) exportKeyPairCertificateChainAction.getValue(Action.LONG_DESCRIPTION), this);

        jmiKeyPairExportPrivateKey = new JMenuItem(exportKeyPairPrivateKeyAction);
        jmiKeyPairExportPrivateKey.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyPairExportPrivateKey,
                (String) exportKeyPairPrivateKeyAction.getValue(Action.LONG_DESCRIPTION), this);

        jmiKeyPairExportPublicKey = new JMenuItem(exportKeyPairPublicKeyAction);
        jmiKeyPairExportPublicKey.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyPairExportPublicKey,
                (String) exportKeyPairPublicKeyAction.getValue(Action.LONG_DESCRIPTION), this);

        jmiKeyPairGenerateCsr = new JMenuItem(generateCsrAction);
        jmiKeyPairGenerateCsr.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyPairGenerateCsr,
                (String) generateCsrAction.getValue(Action.LONG_DESCRIPTION), this);

        jmKeyPairImportCaReply = new JMenu(res.getString("KseFrame.jmKeyPairImportCaReply.text"));
        jmKeyPairImportCaReply.setIcon(new ImageIcon(Toolkit.getDefaultToolkit()
                .createImage(getClass().getResource(res.getString("KseFrame.jmKeyPairImportCaReply.image")))));

        jmiKeyPairImportCaReplyFile = new JMenuItem(importCaReplyFromFileAction);
        jmiKeyPairImportCaReplyFile.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyPairImportCaReplyFile,
                (String) importCaReplyFromFileAction.getValue(Action.LONG_DESCRIPTION), this);

        jmiKeyPairImportCaReplyClipboard = new JMenuItem(importCaReplyFromClipboardAction);
        jmiKeyPairImportCaReplyClipboard.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyPairImportCaReplyClipboard,
                (String) importCaReplyFromClipboardAction.getValue(Action.LONG_DESCRIPTION), this);

        jmKeyPairEditCertChain = new JMenu(res.getString("KseFrame.jmKeyPairEditCertChain.text"));
        jmKeyPairEditCertChain.setIcon(new ImageIcon(Toolkit.getDefaultToolkit()
                .createImage(getClass().getResource(res.getString("KseFrame.jmKeyPairEditCertChain.image")))));

        jmiKeyPairEditCertChainAppendCert = new JMenuItem(appendToCertificateChainAction);
        jmiKeyPairEditCertChainAppendCert.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyPairEditCertChainAppendCert,
                (String) appendToCertificateChainAction.getValue(Action.LONG_DESCRIPTION), this);

        jmiKeyPairEditCertChainRemoveCert = new JMenuItem(removeFromCertificateChainAction);
        jmiKeyPairEditCertChainRemoveCert.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyPairEditCertChainRemoveCert,
                (String) removeFromCertificateChainAction.getValue(Action.LONG_DESCRIPTION), this);

        jmKeyPairSign = new JMenu(res.getString("KseFrame.jmKeyPairSign.text"));
        jmKeyPairSign.setIcon(new ImageIcon(Toolkit.getDefaultToolkit()
                .createImage(getClass().getResource(res.getString("KseFrame.jmKeyPairSign.image")))));

        jmiKeyPairSignCsr = new JMenuItem(signCsrAction);
        jmiKeyPairSignCsr.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyPairSignCsr, (String) signCsrAction.getValue(Action.LONG_DESCRIPTION),
                this);

        jmiKeyPairSignJar = new JMenuItem(signJarAction);
        jmiKeyPairSignJar.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyPairSignJar, (String) signJarAction.getValue(Action.LONG_DESCRIPTION),
                this);

        jmiKeyPairSignMidlet = new JMenuItem(signMidletAction);
        jmiKeyPairSignMidlet.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyPairSignMidlet,
                (String) signMidletAction.getValue(Action.LONG_DESCRIPTION), this);

        jmiKeyPairSignNewKeyPair = new JMenuItem(signNewKeyPairAction);
        jmiKeyPairSignNewKeyPair.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyPairSignNewKeyPair,
                (String) signNewKeyPairAction.getValue(Action.LONG_DESCRIPTION), this);

        jmiKeyPairUnlock = new JMenuItem(unlockKeyPairAction);
        jmiKeyPairUnlock.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyPairUnlock, (String) unlockKeyPairAction.getValue(Action.LONG_DESCRIPTION),
                this);

        jmiKeyPairSetPassword = new JMenuItem(setKeyPairPasswordAction);
        jmiKeyPairSetPassword.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyPairSetPassword,
                (String) setKeyPairPasswordAction.getValue(Action.LONG_DESCRIPTION), this);

        jmiKeyPairDelete = new JMenuItem(deleteKeyPairAction);
        jmiKeyPairDelete.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyPairDelete, (String) deleteKeyPairAction.getValue(Action.LONG_DESCRIPTION),
                this);

        jmiKeyPairRename = new JMenuItem(renameKeyPairAction);
        jmiKeyPairRename.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyPairRename, (String) renameKeyPairAction.getValue(Action.LONG_DESCRIPTION),
                this);

        jpmKeyPair.add(jmKeyPairDetails);
        jmKeyPairDetails.add(jmiKeyPairCertificateChainDetails);
        jmKeyPairDetails.add(jmiKeyPairPrivateKeyDetails);
        jmKeyPairDetails.add(jmiKeyPairPublicKeyDetails);
        jpmKeyPair.addSeparator();
        jpmKeyPair.add(jmiKeyPairCut);
        jpmKeyPair.add(jmiKeyPairCopy);
        jpmKeyPair.addSeparator();
        jpmKeyPair.add(jmKeyPairExport);
        jmKeyPairExport.add(jmiKeyPairExport);
        jmKeyPairExport.add(jmiKeyPairExportCertificateChain);
        jmKeyPairExport.add(jmiKeyPairExportPrivateKey);
        jmKeyPairExport.add(jmiKeyPairExportPublicKey);
        jpmKeyPair.add(jmiKeyPairGenerateCsr);
        jpmKeyPair.add(jmKeyPairImportCaReply);
        jmKeyPairImportCaReply.add(jmiKeyPairImportCaReplyFile);
        jmKeyPairImportCaReply.add(jmiKeyPairImportCaReplyClipboard);
        jpmKeyPair.add(jmKeyPairEditCertChain);
        jmKeyPairEditCertChain.add(jmiKeyPairEditCertChainAppendCert);
        jmKeyPairEditCertChain.add(jmiKeyPairEditCertChainRemoveCert);
        jpmKeyPair.addSeparator();
        jpmKeyPair.add(jmKeyPairSign);
        jmKeyPairSign.add(jmiKeyPairSignNewKeyPair);
        jmKeyPairSign.add(jmiKeyPairSignCsr);
        jmKeyPairSign.add(jmiKeyPairSignJar);
        jmKeyPairSign.add(jmiKeyPairSignMidlet);
        jpmKeyPair.addSeparator();
        jpmKeyPair.add(jmiKeyPairUnlock);
        jpmKeyPair.add(jmiKeyPairSetPassword);
        jpmKeyPair.add(jmiKeyPairDelete);
        jpmKeyPair.add(jmiKeyPairRename);

        jpmTrustedCertificate = new JPopupMenu();

        jmTrustedCertificateDetails = new JMenu(res.getString("KseFrame.jmTrustedCertificateDetails.text"));
        jmTrustedCertificateDetails.setIcon(new ImageIcon(Toolkit.getDefaultToolkit()
                .createImage(getClass().getResource(res.getString("KseFrame.jmTrustedCertificateDetails.image")))));

        jmiTrustedCertificateDetails = new JMenuItem(trustedCertificateDetailsAction);
        jmiTrustedCertificateDetails.setToolTipText(null);
        new StatusBarChangeHandler(jmiTrustedCertificateDetails,
                (String) trustedCertificateDetailsAction.getValue(Action.LONG_DESCRIPTION), this);

        jmiTrustedCertificatePublicKeyDetails = new JMenuItem(trustedCertificatePublicKeyDetailsAction);
        jmiTrustedCertificatePublicKeyDetails.setToolTipText(null);
        new StatusBarChangeHandler(jmiTrustedCertificatePublicKeyDetails,
                (String) trustedCertificatePublicKeyDetailsAction.getValue(Action.LONG_DESCRIPTION), this);

        jmiTrustedCertificateCut = new JMenuItem(cutTrustedCertificateAction);
        jmiTrustedCertificateCut.setToolTipText(null);
        new StatusBarChangeHandler(jmiTrustedCertificateCut,
                (String) cutTrustedCertificateAction.getValue(Action.LONG_DESCRIPTION), this);

        jmiTrustedCertificateCopy = new JMenuItem(copyTrustedCertificateAction);
        jmiTrustedCertificateCopy.setToolTipText(null);
        new StatusBarChangeHandler(jmiTrustedCertificateCopy,
                (String) copyTrustedCertificateAction.getValue(Action.LONG_DESCRIPTION), this);

        jmTrustedCertificateExport = new JMenu(res.getString("KseFrame.jmTrustedCertificateExport.text"));
        jmTrustedCertificateExport.setIcon(new ImageIcon(Toolkit.getDefaultToolkit()
                .createImage(getClass().getResource(res.getString("KseFrame.jmTrustedCertificateExport.image")))));

        jmiTrustedCertificateExport = new JMenuItem(exportTrustedCertificateAction);
        jmiTrustedCertificateExport.setToolTipText(null);
        new StatusBarChangeHandler(jmiTrustedCertificateExport,
                (String) exportTrustedCertificateAction.getValue(Action.LONG_DESCRIPTION), this);

        jmiTrustedCertificateExportPublicKey = new JMenuItem(exportTrustedCertificatePublicKeyAction);
        jmiTrustedCertificateExportPublicKey.setToolTipText(null);
        new StatusBarChangeHandler(jmiTrustedCertificateExportPublicKey,
                (String) exportTrustedCertificatePublicKeyAction.getValue(Action.LONG_DESCRIPTION), this);

        jmiTrustedCertificateDelete = new JMenuItem(deleteTrustedCertificateAction);
        jmiTrustedCertificateDelete.setToolTipText(null);
        new StatusBarChangeHandler(jmiTrustedCertificateDelete,
                (String) deleteTrustedCertificateAction.getValue(Action.LONG_DESCRIPTION), this);

        jmiTrustedCertificateRename = new JMenuItem(renameTrustedCertificateAction);
        jmiTrustedCertificateRename.setToolTipText(null);
        new StatusBarChangeHandler(jmiTrustedCertificateRename,
                (String) renameTrustedCertificateAction.getValue(Action.LONG_DESCRIPTION), this);

        jpmTrustedCertificate.add(jmTrustedCertificateDetails);
        jmTrustedCertificateDetails.add(jmiTrustedCertificateDetails);
        jmTrustedCertificateDetails.add(jmiTrustedCertificatePublicKeyDetails);
        jpmTrustedCertificate.addSeparator();
        jpmTrustedCertificate.add(jmiTrustedCertificateCut);
        jpmTrustedCertificate.add(jmiTrustedCertificateCopy);
        jpmTrustedCertificate.addSeparator();
        jpmTrustedCertificate.add(jmTrustedCertificateExport);
        jmTrustedCertificateExport.add(jmiTrustedCertificateExport);
        jmTrustedCertificateExport.add(jmiTrustedCertificateExportPublicKey);
        jpmTrustedCertificate.addSeparator();
        jpmTrustedCertificate.add(jmiTrustedCertificateDelete);
        jpmTrustedCertificate.add(jmiTrustedCertificateRename);

        jpmKey = new JPopupMenu();

        jmiKeyDetails = new JMenuItem(keyDetailsAction);
        jmiKeyDetails.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyDetails, (String) keyDetailsAction.getValue(Action.LONG_DESCRIPTION),
                this);

        jmiKeyUnlock = new JMenuItem(unlockKeyAction);
        jmiKeyUnlock.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyUnlock, (String) unlockKeyAction.getValue(Action.LONG_DESCRIPTION), this);

        jmiKeySetPassword = new JMenuItem(setKeyPasswordAction);
        jmiKeySetPassword.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeySetPassword,
                (String) setKeyPasswordAction.getValue(Action.LONG_DESCRIPTION), this);

        jmiKeyDelete = new JMenuItem(deleteKeyAction);
        jmiKeyDelete.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyDelete, (String) deleteKeyAction.getValue(Action.LONG_DESCRIPTION), this);

        jmiKeyRename = new JMenuItem(renameKeyAction);
        jmiKeyRename.setToolTipText(null);
        new StatusBarChangeHandler(jmiKeyRename, (String) renameKeyAction.getValue(Action.LONG_DESCRIPTION), this);

        jpmKey.add(jmiKeyDetails);
        jpmKey.addSeparator();
        jpmKey.add(jmiKeyUnlock);
        jpmKey.add(jmiKeySetPassword);
        jpmKey.add(jmiKeyDelete);
        jpmKey.add(jmiKeyRename);
    }

    private void maybeShowSelectedEntryDetails(MouseEvent evt) {
        // Check if a double click occurred on the KeyStore table. If it has
        // show the relevant details of the entry clicked upon
        if (evt.getClickCount() > 1) {
            JTable jtKeyStore = (JTable) evt.getComponent();

            Point point = new Point(evt.getX(), evt.getY());
            int row = jtKeyStore.rowAtPoint(point);

            if (row != -1) {
                try {
                    CursorUtil.setCursorBusy(frame);
                    showSelectedEntryDetails(jtKeyStore, row);
                } finally {
                    CursorUtil.setCursorFree(frame);
                }
            }
        }
    }

    private void showSelectedEntryDetails(JTable jtKeyStore, int row) {
        jtKeyStore.setRowSelectionInterval(row, row);
        updateCutCopyPasteControls(); // Selection changed - update edit controls

        KeyStoreHistory history = getActiveKeyStoreHistory();
        KeyStore keyStore = history.getCurrentState().getKeyStore();
        String alias = getSelectedEntryAlias();

        try {
            if (KeyStoreUtil.isKeyPairEntry(alias, keyStore)) {
                keyPairCertificateChainDetailsAction.showCertificateSelectedEntry();
            } else if (KeyStoreUtil.isTrustedCertificateEntry(alias, keyStore)) {
                trustedCertificateDetailsAction.showCertificateSelectedEntry();
            } else if (KeyStoreUtil.isKeyEntry(alias, keyStore)) {
                keyDetailsAction.showKeySelectedEntry();
            }
        } catch (Exception ex) {
            DError.displayError(frame, ex);
        }
    }

    private void maybeShowSelectedEntryPopupMenu(MouseEvent evt) {

        JTable jtKeyStore = (JTable) evt.getComponent();

        Point point = new Point(evt.getX(), evt.getY());
        int row = jtKeyStore.rowAtPoint(point);

        KeyStoreType type = KeyStoreType
                .resolveJce(getActiveKeyStoreHistory().getCurrentState().getKeyStore().getType());

        if (evt.isPopupTrigger()) {

            if (row != -1) {

                jtKeyStore.setRowSelectionInterval(row, row);

                if (jtKeyStore.getValueAt(row, 0).equals(KeyStoreTableModel.KEY_PAIR_ENTRY)) {

                    // For KeyStore types that support password protected entries...
                    if (type.hasEntryPasswords()) {
                        // Only allow unlocking from menu if entry is currently locked
                        boolean locked = ((Boolean) jtKeyStore.getValueAt(row, 1)).booleanValue();
                        unlockKeyPairAction.setEnabled(locked);
                    }

                    jpmKeyPair.show(evt.getComponent(), evt.getX(), evt.getY());

                } else if (jtKeyStore.getValueAt(row, 0).equals(KeyStoreTableModel.TRUST_CERT_ENTRY)) {

                    jpmTrustedCertificate.show(evt.getComponent(), evt.getX(), evt.getY());

                } else if (jtKeyStore.getValueAt(row, 0).equals(KeyStoreTableModel.KEY_ENTRY)) {

                    // For KeyStore types that support password protected entries...
                    if (type.hasEntryPasswords()) {
                        // Only allow unlocking from menu if entry is currently locked
                        boolean locked = ((Boolean) jtKeyStore.getValueAt(row, 1)).booleanValue();
                        unlockKeyAction.setEnabled(locked);
                    }

                    jpmKey.show(evt.getComponent(), evt.getX(), evt.getY());
                }
            } else {
                jpmKeyStore.show(evt.getComponent(), evt.getX(), evt.getY());
            }
        } else if (evt.getClickCount() > 1 && row == -1) {
            // double click on free space opens generate key pair dialog
            generateKeyPairAction.generateKeyPair();
        }

        // Selection changed - update edit controls
        updateCutCopyPasteControls();
    }

    private void maybeShowKeyStoreTabPopup(MouseEvent evt) {
        if (evt.isPopupTrigger()) {
            int tabCount = jkstpKeyStores.getTabCount();
            TabbedPaneUI tpu = jkstpKeyStores.getUI();

            for (int i = 0; i < tabCount; i++) {
                Rectangle rect = tpu.getTabBounds(jkstpKeyStores, i);

                int x = evt.getX();
                int y = evt.getY();

                if (x < rect.x || x > rect.x + rect.width || y < rect.y || y > rect.y + rect.height) {
                    continue;
                }

                jpmKeyStoreTab.show(evt.getComponent(), evt.getX(), evt.getY());
                break;
            }
        }
    }

    /**
     * Add a KeyStore to the set of loaded KeyStores.
     *
     * @param keyStore
     *            KeyStore
     * @param keyStoreName
     *            KeyStore name
     * @param password
     *            KeyStore password
     * @param explicitProvider
     *            Explicitly specify a provider that is used for this keystore
     */
    public void addKeyStore(KeyStore keyStore, String keyStoreName, Password password, Provider explicitProvider) {
        KeyStoreHistory history = new KeyStoreHistory(keyStore, keyStoreName, password, explicitProvider);

        addKeyStoreHistory(history);
    }

    /**
     * Add a KeyStore to the set of loaded KeyStores.
     *
     * @param keyStore
     *            KeyStore
     * @param keyStoreFile
     *            KeyStore file
     * @param password
     *            KeyStore password
     */
    public void addKeyStore(KeyStore keyStore, File keyStoreFile, Password password) {
        KeyStoreHistory history = new KeyStoreHistory(keyStore, keyStoreFile, password);

        addKeyStoreHistory(history);
    }

    private void addKeyStoreHistory(KeyStoreHistory history) {
        histories.add(history);

        JTable jtKeyStore = createEmptyKeyStoreTable();
        keyStoreTables.add(jtKeyStore);

        JScrollPane jspKeyStore = wrapKeyStoreTableInScrollPane(jtKeyStore);

        KeyStoreTab keyStoreTab = new KeyStoreTab(history.getName(), this, history);
        jkstpKeyStores.addTab(null, jspKeyStore);
        jkstpKeyStores.setTabComponentAt(jkstpKeyStores.getTabCount() - 1, keyStoreTab);
        jkstpKeyStores.setSelectedIndex(jkstpKeyStores.getTabCount() - 1);

        updateControls(true);

        // If KeyStore is backed up by a file add it to the recent files menu
        if (history.getFile() != null) {
            jmrfRecentFiles.add(createRecentFileMenuItem(jmrfRecentFiles, history.getFile()));
        }
    }

    /**
     * Removed the supplied KeyStore from the set of loaded KeyStores.
     *
     * @param keyStore
     *            KeyStore
     */
    public void removeKeyStore(KeyStore keyStore) {
        int index = findKeyStoreIndex(keyStore);

        if (index >= 0) {
            keyStoreTables.remove(index);
            histories.remove(index).nullPasswords();
            jkstpKeyStores.remove(index);
        }
    }

    /**
     * Find the supplied KeyStore in the set of loaded KeyStores.
     *
     * @param keyStore
     *            KeyStore to find
     * @return The KeyStore's index
     */
    public int findKeyStoreIndex(KeyStore keyStore) {
        for (int i = 0; i < histories.size(); i++) {
            if (keyStore.equals(histories.get(i).getCurrentState().getKeyStore())) {
                return i;
            }
        }

        return -1;
    }

    /**
     * Get the active KeyStore.
     *
     * @return The KeyStore or null if no KeyStore is active
     */
    public KeyStore getActiveKeyStore() {
        KeyStoreHistory history = getActiveKeyStoreHistory();
        if (history == null) {
            return null;
        }

        KeyStoreState currentState = history.getCurrentState();
        KeyStore keyStore = currentState.getKeyStore();
        return keyStore;
    }

    /**
     * Get the active KeyStore history.
     *
     * @return The KeyStore history or null if no KeyStore is active
     */
    public KeyStoreHistory getActiveKeyStoreHistory() {
        if (histories.size() == 0) {
            return null;
        }

        int selected = jkstpKeyStores.getSelectedIndex();
        return histories.get(selected);
    }

    /**
     * Get all loaded KeyStore histories in display order.
     *
     * @return KeyStore histories
     */
    public KeyStoreHistory[] getKeyStoreHistories() {
        return histories.toArray(new KeyStoreHistory[histories.size()]);
    }

    /**
     * Focus on the supplied KeyStore.
     *
     * @param keyStore
     *            KeyStore
     */
    public void focusOnKeyStore(KeyStore keyStore) {
        int index = findKeyStoreIndex(keyStore);

        if (index >= 0) {
            jkstpKeyStores.setSelectedIndex(index);
        }
    }

    private JTable getActiveKeyStoreTable() {
        if (keyStoreTables.size() == 0) {
            return null;
        }

        int selected = jkstpKeyStores.getSelectedIndex();
        return keyStoreTables.get(selected);
    }

    /**
     * Get a the selected entry as a drag entry for DnD.
     *
     * @return Drag entry or null if entry could not be dragged
     */
    public DragEntry dragSelectedEntry() {
        try {
            KeyStoreHistory history = getActiveKeyStoreHistory();

            if (history == null) {
                return null; // No KeyStore to drag from
            }

            KeyStoreState currentState = history.getCurrentState();
            KeyStore keyStore = currentState.getKeyStore();
            String alias = getSelectedEntryAlias();

            if (alias == null) {
                return null; // No selected entry to drag
            }

            if (KeyStoreUtil.isKeyEntry(alias, keyStore)) {
                JOptionPane.showMessageDialog(frame, res.getString("KseFrame.NoDragKeyEntry.message"),
                        KSE.getApplicationName(), JOptionPane.WARNING_MESSAGE);
                return null;
            }

            if (KeyStoreUtil.isKeyPairEntry(alias, keyStore)) {

                // Otherwise entry must already be unlocked to get password
                Password password = currentState.getEntryPassword(alias);
                KeyStoreType type = KeyStoreType.resolveJce(keyStore.getType());

                if (password == null && type.hasEntryPasswords()) {
                    JOptionPane.showMessageDialog(frame, res.getString("KseFrame.NoDragLockedKeyPairEntry.message"),
                            KSE.getApplicationName(), JOptionPane.WARNING_MESSAGE);
                    return null;
                }

                PrivateKey privateKey = (PrivateKey) keyStore.getKey(alias, password.toCharArray());
                Certificate[] certificateChain = keyStore.getCertificateChain(alias);

                return new DragKeyPairEntry(alias, privateKey, password, certificateChain);
            } else {
                Certificate trustedCertificate = keyStore.getCertificate(alias);
                return new DragTrustedCertificateEntry(alias, trustedCertificate);
            }
        } catch (Exception ex) {
            DError.displayError(frame, ex);
            return null;
        }
    }

    /**
     * Get the alias of the entry currently selected in the KeyStore table if
     * any.
     *
     * @return Alias or null if none selected
     */
    public String getSelectedEntryAlias() {
        JTable jtKeyStore = getActiveKeyStoreTable();
        int row = jtKeyStore.getSelectedRow();

        if (row == -1) {
            return null;
        }

        String alias = (String) jtKeyStore.getValueAt(row, 3);
        return alias;
    }

    private void setSelectedEntryByAlias(String alias) {
        JTable jtKeyStore = getActiveKeyStoreTable();

        for (int i = 0; i < jtKeyStore.getRowCount(); i++) {
            if (alias.equals(jtKeyStore.getValueAt(i, 3))) {
                jtKeyStore.setRowSelectionInterval(i, i);
                break;
            }
        }
    }

    /**
     * Update the frame's controls dependent on the state of its open and active
     * KeyStores.
     *
     * @param keyStoreContentsChanged
     *            Have the active KeyStore's contents changed?
     */
    public void updateControls(boolean keyStoreContentsChanged) {
        KeyStoreHistory history = getActiveKeyStoreHistory();

        if (history == null) {
            updateControlsNoKeyStoresOpen();
            return;
        }

        KeyStoreState currentState = history.getCurrentState();

        // Reload KeyStore in table if it has changed
        if (keyStoreContentsChanged) {
            try {
                String selectedAlias = getSelectedEntryAlias();

                ((KeyStoreTableModel) getActiveKeyStoreTable().getModel()).load(history);

                // Loading the model loses the selected entry - preserve it
                if (selectedAlias != null) {
                    setSelectedEntryByAlias(selectedAlias);
                }
            } catch (GeneralSecurityException ex) {
                DError.displayError(frame, ex);
            } catch (CryptoException ex) {
                DError.displayError(frame, ex);
            }
        }

        // Can save if active KeyStore has not been saved
        if (!currentState.isSavedState()) {
            saveAction.setEnabled(true);
        } else {
            saveAction.setEnabled(false);
        }

        // Can save all if any KeyStore has been changed since saved
        boolean saveAll = false;
        for (int i = 0; i < histories.size(); i++) {
            KeyStoreHistory h = histories.get(i);

            if (!h.getCurrentState().isSavedState()) {
                saveAll = true; // Yes - can Save All
                break;
            }
        }

        saveAllAction.setEnabled(saveAll);

        // Can close
        closeAction.setEnabled(true);
        closeAllAction.setEnabled(true);

        // Can close others?
        if (jkstpKeyStores.getTabCount() > 1) {
            closeOthersAction.setEnabled(true);
        } else {
            closeOthersAction.setEnabled(false);
        }

        KeyStore keyStore = currentState.getKeyStore();
        KeyStoreType type = KeyStoreType.resolveJce(keyStore.getType());

        // Can Save As
        if (type.isFileBased()) {
            saveAsAction.setEnabled(true);
        }

        // May be able to undo/redo
        updateUndoRedoControls(currentState);

        // May be able to cut/copy/paste
        if (type.isFileBased()) {
            updateCutCopyPasteControls();
        }

        // Can use tools on
        generateKeyPairAction.setEnabled(true);
        generateSecretKeyAction.setEnabled(type.supportsKeyEntries());
        importTrustedCertificateAction.setEnabled(true);
        importKeyPairAction.setEnabled(true);
        propertiesAction.setEnabled(true);
        if (type.isFileBased()) {
            setPasswordAction.setEnabled(true);
        }

        // Show default status bar display
        setDefaultStatusBarText();

        // Passwords, and therefore unlocking, are not relevant for PKCS #12 or KeyStores that are not file-based
        if (!type.hasEntryPasswords() || !type.isFileBased()) {
            unlockKeyPairAction.setEnabled(false);
            setKeyPairPasswordAction.setEnabled(false);
            unlockKeyAction.setEnabled(false);
            setKeyPasswordAction.setEnabled(false);
        } else {
            unlockKeyPairAction.setEnabled(true);
            setKeyPairPasswordAction.setEnabled(true);
            unlockKeyAction.setEnabled(true);
            setKeyPasswordAction.setEnabled(true);
        }

        // Special restrictions for MSCAPI and PKCS#11 type
        if (type == KeyStoreType.MS_CAPI_PERSONAL || type == KeyStoreType.PKCS11) {

            keyPairPrivateKeyDetailsAction.setEnabled(false);
            keyDetailsAction.setEnabled(false);

            renameKeyAction.setEnabled(false);
            renameKeyPairAction.setEnabled(false);
            renameTrustedCertificateAction.setEnabled(false);

            exportKeyPairAction.setEnabled(false);
            exportKeyPairPrivateKeyAction.setEnabled(false);

            jmKeyPairEditCertChain.setEnabled(false);
            appendToCertificateChainAction.setEnabled(false);
            removeFromCertificateChainAction.setEnabled(false);

            // "UnsupportedOperationException" ...
            jmKeyPairImportCaReply.setEnabled(false);
        } else {
            keyPairPrivateKeyDetailsAction.setEnabled(true);
            keyDetailsAction.setEnabled(true);

            renameKeyAction.setEnabled(true);
            renameKeyPairAction.setEnabled(true);
            renameTrustedCertificateAction.setEnabled(true);

            exportKeyPairAction.setEnabled(true);
            exportKeyPairPrivateKeyAction.setEnabled(true);

            jmKeyPairEditCertChain.setEnabled(true);
            appendToCertificateChainAction.setEnabled(true);
            removeFromCertificateChainAction.setEnabled(true);

            jmKeyPairImportCaReply.setEnabled(true);
        }

        // KeyStore type menu items
        if (type.isFileBased()) {
            jmChangeType.setEnabled(true);

            if (type == JKS) {
                jrbmiChangeTypeJks.setSelected(true);
                jrbmiKeyStoreChangeTypeJks.setSelected(true);
            } else if (type == HTKS) {
                jrbmiChangeTypeJks.setSelected(true);
                jrbmiKeyStoreChangeTypeJks.setSelected(true);
            } else if (type == JCEKS) {
                jrbmiChangeTypeJceks.setSelected(true);
                jrbmiKeyStoreChangeTypeJceks.setSelected(true);
            } else if (type == PKCS12) {
                jrbmiChangeTypePkcs12.setSelected(true);
                jrbmiKeyStoreChangeTypePkcs12.setSelected(true);
            } else if (type == BKS_V1) {
                jrbmiChangeTypeBksV1.setSelected(true);
                jrbmiKeyStoreChangeTypeBksV1.setSelected(true);
            } else if (type == BKS) {
                jrbmiChangeTypeBks.setSelected(true);
                jrbmiKeyStoreChangeTypeBks.setSelected(true);
            } else {
                jrbmiChangeTypeUber.setSelected(true);
                jrbmiKeyStoreChangeTypeUber.setSelected(true);
            }
        } else {
            jmKeyStoreChangeType.setEnabled(false);
        }

        // Show KeyStores tabbed pane
        frame.getContentPane().remove(jQuickStart);
        frame.getContentPane().add(jkstpKeyStores, BorderLayout.CENTER);

        updateKeyStoreTabsText();
        updateApplicationTitle();

        frame.repaint();
    }

    private void updateControlsNoKeyStoresOpen() {
        // Nothing to close
        closeAction.setEnabled(false);
        closeOthersAction.setEnabled(false);
        closeAllAction.setEnabled(false);

        // Nothing to save
        saveAction.setEnabled(false);
        saveAsAction.setEnabled(false);
        saveAllAction.setEnabled(false);

        // Nothing to undo/redo
        undoAction.setEnabled(false);
        redoAction.setEnabled(false);

        // Nothing to cut/copy/paste
        cutAction.setEnabled(false);
        cutKeyPairAction.setEnabled(false);
        cutTrustedCertificateAction.setEnabled(false);
        copyAction.setEnabled(false);
        copyKeyPairAction.setEnabled(false);
        copyTrustedCertificateAction.setEnabled(false);
        pasteAction.setEnabled(false);

        // Nothing to use tools on
        generateKeyPairAction.setEnabled(false);
        generateSecretKeyAction.setEnabled(false);
        importTrustedCertificateAction.setEnabled(false);
        importKeyPairAction.setEnabled(false);
        setPasswordAction.setEnabled(false);
        jmChangeType.setEnabled(false);
        propertiesAction.setEnabled(false);

        // No current KeyStore type
        jrbmiChangeTypeJks.setSelected(false);
        jrbmiChangeTypeJceks.setSelected(false);
        jrbmiChangeTypePkcs12.setSelected(false);
        jrbmiChangeTypeBks.setSelected(false);
        jrbmiChangeTypeBksV1.setSelected(false);
        jrbmiChangeTypeUber.setSelected(false);
        jrbmiKeyStoreChangeTypeJks.setSelected(false);
        jrbmiKeyStoreChangeTypeJceks.setSelected(false);
        jrbmiKeyStoreChangeTypePkcs12.setSelected(false);
        jrbmiKeyStoreChangeTypeBks.setSelected(false);
        jrbmiKeyStoreChangeTypeBksV1.setSelected(false);
        jrbmiKeyStoreChangeTypeUber.setSelected(false);

        // Show Quick Start pane
        frame.getContentPane().remove(jkstpKeyStores);
        frame.getContentPane().add(jQuickStart, BorderLayout.CENTER);

        updateApplicationTitle();

        setDefaultStatusBarText();

        frame.repaint();
    }

    private void updateUndoRedoControls(KeyStoreState state) {
        undoAction.setEnabled(state.hasPreviousState());
        redoAction.setEnabled(state.hasNextState());
    }

    private void updateCutCopyPasteControls() {
        // Can cut and copy if a KeyStore entry is selected
        boolean cutAndCopyEnabled = getActiveKeyStoreTable().getSelectedRow() != -1;

        cutAction.setEnabled(cutAndCopyEnabled);
        cutKeyPairAction.setEnabled(cutAndCopyEnabled);
        cutTrustedCertificateAction.setEnabled(cutAndCopyEnabled);
        copyAction.setEnabled(cutAndCopyEnabled);
        copyKeyPairAction.setEnabled(cutAndCopyEnabled);
        copyTrustedCertificateAction.setEnabled(cutAndCopyEnabled);

        // Can paste if anything is in buffer
        pasteAction.setEnabled(Buffer.isPopulated());
    }

    private void updateKeyStoreTabsText() {
        for (int i = 0; i < histories.size(); i++) {
            KeyStoreHistory history = histories.get(i);

            KeyStoreTab keyStoreTab = (KeyStoreTab) jkstpKeyStores.getTabComponentAt(i);

            // Tab component may not be available yet
            if (keyStoreTab != null) {
                if (!history.getCurrentState().isSavedState()) {
                    // Unsaved Changes - append '*'
                    String title = MessageFormat.format("{0} *", history.getName());
                    keyStoreTab.updateTitle(title);
                } else {
                    String title = history.getName();
                    keyStoreTab.updateTitle(title);
                }

                // Set tooltip text to be the same as is displayed for the
                // KeyStore's status bar text
                jkstpKeyStores.setToolTipTextAt(i, getKeyStoreStatusText(history));
            }
        }
    }

    private void updateApplicationTitle() {
        // Title: "[KeyStore Name [*] - ] Application Name and Version"

        String appName = MessageFormat.format("{0} {1}", KSE.getApplicationName(), KSE.getApplicationVersion());

        KeyStoreHistory history = getActiveKeyStoreHistory();

        if (history == null) {
            frame.setTitle(appName);
        } else {
            String keyStoreName = history.getName();

            if (!history.getCurrentState().isSavedState()) {
                frame.setTitle(MessageFormat.format("{0} * - {1}", keyStoreName, appName));
            } else {
                frame.setTitle(MessageFormat.format("{0} - {1}", keyStoreName, appName));
            }
        }
    }

    /**
     * Display the supplied text in the status bar.
     *
     * @param status
     *            Text to display
     */
    @Override
    public void setStatusBarText(String status) {
        jlStatusBar.setText(status);
    }

    /**
     * Set the text in the status bar to reflect the status of the active
     * KeyStore.
     */
    @Override
    public void setDefaultStatusBarText() {
        KeyStoreHistory history = getActiveKeyStoreHistory();

        if (history == null) {
            setStatusBarText(res.getString("KseFrame.noKeyStore.statusbar"));
        } else {
            setStatusBarText(getKeyStoreStatusText(history));
        }
    }

    private String getKeyStoreStatusText(KeyStoreHistory history) {
        // Status Text: 'KeyStore Type, Size, Path'
        KeyStoreState currentState = history.getCurrentState();

        KeyStore ksLoaded = currentState.getKeyStore();

        int size;
        try {
            size = ksLoaded.size();
        } catch (KeyStoreException ex) {
            DError.displayError(frame, ex);
            return "";
        }

        KeyStoreType keyStoreType = currentState.getType();

        return MessageFormat.format(res.getString("KseFrame.entries.statusbar"), keyStoreType.friendly(), size,
                history.getPath());
    }

    /**
     * Get frame's size and position. Used to get size on exit.
     *
     * @param keyStoresClosed
     *            Were all KeyStores closed on exit?
     * @return Size and position
     */
    public Rectangle getSizeAndPosition(boolean keyStoresClosed) {
        Rectangle sizeAndPosition = new Rectangle();

        if (keyStoresClosed) {
            sizeAndPosition.width = jkstpKeyStores.getWidth();
            sizeAndPosition.height = jkstpKeyStores.getHeight();
        } else {
            sizeAndPosition.width = jQuickStart.getWidth();
            sizeAndPosition.height = jQuickStart.getHeight();
        }

        sizeAndPosition.x = frame.getX();
        sizeAndPosition.y = frame.getY();

        return sizeAndPosition;
    }

    /**
     * Get recently opened files.
     *
     * @return Recently opened files
     */
    public File[] getRecentFiles() {
        return jmrfRecentFiles.getRecentFiles();
    }

    /**
     * Add a file to the top of the recently opened files.
     *
     * @param recentFile
     *            Recent file
     */
    public void addRecentFile(File recentFile) {
        jmrfRecentFiles.add(createRecentFileMenuItem(jmrfRecentFiles, recentFile));
    }

    /**
     * Set tab layout policy - must be one of JTabbedPane.WRAP_TAB_LAYOUT or
     * JTabbedPane.SCROLL_TAB_LAYOUT to take effect.
     *
     * @param tabLayoutPolicy
     *            Tab layout policy
     */
    public void setKeyStoreTabLayoutPolicy(int tabLayoutPolicy) {
        if (tabLayoutPolicy == JTabbedPane.WRAP_TAB_LAYOUT || tabLayoutPolicy == JTabbedPane.SCROLL_TAB_LAYOUT) {
            jkstpKeyStores.setTabLayoutPolicy(tabLayoutPolicy);
            applicationSettings.setTabLayout(tabLayoutPolicy);
        }
    }

    /**
     * If the tool bar is currently displayed hide it and vice versa.
     */
    public void showHideToolBar() {
        Container contentPane = frame.getContentPane();
        boolean toolBarShown = false;
        for (int i = 0; i < contentPane.getComponentCount(); i++) {
            if (contentPane.getComponent(i).equals(jtbToolBar)) {
                toolBarShown = true;
                break;
            }
        }

        if (toolBarShown) {
            frame.getContentPane().remove(jtbToolBar);
            applicationSettings.setShowToolBar(false);
        } else {
            frame.getContentPane().add(jtbToolBar, BorderLayout.NORTH);
            applicationSettings.setShowToolBar(true);
        }
    }

    /**
     * If the status bar is currently displayed hide it and vice versa.
     */
    public void showHideStatusBar() {
        Container contentPane = frame.getContentPane();
        boolean statusBarShown = false;
        for (int i = 0; i < contentPane.getComponentCount(); i++) {
            if (contentPane.getComponent(i).equals(jlStatusBar)) {
                statusBarShown = true;
                break;
            }
        }

        if (statusBarShown) {
            frame.getContentPane().remove(jlStatusBar);
            applicationSettings.setShowStatusBar(false);
        } else {
            frame.getContentPane().add(jlStatusBar, BorderLayout.SOUTH);
            applicationSettings.setShowStatusBar(true);
        }
    }
}