Example usage for java.awt.event MouseAdapter MouseAdapter

List of usage examples for java.awt.event MouseAdapter MouseAdapter

Introduction

In this page you can find the example usage for java.awt.event MouseAdapter MouseAdapter.

Prototype

MouseAdapter

Source Link

Usage

From source file:com.mirth.connect.client.ui.editors.filter.FilterPane.java

public void makeFilterTable() {
    filterTable = new MirthTable();

    filterTable.setModel(new DefaultTableModel(new String[] { "#", "Operator", "Name", "Type", "Data" }, 0) {

        public boolean isCellEditable(int rowIndex, int columnIndex) {
            boolean[] canEdit;
            FilterRulePlugin plugin;//from  www  . j  av  a  2 s.  co  m
            try {
                plugin = getPlugin((String) filterTableModel.getValueAt(rowIndex, RULE_TYPE_COL));
                canEdit = new boolean[] { false, true, plugin.isNameEditable(), true, true };
            } catch (Exception e) {
                canEdit = new boolean[] { false, true, true, true, true };
            }
            return canEdit[columnIndex];
        }
    });

    filterTable.putClientProperty("terminateEditOnFocusLost", Boolean.TRUE);

    filterTableModel = (DefaultTableModel) filterTable.getModel();

    filterTable.getColumnModel().getColumn(RULE_NAME_COL).setCellEditor(new EditorTableCellEditor(this));
    filterTable.setCustomEditorControls(true);

    // Set the combobox editor on the operator column, and add action
    // listener
    MirthComboBoxTableCellEditor comboBoxOp = new MirthComboBoxTableCellEditor(filterTable, comboBoxValues, 2,
            true, new ActionListener() {

                @Override
                public void actionPerformed(ActionEvent e) {
                    modified = true;
                    updateOperations();
                }
            });

    // Set the combobox editor on the type column, and add action listener
    String[] defaultComboBoxValues = new String[LoadedExtensions.getInstance().getFilterRulePlugins().size()];
    FilterRulePlugin[] pluginArray = LoadedExtensions.getInstance().getFilterRulePlugins().values()
            .toArray(new FilterRulePlugin[0]);
    for (int i = 0; i < pluginArray.length; i++) {
        defaultComboBoxValues[i] = pluginArray[i].getPluginPointName();
    }

    MirthComboBoxTableCellEditor comboBoxType = new MirthComboBoxTableCellEditor(filterTable,
            defaultComboBoxValues, 2, true, new ActionListener() {

                @Override
                public void actionPerformed(ActionEvent evt) {
                    if (filterTable.getEditingRow() != -1) {
                        int row = getSelectedRow();
                        String selectedType = ((JComboBox) evt.getSource()).getSelectedItem().toString();
                        String previousType = (String) filterTable.getValueAt(row, RULE_TYPE_COL);

                        if (selectedType.equalsIgnoreCase(previousType)) {
                            return;
                        }

                        modified = true;
                        FilterRulePlugin plugin;
                        try {
                            if (rulePanel.isModified() && !PlatformUI.MIRTH_FRAME.alertOption(
                                    PlatformUI.MIRTH_FRAME,
                                    "Are you sure you would like to change this filter rule and lose all of the current filter data?")) {
                                ((JComboBox) evt.getSource()).getModel().setSelectedItem(previousType);
                                return;
                            }

                            plugin = getPlugin(selectedType);
                            plugin.initData();
                            filterTableModel.setValueAt(plugin.getNewName(), row, RULE_NAME_COL);
                            rulePanel.showCard(selectedType);
                            updateTaskPane(selectedType);
                            updateCodePanel(selectedType);
                        } catch (Exception e) {
                            parent.alertThrowable(parent, e);
                        }

                    }
                }
            });

    filterTable.setSelectionMode(0); // only select one row at a time

    filterTable.getColumnExt(RULE_NUMBER_COL).setMaxWidth(UIConstants.MAX_WIDTH);
    filterTable.getColumnExt(RULE_OP_COL).setMaxWidth(UIConstants.MAX_WIDTH);

    filterTable.getColumnExt(RULE_NUMBER_COL).setPreferredWidth(30);
    filterTable.getColumnExt(RULE_OP_COL).setPreferredWidth(60);

    filterTable.getColumnExt(RULE_NUMBER_COL).setCellRenderer(new CenterCellRenderer());
    filterTable.getColumnExt(RULE_OP_COL).setCellEditor(comboBoxOp);
    filterTable.getColumnExt(RULE_OP_COL).setCellRenderer(new MirthComboBoxTableCellRenderer(comboBoxValues) {
        @Override
        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected,
                boolean hasFocus, int row, int column) {
            if (value instanceof String && value.equals("")) {
                value = null;
            } else if (value != null) {
                value = value.toString();
            }

            return super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
        }
    });

    filterTable.getColumnExt(RULE_TYPE_COL).setMaxWidth(UIConstants.MAX_WIDTH);
    filterTable.getColumnExt(RULE_TYPE_COL).setMinWidth(120);
    filterTable.getColumnExt(RULE_TYPE_COL).setPreferredWidth(120);
    filterTable.getColumnExt(RULE_TYPE_COL).setCellEditor(comboBoxType);
    filterTable.getColumnExt(RULE_TYPE_COL)
            .setCellRenderer(new MirthComboBoxTableCellRenderer(defaultComboBoxValues));

    filterTable.getColumnExt(RULE_DATA_COL).setVisible(false);

    filterTable.setRowHeight(UIConstants.ROW_HEIGHT);
    filterTable.packTable(UIConstants.COL_MARGIN);
    filterTable.setSortable(false);
    filterTable.setOpaque(true);
    filterTable.setRowSelectionAllowed(true);
    filterTable.setDragEnabled(false);
    filterTable.getTableHeader().setReorderingAllowed(false);

    if (Preferences.userNodeForPackage(Mirth.class).getBoolean("highlightRows", true)) {
        Highlighter highlighter = HighlighterFactory.createAlternateStriping(UIConstants.HIGHLIGHTER_COLOR,
                UIConstants.BACKGROUND_COLOR);
        filterTable.setHighlighters(highlighter);
    }

    filterTable.setDropTarget(dropTarget);
    filterTablePane.setDropTarget(dropTarget);

    filterTable.setBorder(BorderFactory.createEmptyBorder());
    filterTablePane.setBorder(BorderFactory.createEmptyBorder());

    filterTablePane.setViewportView(filterTable);

    filterTable.addMouseListener(new MouseAdapter() {

        public void mousePressed(MouseEvent evt) {
            checkSelectionAndPopupMenu(evt);
        }

        public void mouseReleased(MouseEvent evt) {
            checkSelectionAndPopupMenu(evt);
        }
    });

    filterTable.getSelectionModel().addListSelectionListener(new ListSelectionListener() {

        public void valueChanged(ListSelectionEvent evt) {
            if (!updating && !evt.getValueIsAdjusting()) {
                FilterListSelected(evt);
                updateCodePanel(null);
            }
        }
    });
    filterTable.addKeyListener(new KeyListener() {
        public void keyPressed(KeyEvent e) {
            if (e.getKeyCode() == KeyEvent.VK_DELETE) {
                deleteRule();
            }
        }

        public void keyReleased(KeyEvent e) {
        }

        public void keyTyped(KeyEvent e) {
        }
    });
}

From source file:io.heming.accountbook.ui.MainFrame.java

private void initToolBar() {
    toolbar = new JToolBar("ToolBar", JToolBar.HORIZONTAL);

    // Add Button
    addButton = new JButton();
    addButton.setActionCommand("");
    addButton.setToolTipText("");
    addButton.setIcon(new ImageIcon(getClass().getResource("edit-add-3.png")));

    // Search date range radio buttons
    ButtonGroup group = new ButtonGroup();
    yearToggleButton = new JToggleButton();
    yearToggleButton.setToolTipText("");
    yearToggleButton.setIcon(new ImageIcon(getClass().getResource("year-s.png")));
    group.add(yearToggleButton);//from  w  w  w  .  j  av a 2 s. c om
    monthToggleButton = new JToggleButton();
    monthToggleButton.setToolTipText("");
    monthToggleButton.setIcon(new ImageIcon(getClass().getResource("month-s.png")));
    group.add(monthToggleButton);
    dayToggleButton = new JToggleButton();
    dayToggleButton.setToolTipText("");
    dayToggleButton.setIcon(new ImageIcon(getClass().getResource("day-s.png")));
    group.add(dayToggleButton);
    customToggleButton = new JToggleButton();
    customToggleButton.setToolTipText("");
    customToggleButton.setIcon(new ImageIcon(getClass().getResource("all-s.png")));
    group.add(customToggleButton);

    // ??Checkbox
    monthToggleButton.setSelected(true);

    Calendar earliestCalendar = Calendar.getInstance();
    earliestCalendar.add(Calendar.YEAR, -100);
    java.util.Date earliestDate = earliestCalendar.getTime();

    Calendar latestCalendar = Calendar.getInstance();
    latestCalendar.add(Calendar.YEAR, 100);
    java.util.Date latestDate = latestCalendar.getTime();
    // 3?
    Calendar calendar = Calendar.getInstance();
    calendar.add(Calendar.MONTH, -1);
    calendar.add(Calendar.DAY_OF_MONTH, 1);
    java.util.Date initDate = calendar.getTime();

    SpinnerDateModel startDateModel = new SpinnerDateModel(DateUtil.getStartOfWeek(), earliestDate, latestDate,
            Calendar.MONTH);
    startDateSpinner = new JSpinner(startDateModel);
    JSpinner.DateEditor startDateEditor = new JSpinner.DateEditor(startDateSpinner, "yyyy-MM-dd");
    startDateSpinner.setEditor(startDateEditor);

    calendar.add(Calendar.MONTH, 1);
    calendar.add(Calendar.DAY_OF_MONTH, -1);
    initDate = calendar.getTime();
    SpinnerDateModel endDateModel = new SpinnerDateModel(initDate, earliestDate, latestDate, Calendar.MONTH);
    endDateSpinner = new JSpinner(endDateModel);
    JSpinner.DateEditor endDateEditor = new JSpinner.DateEditor(endDateSpinner, "yyyy-MM-dd");
    endDateSpinner.setEditor(endDateEditor);

    // Keyword text field
    keywordTextField = new JTextField();
    keywordTextField.setPreferredSize(new Dimension(250, 20));
    keywordTextField.setMaximumSize(keywordTextField.getPreferredSize());

    // Search Button
    searchButton = new JButton();
    searchButton.setActionCommand("?");
    searchButton.setToolTipText("?");
    searchButton.setIcon(new ImageIcon(getClass().getResource("edit-find-5.png")));

    // Layout
    cards = new JPanel();
    cards.setLayout(new CardLayout());
    Box box = Box.createHorizontalBox();
    box.add(Box.createHorizontalGlue());

    startDateSpinner.setPreferredSize(new Dimension(90, 20));
    startDateSpinner.setMaximumSize(startDateSpinner.getPreferredSize());
    box.add(startDateSpinner);

    box.add(Box.createHorizontalStrut(6));

    endDateSpinner.setPreferredSize(new Dimension(90, 20));
    endDateSpinner.setMaximumSize(endDateSpinner.getPreferredSize());
    box.add(endDateSpinner);

    cards.add(new JPanel(), HIDE_DATE_CHOOSER);
    cards.add(box, SHOW_DATE_CHOOSER);

    Box dateRangeBox = Box.createHorizontalBox();
    dateRangeBox.add(Box.createHorizontalGlue());
    dateRangeBox.add(cards);

    toolbar.add(addButton);
    toolbar.add(dateRangeBox);
    toolbar.add(customToggleButton);
    toolbar.add(yearToggleButton);
    toolbar.add(monthToggleButton);
    toolbar.add(dayToggleButton);
    toolbar.add(keywordTextField);
    toolbar.add(searchButton);

    add(toolbar, BorderLayout.NORTH);

    // Event listener
    addButton.addActionListener(e -> showAddRecordDialog());

    ActionListener listener = e -> searchRecords();
    yearToggleButton.addActionListener(listener);
    monthToggleButton.addActionListener(listener);
    dayToggleButton.addActionListener(listener);
    customToggleButton.addActionListener(listener);
    keywordTextField.addActionListener(listener);
    searchButton.addActionListener(listener);

    customToggleButton.addMouseListener(new MouseAdapter() {
        @Override
        public void mouseClicked(MouseEvent e) {
            if (SwingUtilities.isRightMouseButton(e)) {
                chooseDateRange();
            }
        }
    });
}

From source file:com.mirth.connect.client.ui.editors.transformer.TransformerPane.java

public void makeTransformerTable() {
    transformerTable = new MirthTable();
    transformerTable.setBorder(BorderFactory.createEmptyBorder());

    // Data Column is hidden
    transformerTable.setModel(new DefaultTableModel(new String[] { "#", "Name", "Type", "Data" }, 0) {

        public boolean isCellEditable(int rowIndex, int columnIndex) {
            boolean[] canEdit;
            TransformerStepPlugin plugin;
            try {
                plugin = getPlugin((String) transformerTableModel.getValueAt(rowIndex, STEP_TYPE_COL));
                canEdit = new boolean[] { false, plugin.isNameEditable(), true, true };
            } catch (Exception e) {
                canEdit = new boolean[] { false, false, true, true };
            }/*  w ww.j a  va 2s . co  m*/
            return canEdit[columnIndex];
        }
    });

    transformerTable.putClientProperty("terminateEditOnFocusLost", Boolean.TRUE);

    transformerTableModel = (DefaultTableModel) transformerTable.getModel();

    transformerTable.getColumnModel().getColumn(STEP_NAME_COL).setCellEditor(new EditorTableCellEditor(this));
    transformerTable.setCustomEditorControls(true);

    // Set the combobox editor on the type column, and add action listener
    String[] defaultComboBoxValues = new String[LoadedExtensions.getInstance().getTransformerStepPlugins()
            .size()];
    TransformerStepPlugin[] pluginArray = LoadedExtensions.getInstance().getTransformerStepPlugins().values()
            .toArray(new TransformerStepPlugin[0]);
    for (int i = 0; i < pluginArray.length; i++) {
        defaultComboBoxValues[i] = pluginArray[i].getPluginPointName();
    }

    MirthComboBoxTableCellEditor comboBox = new MirthComboBoxTableCellEditor(transformerTable,
            defaultComboBoxValues, 2, true, new ActionListener() {

                @Override
                public void actionPerformed(ActionEvent evt) {
                    if (transformerTable.getEditingRow() != -1) {
                        int row = getSelectedRow();
                        String selectedType = ((JComboBox) evt.getSource()).getSelectedItem().toString();
                        String previousType = (String) transformerTable.getValueAt(row, STEP_TYPE_COL);

                        if (selectedType.equalsIgnoreCase(previousType)) {
                            return;
                        }

                        modified = true;
                        invalidVar = false;
                        TransformerStepPlugin plugin = null;
                        try {

                            if (stepPanel.isModified() && !PlatformUI.MIRTH_FRAME.alertOption(
                                    PlatformUI.MIRTH_FRAME,
                                    "Are you sure you would like to change this transformer step and lose all of the current transformer data?")) {
                                ((JComboBox) evt.getSource()).getModel().setSelectedItem(previousType);
                                return;
                            }

                            plugin = getPlugin(selectedType);
                            plugin.initData();
                            transformerTableModel.setValueAt(plugin.getNewName(), row, STEP_NAME_COL);
                            stepPanel.showCard(selectedType);
                            updateTaskPane(selectedType);
                            updateCodePanel(selectedType);
                        } catch (Exception e) {
                            parent.alertThrowable(PlatformUI.MIRTH_FRAME, e);
                        }
                    }
                }
            });

    transformerTable.setSelectionMode(0); // only select one row at a time

    transformerTable.getColumnExt(STEP_NUMBER_COL).setMaxWidth(UIConstants.MAX_WIDTH);
    transformerTable.getColumnExt(STEP_TYPE_COL).setMaxWidth(UIConstants.MAX_WIDTH);
    transformerTable.getColumnExt(STEP_TYPE_COL).setMinWidth(120);

    transformerTable.getColumnExt(STEP_NUMBER_COL).setPreferredWidth(30);
    transformerTable.getColumnExt(STEP_TYPE_COL).setPreferredWidth(120);

    transformerTable.getColumnExt(STEP_NUMBER_COL).setCellRenderer(new CenterCellRenderer());
    transformerTable.getColumnExt(STEP_TYPE_COL).setCellEditor(comboBox);
    transformerTable.getColumnExt(STEP_TYPE_COL)
            .setCellRenderer(new MirthComboBoxTableCellRenderer(defaultComboBoxValues));

    transformerTable.getColumnExt(STEP_DATA_COL).setVisible(false);

    transformerTable.setRowHeight(UIConstants.ROW_HEIGHT);
    transformerTable.packTable(UIConstants.COL_MARGIN);
    transformerTable.setSortable(false);
    transformerTable.setOpaque(true);
    transformerTable.setRowSelectionAllowed(true);
    transformerTable.setDragEnabled(false);
    transformerTable.getTableHeader().setReorderingAllowed(false);

    if (Preferences.userNodeForPackage(Mirth.class).getBoolean("highlightRows", true)) {
        Highlighter highlighter = HighlighterFactory.createAlternateStriping(UIConstants.HIGHLIGHTER_COLOR,
                UIConstants.BACKGROUND_COLOR);
        transformerTable.setHighlighters(highlighter);
    }

    transformerTable.setDropTarget(dropTarget);
    transformerTablePane.setDropTarget(dropTarget);

    transformerTable.setBorder(BorderFactory.createEmptyBorder());
    transformerTablePane.setBorder(BorderFactory.createEmptyBorder());
    transformerTablePane.setViewportView(transformerTable);

    // listen for mouse clicks on the actual table
    transformerTable.addMouseListener(new MouseAdapter() {

        public void mousePressed(MouseEvent evt) {
            checkSelectionAndPopupMenu(evt);
        }

        public void mouseReleased(MouseEvent evt) {
            checkSelectionAndPopupMenu(evt);
        }
    });

    transformerTable.getSelectionModel().addListSelectionListener(new ListSelectionListener() {

        public void valueChanged(ListSelectionEvent evt) {
            if (!updating && !evt.getValueIsAdjusting()) {
                TransformerListSelected(evt);
                updateCodePanel(null);
            }
        }
    });
    transformerTable.addKeyListener(new KeyListener() {
        public void keyPressed(KeyEvent e) {
            if (e.getKeyCode() == KeyEvent.VK_DELETE) {
                deleteStep();
            }
        }

        public void keyReleased(KeyEvent e) {
        }

        public void keyTyped(KeyEvent e) {
        }
    });
}

From source file:com.mirth.connect.plugins.httpauth.HttpAuthConnectorPropertiesPanel.java

private void initComponents() {
    setBackground(UIConstants.BACKGROUND_COLOR);

    typeLabel = new JLabel("Authentication Type:");
    typeLabel.setHorizontalAlignment(SwingConstants.RIGHT);

    typeComboBox = new MirthComboBox();
    typeComboBox.setModel(new DefaultComboBoxModel<AuthType>(AuthType.values()));
    typeComboBox.addActionListener(new ActionListener() {
        @Override/*from   w  ww  .j  ava  2s . co  m*/
        public void actionPerformed(ActionEvent evt) {
            authTypeChanged();
        }
    });
    typeComboBox.setToolTipText("Select the type of HTTP authentication to perform for incoming requests.");

    basicRealmLabel = new JLabel("Realm:");
    basicRealmField = new MirthTextField();
    basicRealmField.setToolTipText("The protection space for this server.");
    basicCredentialsLabel = new JLabel("Credentials:");

    basicCredentialsPanel = new JPanel();
    basicCredentialsPanel.setBackground(getBackground());

    basicCredentialsTable = new MirthTable();
    basicCredentialsTable.setModel(new RefreshTableModel(new String[] { "Username", "Password" }, 0));
    basicCredentialsTable.setCustomEditorControls(true);
    basicCredentialsTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
    basicCredentialsTable.setRowSelectionAllowed(true);
    basicCredentialsTable.setRowHeight(UIConstants.ROW_HEIGHT);
    basicCredentialsTable.setDragEnabled(false);
    basicCredentialsTable.setOpaque(true);
    basicCredentialsTable.setSortable(false);
    basicCredentialsTable.getTableHeader().setReorderingAllowed(false);
    basicCredentialsTable.putClientProperty("terminateEditOnFocusLost", Boolean.TRUE);
    basicCredentialsTable.setToolTipText(
            "<html>Username and password pairs to authenticate<br/>users with. At least one pair is required.</html>");

    if (Preferences.userNodeForPackage(Mirth.class).getBoolean("highlightRows", true)) {
        Highlighter highlighter = HighlighterFactory.createAlternateStriping(UIConstants.HIGHLIGHTER_COLOR,
                UIConstants.BACKGROUND_COLOR);
        basicCredentialsTable.setHighlighters(highlighter);
    }

    CredentialsTableCellEditor basicCredentialsTableCellEditor = new CredentialsTableCellEditor(
            basicCredentialsTable);
    basicCredentialsTable.getColumnExt(0).setCellEditor(basicCredentialsTableCellEditor);
    basicCredentialsTable.getColumnExt(0).setToolTipText("The username to authenticate with.");
    basicCredentialsTable.getColumnExt(1).setCellRenderer(new PasswordCellRenderer());
    basicCredentialsTable.getColumnExt(1).setCellEditor(new DefaultCellEditor(new JPasswordField()));
    basicCredentialsTable.getColumnExt(1).setToolTipText("The password to authenticate with.");

    basicCredentialsTableScrollPane = new JScrollPane(basicCredentialsTable);

    basicCredentialsNewButton = new MirthButton("New");
    basicCredentialsNewButton.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent evt) {
            int num = 0;
            String username;
            boolean found;
            do {
                num++;
                username = "user" + num;

                found = false;
                for (int row = 0; row < basicCredentialsTable.getModel().getRowCount(); row++) {
                    if (StringUtils.equals(username,
                            (String) basicCredentialsTable.getModel().getValueAt(row, 0))) {
                        found = true;
                    }
                }
            } while (found);

            ((DefaultTableModel) basicCredentialsTable.getModel()).addRow(new String[] { username, "" });
            basicCredentialsTable.setRowSelectionInterval(basicCredentialsTable.getRowCount() - 1,
                    basicCredentialsTable.getRowCount() - 1);
            PlatformUI.MIRTH_FRAME.setSaveEnabled(true);
        }
    });

    basicCredentialsDeleteButton = new MirthButton("Delete");
    basicCredentialsDeleteButton.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent evt) {
            int selectedRow = getSelectedRow(basicCredentialsTable);
            if (selectedRow >= 0) {
                if (basicCredentialsTable.isEditing()) {
                    basicCredentialsTable.getCellEditor().cancelCellEditing();
                }

                ((DefaultTableModel) basicCredentialsTable.getModel()).removeRow(selectedRow);

                int rowCount = basicCredentialsTable.getRowCount();
                if (selectedRow < rowCount) {
                    basicCredentialsTable.setRowSelectionInterval(selectedRow, selectedRow);
                } else if (rowCount > 0) {
                    basicCredentialsTable.setRowSelectionInterval(rowCount - 1, rowCount - 1);
                }

                PlatformUI.MIRTH_FRAME.setSaveEnabled(true);
            }
        }
    });
    basicCredentialsTableCellEditor.setDeleteButton(basicCredentialsDeleteButton);

    digestRealmLabel = new JLabel("Realm:");
    digestRealmField = new MirthTextField();
    digestRealmField.setToolTipText("The protection space for this server.");

    digestAlgorithmLabel = new JLabel("Algorithms:");
    ButtonGroup digestAlgorithmButtonGroup = new ButtonGroup();
    String toolTipText = "<html>Specifies the digest algorithms supported by this server.<br/><b>&nbsp;- MD5:</b> The security data A1 will contain the username, realm, and password.<br/><b>&nbsp;- MD5-sess:</b> The security data A1 will also contain the server and client nonces.</html>";

    digestAlgorithmMD5Radio = new MirthRadioButton(Algorithm.MD5.toString());
    digestAlgorithmMD5Radio.setBackground(getBackground());
    digestAlgorithmMD5Radio.setToolTipText(toolTipText);
    digestAlgorithmButtonGroup.add(digestAlgorithmMD5Radio);

    digestAlgorithmMD5SessRadio = new MirthRadioButton(Algorithm.MD5_SESS.toString());
    digestAlgorithmMD5SessRadio.setBackground(getBackground());
    digestAlgorithmMD5SessRadio.setToolTipText(toolTipText);
    digestAlgorithmButtonGroup.add(digestAlgorithmMD5SessRadio);

    digestAlgorithmBothRadio = new MirthRadioButton("Both");
    digestAlgorithmBothRadio.setBackground(getBackground());
    digestAlgorithmBothRadio.setToolTipText(toolTipText);
    digestAlgorithmButtonGroup.add(digestAlgorithmBothRadio);

    digestQOPLabel = new JLabel("QOP Modes:");
    toolTipText = "<html>The quality of protection modes to support.<br/><b>&nbsp;- auth:</b> Regular auth with client nonce and count in the digest.<br/><b>&nbsp;- auth-int:</b> Same as auth, but also with message integrity protection enabled.</html>";

    digestQOPAuthCheckBox = new MirthCheckBox(QOPMode.AUTH.toString());
    digestQOPAuthCheckBox.setBackground(getBackground());
    digestQOPAuthCheckBox.setToolTipText(toolTipText);

    digestQOPAuthIntCheckBox = new MirthCheckBox(QOPMode.AUTH_INT.toString());
    digestQOPAuthIntCheckBox.setBackground(getBackground());
    digestQOPAuthIntCheckBox.setToolTipText(toolTipText);

    digestOpaqueLabel = new JLabel("Opaque:");
    digestOpaqueField = new MirthTextField();
    digestOpaqueField.setToolTipText("A string of data that should be returned by the client unchanged.");
    digestCredentialsLabel = new JLabel("Credentials:");

    digestCredentialsPanel = new JPanel();
    digestCredentialsPanel.setBackground(getBackground());

    digestCredentialsTable = new MirthTable();
    digestCredentialsTable.setModel(new RefreshTableModel(new String[] { "Username", "Password" }, 0));
    digestCredentialsTable.setCustomEditorControls(true);
    digestCredentialsTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
    digestCredentialsTable.setRowSelectionAllowed(true);
    digestCredentialsTable.setRowHeight(UIConstants.ROW_HEIGHT);
    digestCredentialsTable.setDragEnabled(false);
    digestCredentialsTable.setOpaque(true);
    digestCredentialsTable.setSortable(false);
    digestCredentialsTable.getTableHeader().setReorderingAllowed(false);
    digestCredentialsTable.putClientProperty("terminateEditOnFocusLost", Boolean.TRUE);
    digestCredentialsTable.setToolTipText(
            "<html>Username and password pairs to authenticate<br/>users with. At least one pair is required.</html>");

    if (Preferences.userNodeForPackage(Mirth.class).getBoolean("highlightRows", true)) {
        Highlighter highlighter = HighlighterFactory.createAlternateStriping(UIConstants.HIGHLIGHTER_COLOR,
                UIConstants.BACKGROUND_COLOR);
        digestCredentialsTable.setHighlighters(highlighter);
    }

    CredentialsTableCellEditor digestCredentialsTableCellEditor = new CredentialsTableCellEditor(
            digestCredentialsTable);
    digestCredentialsTable.getColumnExt(0).setCellEditor(digestCredentialsTableCellEditor);
    digestCredentialsTable.getColumnExt(0).setToolTipText("The username to authenticate with.");
    digestCredentialsTable.getColumnExt(1).setCellRenderer(new PasswordCellRenderer());
    digestCredentialsTable.getColumnExt(1).setCellEditor(new DefaultCellEditor(new JPasswordField()));
    digestCredentialsTable.getColumnExt(1).setToolTipText("The password to authenticate with.");

    digestCredentialsTableScrollPane = new JScrollPane(digestCredentialsTable);

    digestCredentialsNewButton = new MirthButton("New");
    digestCredentialsNewButton.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent evt) {
            int num = 0;
            String username;
            boolean found;
            do {
                num++;
                username = "user" + num;

                found = false;
                for (int row = 0; row < digestCredentialsTable.getModel().getRowCount(); row++) {
                    if (StringUtils.equals(username,
                            (String) digestCredentialsTable.getModel().getValueAt(row, 0))) {
                        found = true;
                    }
                }
            } while (found);

            ((DefaultTableModel) digestCredentialsTable.getModel()).addRow(new String[] { username, "" });
            digestCredentialsTable.setRowSelectionInterval(digestCredentialsTable.getRowCount() - 1,
                    digestCredentialsTable.getRowCount() - 1);
            PlatformUI.MIRTH_FRAME.setSaveEnabled(true);
        }
    });

    digestCredentialsDeleteButton = new MirthButton("Delete");
    digestCredentialsDeleteButton.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent evt) {
            int selectedRow = getSelectedRow(digestCredentialsTable);
            if (selectedRow >= 0) {
                if (digestCredentialsTable.isEditing()) {
                    digestCredentialsTable.getCellEditor().cancelCellEditing();
                }

                ((DefaultTableModel) digestCredentialsTable.getModel()).removeRow(selectedRow);

                int rowCount = digestCredentialsTable.getRowCount();
                if (selectedRow < rowCount) {
                    digestCredentialsTable.setRowSelectionInterval(selectedRow, selectedRow);
                } else if (rowCount > 0) {
                    digestCredentialsTable.setRowSelectionInterval(rowCount - 1, rowCount - 1);
                }

                PlatformUI.MIRTH_FRAME.setSaveEnabled(true);
            }
        }
    });
    digestCredentialsTableCellEditor.setDeleteButton(digestCredentialsDeleteButton);

    jsScriptLabel = new JLabel("Script:");
    jsScriptField = new JTextField();
    jsScriptField.setEditable(false);
    jsScriptField.setBackground(getBackground());
    jsScriptField.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
    jsScriptField.addMouseListener(new MouseAdapter() {
        @Override
        public void mouseReleased(MouseEvent evt) {
            JavaScriptHttpAuthDialog dialog = new JavaScriptHttpAuthDialog(PlatformUI.MIRTH_FRAME, jsScript);
            if (dialog.wasSaved()) {
                PlatformUI.MIRTH_FRAME.setSaveEnabled(true);
                jsScript = dialog.getScript();
                updateJSScriptField();
            }
        }
    });
    jsScriptField.setToolTipText(
            "<html>Click here to open the JavaScript editor dialog.<br/>The return value of this script is used to accept or reject requests.</html>");

    customClassNameLabel = new JLabel("Class Name:");
    customClassNameField = new MirthTextField();
    customClassNameField
            .setToolTipText("The fully-qualified Java class name of the Authenticator class to use.");
    customPropertiesLabel = new JLabel("Properties:");

    customPropertiesPanel = new JPanel();
    customPropertiesPanel.setBackground(getBackground());

    customPropertiesTable = new MirthTable();
    customPropertiesTable.setModel(new RefreshTableModel(new String[] { "Name", "Value" }, 0));
    customPropertiesTable.setCustomEditorControls(true);
    customPropertiesTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
    customPropertiesTable.setRowSelectionAllowed(true);
    customPropertiesTable.setRowHeight(UIConstants.ROW_HEIGHT);
    customPropertiesTable.setDragEnabled(false);
    customPropertiesTable.setOpaque(true);
    customPropertiesTable.setSortable(false);
    customPropertiesTable.getTableHeader().setReorderingAllowed(false);
    customPropertiesTable.putClientProperty("terminateEditOnFocusLost", Boolean.TRUE);
    customPropertiesTable.setToolTipText(
            "Optional properties to pass into the Authenticator class when it is instantiated.");

    if (Preferences.userNodeForPackage(Mirth.class).getBoolean("highlightRows", true)) {
        Highlighter highlighter = HighlighterFactory.createAlternateStriping(UIConstants.HIGHLIGHTER_COLOR,
                UIConstants.BACKGROUND_COLOR);
        customPropertiesTable.setHighlighters(highlighter);
    }

    CredentialsTableCellEditor customPropertiesTableCellEditor = new CredentialsTableCellEditor(
            customPropertiesTable);
    customPropertiesTable.getColumnExt(0).setCellEditor(customPropertiesTableCellEditor);
    customPropertiesTable.getColumnExt(0).setToolTipText("The name of the property to include.");
    customPropertiesTable.getColumnExt(1).setToolTipText("The value of the property to include.");

    customPropertiesTableScrollPane = new JScrollPane(customPropertiesTable);

    customPropertiesNewButton = new MirthButton("New");
    customPropertiesNewButton.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent evt) {
            int num = 0;
            String name;
            boolean found;
            do {
                num++;
                name = "Property " + num;

                found = false;
                for (int row = 0; row < customPropertiesTable.getModel().getRowCount(); row++) {
                    if (StringUtils.equals(name,
                            (String) customPropertiesTable.getModel().getValueAt(row, 0))) {
                        found = true;
                    }
                }
            } while (found);

            ((DefaultTableModel) customPropertiesTable.getModel()).addRow(new String[] { name, "" });
            customPropertiesTable.setRowSelectionInterval(customPropertiesTable.getRowCount() - 1,
                    customPropertiesTable.getRowCount() - 1);
            PlatformUI.MIRTH_FRAME.setSaveEnabled(true);
        }
    });

    customPropertiesDeleteButton = new MirthButton("Delete");
    customPropertiesDeleteButton.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent evt) {
            int selectedRow = getSelectedRow(customPropertiesTable);
            if (selectedRow >= 0) {
                if (customPropertiesTable.isEditing()) {
                    customPropertiesTable.getCellEditor().cancelCellEditing();
                }

                ((DefaultTableModel) customPropertiesTable.getModel()).removeRow(selectedRow);

                int rowCount = customPropertiesTable.getRowCount();
                if (selectedRow < rowCount) {
                    customPropertiesTable.setRowSelectionInterval(selectedRow, selectedRow);
                } else if (rowCount > 0) {
                    customPropertiesTable.setRowSelectionInterval(rowCount - 1, rowCount - 1);
                }

                PlatformUI.MIRTH_FRAME.setSaveEnabled(true);
            }
        }
    });
    customPropertiesTableCellEditor.setDeleteButton(customPropertiesDeleteButton);

    oauth2TokenLabel = new JLabel("Access Token Location:");

    oauth2TokenLocationComboBox = new MirthComboBox();
    oauth2TokenLocationComboBox.setModel(new DefaultComboBoxModel<TokenLocation>(TokenLocation.values()));
    oauth2TokenLocationComboBox
            .setToolTipText("Determines where the access token is located in client requests.");

    oauth2TokenField = new MirthTextField();
    oauth2TokenField
            .setToolTipText("The header or query parameter to pass along with the verification request.");

    oauth2VerificationURLLabel = new JLabel("Verification URL:");
    oauth2VerificationURLField = new MirthTextField();
    oauth2VerificationURLField.setToolTipText(
            "<html>The HTTP URL to perform a GET request to for access<br/>token verification. If the response code is >= 400,<br/>the authentication attempt is rejected by the server.</html>");

    for (ConnectorPropertiesPlugin connectorPropertiesPlugin : LoadedExtensions.getInstance()
            .getConnectorPropertiesPlugins().values()) {
        if (connectorPropertiesPlugin
                .isConnectorPropertiesPluginSupported(HttpAuthConnectorPluginProperties.PLUGIN_POINT)) {
            connectorPropertiesPanel = connectorPropertiesPlugin.getConnectorPropertiesPanel();
        }
    }
}

From source file:com.rapidminer.gui.new_plotter.gui.ColorSchemeDialog.java

/**
 * @return/*from   ww  w .  j  a va 2  s  .c  o m*/
 */
private JPanel createColorCategoriesPanel() {
    JPanel categoryColorsConfigurationPanel = new JPanel(new GridBagLayout());
    categoryColorsConfigurationPanel.setPreferredSize(new Dimension(180, 200));

    GridBagConstraints itemConstraint = new GridBagConstraints();

    JLabel categoryColorsLabel = new ResourceLabel(
            "plotter.configuration_dialog.color_scheme_dialog.category_colors");
    {

        itemConstraint.fill = GridBagConstraints.HORIZONTAL;
        itemConstraint.anchor = GridBagConstraints.WEST;
        itemConstraint.gridwidth = GridBagConstraints.RELATIVE;
        itemConstraint.insets = new Insets(0, 5, 5, 5);
        itemConstraint.weightx = 1.0;

        categoryColorsConfigurationPanel.add(categoryColorsLabel, itemConstraint);
    }

    // add button panel
    {
        JPanel buttonPanel = new JPanel(new GridBagLayout());

        // remove scheme button
        {
            removeCategoryColorButton = new JButton(new ResourceAction(true,
                    "plotter.configuration_dialog.color_scheme_dialog.remove_category_color_button") {

                private static final long serialVersionUID = 1L;

                @Override
                public void actionPerformed(ActionEvent e) {
                    removeSelectedColorAction();
                }

            });

            itemConstraint = new GridBagConstraints();
            itemConstraint.gridwidth = GridBagConstraints.RELATIVE;
            itemConstraint.fill = GridBagConstraints.NONE;

            buttonPanel.add(removeCategoryColorButton, itemConstraint);
        }

        {
            addCategoryButton = new JButton(new ResourceAction(true,
                    "plotter.configuration_dialog.color_scheme_dialog.add_category_color_button") {

                private static final long serialVersionUID = 1L;

                @Override
                public void actionPerformed(ActionEvent e) {
                    Color oldColor = Color.white;
                    Color newSchemeColor = createColorDialog(oldColor);
                    if (newSchemeColor != null && !newSchemeColor.equals(oldColor)) {
                        addColorAction(newSchemeColor);
                    }
                }

            });

            itemConstraint = new GridBagConstraints();
            itemConstraint.gridwidth = GridBagConstraints.REMAINDER;
            itemConstraint.fill = GridBagConstraints.NONE;

            buttonPanel.add(addCategoryButton, itemConstraint);

        }

        itemConstraint = new GridBagConstraints();
        itemConstraint.gridwidth = GridBagConstraints.REMAINDER;
        itemConstraint.fill = GridBagConstraints.NONE;
        itemConstraint.anchor = GridBagConstraints.EAST;
        itemConstraint.insets = new Insets(0, 5, 5, 5);

        categoryColorsConfigurationPanel.add(buttonPanel, itemConstraint);
    }

    {

        JPanel categoryListPanel = new JPanel(new GridBagLayout());

        // add list of categorie colors
        {

            colorList = new JList<Color>(nominalColorListModel);
            categoryColorsLabel.setLabelFor(colorList);
            colorList.setCellRenderer(new ColorListCellRenderer());
            colorList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

            MouseAdapter ma = new MouseAdapter() {

                private void myPopupEvent(MouseEvent e) {
                    int x = e.getX();
                    int y = e.getY();
                    JList<?> list = (JList<?>) e.getSource();
                    list.setSelectedIndex(list.locationToIndex(e.getPoint()));
                    Color selectedColor = (Color) list.getSelectedValue();
                    if (selectedColor == null) {
                        return;
                    }

                    removeMenuItem.setEnabled(nominalColorListModel.getSize() > 2);

                    popupMenu.show(list, x, y);
                }

                @Override
                public void mousePressed(MouseEvent e) {
                    if (e.isPopupTrigger()) {
                        myPopupEvent(e);
                    }
                }

                @Override
                public void mouseReleased(MouseEvent e) {
                    if (e.isPopupTrigger()) {
                        myPopupEvent(e);
                    }
                }
            };

            colorList.addMouseListener(ma);
            colorList.addKeyListener(new KeyListener() {

                @Override
                public void keyTyped(KeyEvent e) {
                    return; // Nothing to be done
                }

                @Override
                public void keyReleased(KeyEvent e) {
                    return; // Nothing to be done
                }

                @Override
                public void keyPressed(KeyEvent e) {
                    int key = e.getKeyCode();
                    if (key == KeyEvent.VK_DELETE) {
                        if (nominalColorListModel.getSize() > 2) {
                            removeSelectedColorAction();
                        }
                    }
                    if (key == KeyEvent.VK_F2) {
                        replaceSelectedColorAction();
                    }
                    if (key == KeyEvent.VK_UP && SwingTools.isControlOrMetaDown(e)) {
                        moveSelectedColorUpAction();
                    }
                    if (key == KeyEvent.VK_DOWN && SwingTools.isControlOrMetaDown(e)) {
                        moveSelectedColorDownAction();
                    }
                }
            });

            colorListScrollPane = new JScrollPane(colorList);
            colorListScrollPane.setPreferredSize(new Dimension(170, 200));
            colorListScrollPane.setMaximumSize(new Dimension(170, 200));
            colorListScrollPane.setMinimumSize(new Dimension(170, 180));
            colorListScrollPane.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
            colorListScrollPane.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED);

            itemConstraint = new GridBagConstraints();
            itemConstraint.fill = GridBagConstraints.BOTH;
            itemConstraint.weightx = 0.0;
            itemConstraint.weighty = 0.5;
            itemConstraint.gridwidth = GridBagConstraints.RELATIVE;

            categoryListPanel.add(colorListScrollPane, itemConstraint);
        }

        // add up/down button panel
        {

            JPanel upAndDownButtonPanel = new JPanel(new GridBagLayout());

            // add up button
            {
                JButton upButton = new JButton(
                        new ResourceAction(true, "plotter.configuration_dialog.move_color_up") {

                            private static final long serialVersionUID = 1L;

                            @Override
                            public void actionPerformed(ActionEvent e) {
                                moveSelectedColorUpAction();
                            }
                        });

                itemConstraint = new GridBagConstraints();
                itemConstraint.gridwidth = GridBagConstraints.REMAINDER;
                itemConstraint.weightx = 0;
                itemConstraint.weighty = 0;
                itemConstraint.fill = GridBagConstraints.NONE;
                itemConstraint.insets = new Insets(0, 2, 0, 12);

                upAndDownButtonPanel.add(upButton, itemConstraint);
            }

            // add down button
            {
                JButton downButton = new JButton(
                        new ResourceAction(true, "plotter.configuration_dialog.move_color_down") {

                            private static final long serialVersionUID = 1L;

                            @Override
                            public void actionPerformed(ActionEvent e) {
                                moveSelectedColorDownAction();
                            }
                        });

                itemConstraint = new GridBagConstraints();
                itemConstraint.gridwidth = GridBagConstraints.REMAINDER;
                itemConstraint.weightx = 0;
                itemConstraint.weighty = 0;
                itemConstraint.fill = GridBagConstraints.NONE;
                itemConstraint.insets = new Insets(0, 2, 0, 12);

                upAndDownButtonPanel.add(downButton, itemConstraint);
            }

            // add spacer panel
            {
                JPanel spacer = new JPanel();

                itemConstraint.gridwidth = GridBagConstraints.REMAINDER;
                itemConstraint.weightx = 0;
                itemConstraint.weighty = 1;
                itemConstraint.fill = GridBagConstraints.VERTICAL;

                upAndDownButtonPanel.add(spacer, itemConstraint);

            }

            itemConstraint = new GridBagConstraints();
            itemConstraint.gridwidth = GridBagConstraints.REMAINDER;
            itemConstraint.weightx = 1;
            itemConstraint.weighty = 1;
            itemConstraint.fill = GridBagConstraints.VERTICAL;

            categoryListPanel.add(upAndDownButtonPanel, itemConstraint);

        }

        itemConstraint = new GridBagConstraints();
        itemConstraint.gridwidth = GridBagConstraints.REMAINDER;
        itemConstraint.weightx = 1;
        itemConstraint.weighty = 1;
        itemConstraint.fill = GridBagConstraints.BOTH;

        categoryColorsConfigurationPanel.add(categoryListPanel, itemConstraint);
    }

    return categoryColorsConfigurationPanel;
}

From source file:edu.ku.brc.af.ui.forms.FormViewObj.java

/**
 * Constructor with FormView definition.
 * @param view the definition of the view
 * @param altView indicates which AltViewIFace we will be using
 * @param mvParent the mvParent mulitview
 * @param formValidator the form's formValidator
 * @param options the options needed for creating the form
 * @param cellName the name of the outer form's cell for this view (subview)
 * @param bgColor bg color it should use
 *//* ww w  . j  a va  2  s.  c  o m*/
public FormViewObj(final ViewIFace view, final AltViewIFace altView, final MultiView mvParent,
        final FormValidator formValidator, final int options, final String cellName, final Class<?> dataClass,
        final Color bgColor) {
    this.view = view;
    this.altView = altView;
    this.mvParent = mvParent;
    this.cellName = cellName;
    this.dataClass = dataClass;
    this.bgColor = bgColor;

    businessRules = view.createBusinessRule();

    //XXX bug #9497: isEditing        = altView.getMode() == AltViewIFace.CreationMode.EDIT && MultiView.isOptionOn(options, MultiView.IS_EDITTING);
    isEditing = altView.getMode() == AltViewIFace.CreationMode.EDIT;

    boolean addSearch = mvParent != null
            && MultiView.isOptionOn(mvParent.getOptions(), MultiView.ADD_SEARCH_BTN);
    if (addSearch) {
        isEditing = false;
    }
    this.formViewDef = (FormViewDef) altView.getViewDef();

    // Figure columns
    try {
        JPanel panel = useDebugForm ? new FormDebugPanel() : (restrictablePanel = new RestrictablePanel());
        formLayout = new FormLayout(formViewDef.getColumnDef(), formViewDef.getRowDef());
        builder = new PanelBuilder(formLayout, panel);

    } catch (java.lang.NumberFormatException ex) {
        String msg = "Error in row or column definition for form: `" + view.getName() + "`\n" + ex.getMessage();
        UIRegistry.showError(msg);
        return;
    }

    mainComp = new JPanel(new BorderLayout());
    mainComp.setBorder(BorderFactory.createEmptyBorder(2, 2, 2, 2));

    if (mvParent == null) {
        builder.getPanel().setBorder(BorderFactory.createEmptyBorder(4, 4, 4, 4));
    }
    if (bgColor != null) {
        builder.getPanel().setBackground(bgColor);
    }

    this.options = options;
    boolean isSingleObj = MultiView.isOptionOn(options, MultiView.IS_SINGLE_OBJ);
    boolean createResultSetController = MultiView.isOptionOn(options, MultiView.RESULTSET_CONTROLLER);
    boolean hideResultSetController = MultiView.isOptionOn(options, MultiView.HIDE_RESULTSET_CONTROLLER);
    boolean createViewSwitcher = MultiView.isOptionOn(options, MultiView.VIEW_SWITCHER);
    //boolean isNewObject                = MultiView.isOptionOn(options, MultiView.IS_NEW_OBJECT);
    boolean hideSaveBtn = MultiView.isOptionOn(options, MultiView.HIDE_SAVE_BTN);

    isNewlyCreatedDataObj = MultiView.isOptionOn(options, MultiView.IS_NEW_OBJECT);
    if (formValidator != null) {
        formValidator.setNewObj(isNewlyCreatedDataObj);
    }

    //MultiView.printCreateOptions("Creating Form "+altView.getName(), options);

    setValidator(formValidator);

    scrDateFormat = AppPrefsCache.getDateWrapper("ui", "formatting", "scrdateformat");

    AppPreferences.getRemote().addChangeListener("ui.formatting.viewfieldcolor", this);

    boolean addController = mvParent != null && view.getAltViews().size() > 1;

    // See if we need to add a Selector ComboBox
    isSelectorForm = StringUtils.isNotEmpty(view.getSelectorName());

    boolean addSelectorCBX = false;
    //log.debug(altView.getName()+"  "+altView.getMode()+"  "+AltViewIFace.CreationMode.EDIT);
    //if (isSelectorForm && isNewObject && altView.getMode() == AltViewIFace.CreationMode.EDIT)
    if (isSelectorForm && altView.getMode() == AltViewIFace.CreationMode.EDIT) {
        addSelectorCBX = true;
    }

    List<JComponent> comps = new ArrayList<JComponent>();

    int y = 1;
    // Here we create the JComboBox that enables the user to switch between forms
    // when creating a new object
    if (addSelectorCBX) {
        Vector<AltViewIFace> cbxList = new Vector<AltViewIFace>();
        cbxList.add(altView);
        for (AltViewIFace av : view.getAltViews()) {
            if (av != altView && av.getMode() == AltViewIFace.CreationMode.EDIT) {
                cbxList.add(av);
            }
        }
        JPanel p = new JPanel(new BorderLayout());
        p.setOpaque(false);

        p.setBorder(BorderFactory.createEmptyBorder(2, 2, 2, 2));
        selectorCBX = createComboBox(cbxList);
        selectorCBX.setRenderer(new SelectorCellRenderer());
        p.add(selectorCBX, BorderLayout.WEST);
        mainComp.add(p, BorderLayout.NORTH);

        if (mvParent != null) {
            selectorCBX.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent ev) {
                    doSelectorWasSelected(mvParent, ev);
                }
            });
        }
        y += 2;
    }

    //
    // We will add the switchable UI if we are parented to a MultiView and have multiple AltViews
    //
    if (addController) // this says we are the "root" form
    {
        boolean saveWasAdded = false;

        // We want it on the left side of other buttons
        // so wee need to add it before the Save button
        JComponent valInfoBtn = createValidationIndicator(getUIComponent(), formValidator);
        if (valInfoBtn != null) {
            comps.add(valInfoBtn);
        }

        if (createViewSwitcher) // This is passed in outside
        {
            // Now we have a Special case that when when there are only two AltViews and
            // they differ only by Edit & View we hide the switching UI unless we are the root MultiView.
            // This way when switching the Root View all the other views switch
            // (This is because they were created that way. It also makes no sense that while in "View" mode
            // you would want to switch an individual subview to a differe "mode" view than the root).

            altViewsList = new Vector<AltViewIFace>();

            // This will return null if it isn't suppose to have a switcher
            switcherUI = createMenuSwitcherPanel(mvParent, view, altView, altViewsList, restrictablePanel,
                    cellName, dataClass);

            Action action = new AbstractAction() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    if (switcherUI != null && switcherUI.getSwitcherAL() != null) {
                        switcherUI.getSwitcherAL().actionPerformed(e);
                    }
                }
            };

            if (restrictablePanel != null) {
                restrictablePanel.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT)
                        .put(KeyStroke.getKeyStroke("control E"), actionName);
                restrictablePanel.getActionMap().put(actionName, action);
            }

            if (altViewsList.size() > 0) {
                if (altView.getMode() == AltViewIFace.CreationMode.EDIT && mvParent != null
                        && mvParent.isTopLevel()) {
                    addSaveBtn();
                    comps.add(saveControl);
                    saveWasAdded = true;
                }

                if (switcherUI != null) {
                    comps.add(switcherUI);

                }
            }

            // rods - 07/21/08 for disabling the switcher when the form is invalid 
            if (formValidator != null && switcherUI != null) {
                formValidator.addEnableItem(switcherUI, FormValidator.EnableType.ValidNotNew);
            }
        }

        if (!saveWasAdded && altView.getMode() == AltViewIFace.CreationMode.EDIT && mvParent != null
                && mvParent.isTopLevel() && !hideSaveBtn) {
            addSaveBtn();
            comps.add(saveControl);
        }
    }

    // This here because the Search mode shouldn't be combined with other modes
    if (altView.getMode() == AltViewIFace.CreationMode.SEARCH) {
        if (!hideSaveBtn) {
            saveControl = createButton(UIRegistry.getResourceString("SEARCH"),
                    IconManager.getImage("Search", IconManager.IconSize.Std16));/*
                                                                                {
                                                                                public void setEnabled(boolean enabled)
                                                                                {
                                                                                System.err.println("Save: "+enabled);
                                                                                super.setEnabled(enabled);
                                                                                }
                                                                                };*/
            saveControl.setOpaque(false);
            comps.add(saveControl);

            addSaveActionMap(saveControl);
        }

    }

    if (ViewFactory.isFormTransparent()) {
        builder.getPanel().setOpaque(false);
    }
    mainComp.add(builder.getPanel(), BorderLayout.CENTER);

    if (comps.size() > 0 || addController || createResultSetController) {
        controlPanel = new ControlBarPanel(bgColor);
        controlPanel.addComponents(comps, false); // false -> right side

        if (ViewFactory.isFormTransparent()) {
            controlPanel.setOpaque(false);
        }

        mainComp.add(controlPanel, BorderLayout.SOUTH);

    }

    if (createResultSetController) {
        addRSController(addSearch);
        if (hideResultSetController) {
            rsController.getPanel().setVisible(false);
        }
        if (addSearch) {
            DBTableInfo tblInfo = DBTableIdMgr.getInstance().getByClassName(view.getClassName());
            if (tblInfo != null) {
                searchName = tblInfo.getSearchDialog();
                if (StringUtils.isEmpty(searchName)) {
                    searchName = ""; // Note not null but empty tells it to disable the search btn

                    log.error("The Search Dialog Name is empty or missing for class[" + view.getClassName()
                            + "]");
                }
            } else {
                log.error("Couldn't find TableInfo for class[" + view.getClassName() + "]");
            }

            if (rsController.getSearchRecBtn() != null) {
                rsController.getSearchRecBtn().setEnabled(true);
                rsController.getSearchRecBtn().addActionListener(new ActionListener() {
                    public void actionPerformed(ActionEvent e) {
                        doSearch();
                    }
                });
            }
        }

    } else if (isSingleObj) {
        createAddDelSearchPanel();
    }

    if (true) {
        builder.getPanel().addMouseListener(new MouseAdapter() {
            @Override
            public void mousePressed(MouseEvent e) {
                showContextMenu(e);
            }

            @Override
            public void mouseReleased(MouseEvent e) {
                showContextMenu(e);

            }

            @Override
            public void mouseClicked(MouseEvent e) {
                //FormViewObj.this.listFieldChanges();
            }
        });
    }

    if (rsController != null) {
        rsController.setNewObj(isNewlyCreatedDataObj);
    }

    isBuildValid = true;

    isAutoNumberOn = AppPreferences.getLocalPrefs().getBoolean(AUTO_NUM, true);
    SwingUtilities.invokeLater(new Runnable() {
        @Override
        public void run() {
            updateAutoNumberFieldState();
        }
    });
}

From source file:com.sshtools.appframework.ui.SshToolsApplication.java

/**
 * Show an 'About' dialog//from w ww  .j  av  a  2  s .  c  om
 */
public void showAbout(Component parent) {
    JPanel p = new JPanel(new GridBagLayout());
    p.setBorder(BorderFactory.createEmptyBorder(4, 4, 4, 4));
    GridBagConstraints gBC = new GridBagConstraints();
    gBC.anchor = GridBagConstraints.CENTER;
    gBC.fill = GridBagConstraints.HORIZONTAL;
    gBC.insets = new Insets(1, 1, 1, 1);
    JLabel a = new JLabel(getApplicationName());
    a.setFont(a.getFont().deriveFont(24f));
    UIUtil.jGridBagAdd(p, a, gBC, GridBagConstraints.REMAINDER);
    JLabel v = new JLabel("Version " + getApplicationVersion());
    v.setFont(v.getFont().deriveFont(10f));
    UIUtil.jGridBagAdd(p, v, gBC, GridBagConstraints.REMAINDER);
    MultilineLabel x = new MultilineLabel(getAboutLicenseDetails());
    x.setBorder(BorderFactory.createEmptyBorder(8, 0, 8, 0));
    x.setFont(x.getFont().deriveFont(12f));
    UIUtil.jGridBagAdd(p, x, gBC, GridBagConstraints.REMAINDER);
    MultilineLabel c = new MultilineLabel(getExpiryInfo());
    c.setFont(c.getFont().deriveFont(10f));
    UIUtil.jGridBagAdd(p, c, gBC, GridBagConstraints.REMAINDER);
    final JLabel h = new JLabel(getAboutURL());
    h.setForeground(Color.blue);
    h.setFont(new Font(h.getFont().getName(), Font.BOLD, 10));
    h.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
    h.addMouseListener(new MouseAdapter() {
        @Override
        public void mouseClicked(MouseEvent evt) {
            try {
                BrowserLauncher.openURL(getAboutURL());
            } catch (IOException ioe) {
                ioe.printStackTrace();
            }
        }
    });
    UIUtil.jGridBagAdd(p, h, gBC, GridBagConstraints.REMAINDER);
    JOptionPane.showMessageDialog(parent, p, "About", JOptionPane.PLAIN_MESSAGE, getApplicationLargeIcon());
}

From source file:dpcs.Interface.java

public Interface() {
    setIconImage(Toolkit.getDefaultToolkit().getImage(Interface.class.getResource("/graphics/Icon.png")));
    setTitle("Droid PC Suite");
    setResizable(false);/*  www  . j  av a2s .com*/
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setBounds(100, 100, 1088, 715);
    try {
        InputStreamReader reader2 = new InputStreamReader(
                getClass().getResourceAsStream("/others/app-version.txt"));
        String tmp = IOUtils.toString(reader2);
        AppVersion = Double.parseDouble(tmp);
    } catch (IOException e1) {
        e1.printStackTrace();
    }
    JMenuBar menuBar = new JMenuBar();
    setJMenuBar(menuBar);
    JMenu mnMenu = new JMenu("Menu");
    menuBar.add(mnMenu);
    JMenuItem mntmExit = new JMenuItem("Exit");

    mntmExit.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            System.exit(0);
        }
    });

    JMenu mnADBandFastbootTools = new JMenu("ADB and Fastboot tools");
    mnMenu.add(mnADBandFastbootTools);
    mnADBandFastbootTools.setToolTipText("Access various ADB and Fastboot tools");

    JMenuItem mntmDevicestate = new JMenuItem("View device state");
    mntmDevicestate.setToolTipText("Check android device state");
    mntmDevicestate.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            try {
                Process p1 = Runtime.getRuntime().exec("adb get-state");
                p1.waitFor();
                BufferedReader reader = new BufferedReader(new InputStreamReader(p1.getInputStream()));
                JOptionPane.showMessageDialog(null, "State: " + reader.readLine());
            } catch (Exception e1) {
                e1.printStackTrace();
            }
        }
    });

    JMenuItem mntmAdbHelp = new JMenuItem("View ADB help");
    mntmAdbHelp.setToolTipText("Get help regarding ADB");
    mntmAdbHelp.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            ADBHelp obj = new ADBHelp();
            obj.setVisible(true);
        }
    });

    JMenuItem mntmNoOfUsers = new JMenuItem("Max user(s) supported?");
    mntmNoOfUsers.setToolTipText("Max no. of user(s) supported by android device");
    mntmNoOfUsers.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            try {
                Process p1 = Runtime.getRuntime().exec("adb shell pm get-max-users");
                p1.waitFor();
                BufferedReader reader = new BufferedReader(new InputStreamReader(p1.getInputStream()));
                JOptionPane.showMessageDialog(null, reader.readLine());
            } catch (Exception e1) {
                e1.printStackTrace();
            }
        }
    });
    mnADBandFastbootTools.add(mntmNoOfUsers);
    mnADBandFastbootTools.add(mntmAdbHelp);

    JMenuItem mntmAdbVersion = new JMenuItem("View ADB version");
    mntmAdbVersion.setToolTipText("Check the version of ADB installed on your computer");
    mnADBandFastbootTools.add(mntmAdbVersion);
    mntmAdbVersion.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            try {
                Process p1 = Runtime.getRuntime().exec("adb version");
                p1.waitFor();
                BufferedReader reader = new BufferedReader(new InputStreamReader(p1.getInputStream()));
                JOptionPane.showMessageDialog(null, reader.readLine());
            } catch (Exception e1) {
                e1.printStackTrace();
            }
        }
    });

    JMenuItem mntmViewDeviceList = new JMenuItem("View connected device");
    mntmViewDeviceList.setToolTipText(
            "Displays connected device, it will show name and serial no. of the only connected device because of connectivity limit");
    mntmViewDeviceList.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            try {
                JTextArea Devicelistviewer = new JTextArea();
                Devicelistviewer.setEditable(false);
                Devicelistviewer.setForeground(Color.BLACK);
                Devicelistviewer.setOpaque(false);
                Process p1 = Runtime.getRuntime().exec("adb devices -l");
                p1.waitFor();
                int i = 0;
                String line;
                String[] array = new String[1024];
                BufferedReader reader = new BufferedReader(new InputStreamReader(p1.getInputStream()));
                while ((line = reader.readLine()) != null) {
                    array[i] = line;
                    Devicelistviewer.append(line + "\n");
                }
                JOptionPane.showMessageDialog(null, Devicelistviewer);
            } catch (Exception e1) {
                e1.printStackTrace();
            }
        }
    });
    mnADBandFastbootTools.add(mntmViewDeviceList);
    mnADBandFastbootTools.add(mntmDevicestate);

    JMenuItem mntmViewFastbootHelp = new JMenuItem("View fastboot help");
    mntmViewFastbootHelp.setToolTipText("Get help regarding fastboot");
    mntmViewFastbootHelp.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            FastbootHelp obj = new FastbootHelp();
            obj.setVisible(true);
        }
    });
    mnADBandFastbootTools.add(mntmViewFastbootHelp);

    JMenuItem mntmSerialNo = new JMenuItem("View serial no.");
    mntmSerialNo.setToolTipText("Check ADB connectivity serial no. of your android device");
    mnADBandFastbootTools.add(mntmSerialNo);
    mntmSerialNo.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            try {
                Process p1 = Runtime.getRuntime().exec("adb get-serialno");
                p1.waitFor();
                BufferedReader reader = new BufferedReader(new InputStreamReader(p1.getInputStream()));
                JOptionPane.showMessageDialog(null, "Serial No: " + reader.readLine());
            } catch (Exception e1) {
                e1.printStackTrace();
            }
        }
    });

    JMenuItem mntmWaitForDevice = new JMenuItem("Wait for device");
    mntmWaitForDevice.setToolTipText("Ask ADB to wait for your device until the device can accept commands");
    mntmWaitForDevice.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            try {
                Process p1 = Runtime.getRuntime().exec("adb wait-for-device");
                p1.waitFor();
                JOptionPane.showMessageDialog(null, "Waiting...");
            } catch (Exception e1) {
                e1.printStackTrace();
            }
        }
    });
    mnADBandFastbootTools.add(mntmWaitForDevice);

    JMenuItem mntmDeviceFeatures = new JMenuItem("Device features");
    mnMenu.add(mntmDeviceFeatures);
    mntmDeviceFeatures.setToolTipText("View list of features supported by the android device");
    mntmDeviceFeatures.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            Devicefeatures obj = new Devicefeatures();
            obj.setVisible(true);
        }
    });

    JMenu mnDeviceSpecificTools = new JMenu("Device specific tools");
    mnMenu.add(mnDeviceSpecificTools);
    mnDeviceSpecificTools.setToolTipText("View tools which only work with few  or specific devices");

    JMenu mnHTC = new JMenu("HTC");
    mnDeviceSpecificTools.add(mnHTC);
    mnHTC.setToolTipText("View list of tools which only work with HTC devices");

    JMenuItem mntmGetCidNo = new JMenuItem("Get CID no.");
    mntmGetCidNo.setToolTipText("Get CID Number of the device");
    mntmGetCidNo.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            try {
                Process p1 = Runtime.getRuntime().exec("adb reboot fastboot");
                p1.waitFor();
                Process p2 = Runtime.getRuntime().exec("fastboot getvar cid");
                p2.waitFor();
                BufferedReader reader = new BufferedReader(new InputStreamReader(p2.getInputStream()));
                JOptionPane.showMessageDialog(null, reader.readLine());
                Process p3 = Runtime.getRuntime().exec("fastboot reboot");
                p3.waitFor();
            } catch (Exception e1) {
                e1.printStackTrace();
            }
        }
    });

    JMenuItem mntmBootloaderRelatedInfo = new JMenuItem("Bootloader related info");
    mntmBootloaderRelatedInfo.setToolTipText("View CID No.,Main-ver, bootloader info Etc.");
    mntmBootloaderRelatedInfo.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            try {
                Process p1 = Runtime.getRuntime().exec("adb reboot fastboot");
                p1.waitFor();
                Process p2 = Runtime.getRuntime().exec("fastboot getvar all");
                p2.waitFor();
                BufferedReader reader = new BufferedReader(new InputStreamReader(p2.getInputStream()));
                JOptionPane.showMessageDialog(null, reader.readLine() + "\n");
                Process p3 = Runtime.getRuntime().exec("fastboot reboot");
                p3.waitFor();
            } catch (Exception e1) {
                e1.printStackTrace();
            }
        }
    });
    mnHTC.add(mntmBootloaderRelatedInfo);
    mnHTC.add(mntmGetCidNo);

    JMenuItem mntmWriteSuperCIDNo = new JMenuItem("Write Super CID no.");
    mntmWriteSuperCIDNo.setToolTipText("Write Super CID Number to device");
    mntmWriteSuperCIDNo.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            try {
                int supercidno;
                Process p1 = Runtime.getRuntime().exec("adb reboot fastboot");
                p1.waitFor();
                supercidno = Integer.parseInt(JOptionPane.showInputDialog(null,
                        "Enter the Super CID Number to be written :\nfor ex. 11111111"));
                Process p2 = Runtime.getRuntime().exec("fastboot oem writecid " + supercidno);
                p2.waitFor();
                JOptionPane.showMessageDialog(null, "Done, Click OK to reboot");
                Process p3 = Runtime.getRuntime().exec("fastboot reboot");
                p3.waitFor();
            } catch (Exception e1) {
                e1.printStackTrace();
            }
        }
    });
    mnHTC.add(mntmWriteSuperCIDNo);

    JMenu mnSamsung = new JMenu("Samsung");
    mnSamsung.setToolTipText("View list of tools which only work with Samsung devices");
    mnDeviceSpecificTools.add(mnSamsung);

    JMenuItem mntmDownloadMode = new JMenuItem("Download Mode");
    mntmDownloadMode.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            try {
                ApplicationStatus.setText("Rebooting...");
                Process p1 = Runtime.getRuntime().exec("adb reboot download");
                p1.waitFor();
                ApplicationStatus.setText("Done");
            } catch (Exception e1) {
                System.err.println(e1);
            }
        }
    });
    mntmDownloadMode.setToolTipText(
            "Reboot to Download Mode for flashing firmware to samsung device using Odin or Heimdall");
    mnSamsung.add(mntmDownloadMode);

    mnMenu.add(mntmExit);
    JMenu mnHelp = new JMenu("Help");
    menuBar.add(mnHelp);

    JMenuItem mntmCommonWorkarounds = new JMenuItem("Common workarounds");
    mntmCommonWorkarounds.setToolTipText(
            "View solutions and tips to avoid the common problems while using this application");
    mntmCommonWorkarounds.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            Workarounds obj = new Workarounds();
            obj.setVisible(true);
        }
    });

    JMenuItem mntmAbout = new JMenuItem("About");
    mntmAbout.setToolTipText("Information about the application");
    mntmAbout.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            About obj = new About();
            obj.setVisible(true);
        }
    });
    mnHelp.add(mntmAbout);

    JMenuItem mntmCheckForUpdates = new JMenuItem("Check for updates");
    mntmCheckForUpdates.setToolTipText("Check for the new updates of this application");
    mntmCheckForUpdates.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            new Updater();
        }
    });

    JMenuItem mntmChangelog = new JMenuItem("Changelog");
    mntmChangelog.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            Changelog obj = new Changelog();
            obj.setVisible(true);
        }
    });
    mntmChangelog.setToolTipText("View changes made to this application over the time");
    mnHelp.add(mntmChangelog);
    mnHelp.add(mntmCheckForUpdates);
    mnHelp.add(mntmCommonWorkarounds);

    JMenuItem mntmNeedHelp = new JMenuItem("Online help");
    mntmNeedHelp.setToolTipText("Get online help for Droid PC Suite");
    mntmNeedHelp.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            try {
                JOptionPane.showMessageDialog(null, "Post your queries on XDA-Developers thread");
                Desktop.getDesktop().browse(new URL(
                        "http://forum.xda-developers.com/android/development/tool-droid-pc-suite-t3398599")
                                .toURI());
            } catch (Exception e) {
                System.err.println(e);
            }
        }
    });

    JMenuItem mntmForceConnect = new JMenuItem("Force connect");
    mnHelp.add(mntmForceConnect);
    mntmForceConnect.setToolTipText("Force connect android device to computer using ADB protocol");
    mntmForceConnect.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            JOptionPane.showMessageDialog(null,
                    "Go to developer options and turn off android debugging and turn it on again");
            JOptionPane.showMessageDialog(null,
                    "Now tap on Revoke USB debugging authorizations and confirm it by tapping OK on android device");
            JOptionPane.showMessageDialog(null, "Now disconnect your android device and reconnect it via USB");
            JOptionPane.showMessageDialog(null, "Reboot your device. After it completely boots up click OK");
            try {
                adbconnected = false;
                Process p1 = Runtime.getRuntime().exec("adb kill-server");
                p1.waitFor();
                Process p2 = Runtime.getRuntime().exec("adb devices");
                p2.waitFor();
                JOptionPane.showMessageDialog(null, "Check if your device asks to Allow USB debugging");
                JOptionPane.showMessageDialog(null,
                        "If yes check always allow from this computer checkbox and tap OK on your android device");
                Process p3 = Runtime.getRuntime().exec("adb shell touch /sdcard/.CheckADBConnection");
                p3.waitFor();
                Process p4 = Runtime.getRuntime().exec("adb pull /sdcard/.CheckADBConnection");
                p4.waitFor();
                Process p5 = Runtime.getRuntime().exec("adb shell rm /sdcard/.CheckADBConnection");
                p5.waitFor();
                File file = new File(".CheckADBConnection");
                if (file.exists() && !file.isDirectory()) {
                    file.delete();
                    adbconnected = true;
                    ADBConnectionLabel.setText("Device is connected");
                    JOptionPane.showMessageDialog(null, "Success!");
                } else {
                    adbconnected = false;
                    ADBConnectionLabel.setText("");
                    ADBConnectionLabel.setText("Connect your device...");
                    JOptionPane.showMessageDialog(null,
                            "Please try again or perhaps try installing your android device adb drivers on PC");
                }
            } catch (Exception e1) {
                System.err.println(e1);
            }
            try {
                File file = new File("su");
                Process p1 = Runtime.getRuntime().exec("adb pull /system/xbin/su");
                p1.waitFor();
                if (file.exists() && !file.isDirectory()) {
                    file.delete();
                    rooted = true;
                    RootStatusLabel.setText("Device is rooted");
                } else {
                    if (adbconnected == true) {
                        rooted = false;
                        RootStatusLabel.setText("Device is not rooted");
                    } else {
                        rooted = false;
                        RootStatusLabel.setText("");
                    }
                }
            } catch (Exception e1) {
                e1.printStackTrace();
            }
        }
    });

    JMenu mnLegalInformation = new JMenu("Legal information");
    mnLegalInformation.setToolTipText("Vew legal information about the application");
    mnHelp.add(mnLegalInformation);

    JMenuItem mntmDroidPcSuite = new JMenuItem("Droid PC Suite license");
    mntmDroidPcSuite.setToolTipText("View Droid PC Suite licence");
    mntmDroidPcSuite.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            GPLLicense obj = new GPLLicense();
            obj.setVisible(true);
        }
    });
    mnLegalInformation.add(mntmDroidPcSuite);

    JMenuItem mntmOpenSourceLicenses = new JMenuItem("Open source licenses");
    mntmOpenSourceLicenses
            .setToolTipText("View other open source licences for other softwares used with this application");
    mntmOpenSourceLicenses.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            ApacheLicense obj = new ApacheLicense();
            obj.setVisible(true);
        }
    });
    mnLegalInformation.add(mntmOpenSourceLicenses);
    mnHelp.add(mntmNeedHelp);
    contentPane = new JPanel();
    contentPane.setBackground(Color.WHITE);
    contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
    setContentPane(contentPane);
    contentPane.setLayout(null);

    ApplicationStatus = new JLabel("");
    ApplicationStatus.addMouseListener(new MouseAdapter() {
        @Override
        public void mouseClicked(MouseEvent arg0) {
            if (!ApplicationStatus.getText().equals("")) {
                int dialogButton = JOptionPane.YES_NO_OPTION;
                int dialogResult = JOptionPane.showConfirmDialog(null,
                        "Do you want to clear application status?", "Application status", dialogButton);
                if (dialogResult == 0) {
                    ApplicationStatus.setText("");
                }
            }
        }
    });

    JLabel lblApplicationVersion = new JLabel("Version: " + AppVersion);
    lblApplicationVersion.setBounds(818, 150, 135, 22);
    contentPane.add(lblApplicationVersion);
    ApplicationStatus.setBounds(12, 230, 1062, 17);
    contentPane.add(ApplicationStatus);

    RootStatusLabel = new JLabel("");
    RootStatusLabel.setBounds(921, 12, 153, 17);
    RootStatusLabel.setForeground(Color.RED);
    contentPane.add(RootStatusLabel);

    ADBConnectionLabel = new JLabel("");
    ADBConnectionLabel.setBounds(900, 0, 175, 17);
    ADBConnectionLabel.setForeground(Color.GREEN);
    contentPane.add(ADBConnectionLabel);

    JTabbedPane tabbedPane = new JTabbedPane(JTabbedPane.TOP);
    tabbedPane.setBounds(0, 255, 1075, 447);
    contentPane.add(tabbedPane);

    JPanel panel_7 = new JPanel();
    panel_7.setBackground(Color.WHITE);
    tabbedPane.addTab("General", null, panel_7, null);
    panel_7.setLayout(null);

    JButton btnADBTerminal = new JButton("ADB Terminal");
    btnADBTerminal.setToolTipText("Send commands to your android device via ADB protocol, EXPERIMENTAL!");
    btnADBTerminal.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            Terminal obj = new Terminal();
            obj.setVisible(true);
        }
    });

    JButton btnBuildpropeditor = new JButton("build.prop Editor");
    btnBuildpropeditor
            .setToolTipText("Editor for editing build properties of your android device, Use with Caution!");
    btnBuildpropeditor.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            Buildpropeditor obj = new Buildpropeditor();
            obj.setVisible(true);
        }
    });
    btnBuildpropeditor.setBounds(541, 27, 220, 75);
    panel_7.add(btnBuildpropeditor);
    btnADBTerminal.setBounds(25, 27, 220, 75);
    panel_7.add(btnADBTerminal);

    JLabel lblNoteInstallationTo = new JLabel("# Only for android 4.4.x and higher");
    lblNoteInstallationTo.setBounds(20, 311, 1046, 15);
    panel_7.add(lblNoteInstallationTo);

    GeneralDone = new JLabel("");
    GeneralDone.setText("");
    GeneralDone.setBounds(766, 27, 300, 220);
    panel_7.add(GeneralDone);

    JButton btnFileManager = new JButton("File Manager");
    btnFileManager.setToolTipText("Access files on your android device");
    btnFileManager.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            GeneralDone.setText("");
            filemanager.FileManager.main(null);
        }
    });
    btnFileManager.setBounds(25, 131, 220, 75);
    panel_7.add(btnFileManager);

    JLabel lblNeedsRoot = new JLabel(
            "* Needs root access, also may not work with some devices regardless of root access");
    lblNeedsRoot.setBounds(20, 326, 1046, 15);
    panel_7.add(lblNeedsRoot);

    JButton btnScreenshot = new JButton("Screenshot");
    btnScreenshot.setToolTipText("Screenshot your android device screen");
    btnScreenshot.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            try {
                Process p1 = Runtime.getRuntime().exec("adb shell screencap -p /sdcard/screenshot.png");
                p1.waitFor();
                JFileChooser directorychooser = new JFileChooser();
                directorychooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
                directorychooser.setDialogTitle("Select path to save the screenshot");
                FileNameExtensionFilter filter = new FileNameExtensionFilter("PNG Files", "png");
                directorychooser.setFileFilter(filter);
                directorychooser.setApproveButtonText("Save");
                int returnVal = directorychooser.showOpenDialog(getParent());
                if (returnVal == JFileChooser.APPROVE_OPTION) {
                    Process p2 = Runtime.getRuntime().exec("adb pull /sdcard/screenshot.png "
                            + directorychooser.getSelectedFile().getAbsolutePath());
                    p2.waitFor();
                }
                Process p3 = Runtime.getRuntime().exec("adb shell rm /sdcard/screenshot.png");
                p3.waitFor();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    });
    btnScreenshot.setBounds(282, 131, 220, 75);
    panel_7.add(btnScreenshot);

    JButton btnScreenRecorder = new JButton("Screen Recorder #");
    btnScreenRecorder.setToolTipText("Record android device screen");
    btnScreenRecorder.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            String[] options = new String[] { "5 Sec", "30 Sec", "60 Sec", "180 Sec", "Custom" };
            int response = JOptionPane.showOptionDialog(null, "Select duration of recording", "Screen Recorder",
                    JOptionPane.DEFAULT_OPTION, JOptionPane.PLAIN_MESSAGE, null, options, options[0]);
            int time = 0, bitrate = 8000000;
            try {
                if (response == 0) {
                    time = 5;
                }
                if (response == 1) {
                    time = 30;
                }
                if (response == 2) {
                    time = 60;
                }
                if (response == 3) {
                    time = 180;
                }
                if (response == 4) {
                    time = Integer.parseInt(JOptionPane.showInputDialog(null,
                            "Enter the duration of recording in seconds (1 - 180): for ex. 25 for 25 Seconds"));
                    bitrate = Integer.parseInt(JOptionPane.showInputDialog(null,
                            "Enter the bitrate of recording (Default = 8000000 (8Mbps))"));
                }
                JOptionPane.showMessageDialog(null, "You will need to wait for " + time + " seconds, Click ok");
                Process p1 = Runtime.getRuntime().exec("adb shell screenrecord --bit-rate " + bitrate
                        + " --time-limit " + time + " /sdcard/videorecording.mp4");
                p1.waitFor();
                JOptionPane.showMessageDialog(null, "Recording finished, Select destination to save the file");
                JFileChooser directorychooser = new JFileChooser();
                directorychooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
                directorychooser.setDialogTitle("Select path to save the recording");
                FileNameExtensionFilter filter = new FileNameExtensionFilter("MP4 Files", "mp4");
                directorychooser.setFileFilter(filter);
                directorychooser.setApproveButtonText("Save");
                int returnVal = directorychooser.showOpenDialog(getParent());
                if (returnVal == JFileChooser.APPROVE_OPTION) {
                    Process p2 = Runtime.getRuntime().exec("adb pull /sdcard/videorecording.mp4 "
                            + directorychooser.getSelectedFile().getAbsolutePath());
                    p2.waitFor();
                }
                Process p3 = Runtime.getRuntime().exec("adb shell rm /sdcard/videorecording.mp4");
                p3.waitFor();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    });
    btnScreenRecorder.setBounds(541, 131, 220, 75);
    panel_7.add(btnScreenRecorder);

    JButton btnAppManager = new JButton("App Manager");
    btnAppManager.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            GeneralDone.setText("");
            String[] MainOptions = new String[] { "Install apps", "Uninstall apps" };
            int MainResponse = JOptionPane.showOptionDialog(null, "Select an operation", "App Manager",
                    JOptionPane.DEFAULT_OPTION, JOptionPane.PLAIN_MESSAGE, null, MainOptions, MainOptions[0]);
            if (MainResponse == 0) {
                try {
                    GeneralDone.setText("");
                    String[] options = new String[] { "User apps", "Priv-apps", "System apps" };
                    int response = JOptionPane.showOptionDialog(null, "Where to install the app?", "Installer",
                            JOptionPane.DEFAULT_OPTION, JOptionPane.PLAIN_MESSAGE, null, options, options[0]);
                    if (response == 0) {
                        try {
                            GeneralDone.setText("");
                            JFileChooser chooser = new JFileChooser();
                            FileNameExtensionFilter filter = new FileNameExtensionFilter("APK Files", "apk");
                            chooser.setFileFilter(filter);
                            int returnVal = chooser.showOpenDialog(getParent());
                            if (returnVal == JFileChooser.APPROVE_OPTION) {
                                File file = chooser.getSelectedFile();
                                String filename = chooser.getSelectedFile().getName();
                                try {
                                    ApplicationStatus.setText("Installing...");
                                    String[] commands = new String[3];
                                    commands[0] = "adb";
                                    commands[1] = "install";
                                    commands[2] = file.getAbsolutePath();
                                    ApplicationStatus.setText("Installing App...");
                                    Process p1 = Runtime.getRuntime().exec(commands, null);
                                    p1.waitFor();
                                    ApplicationStatus.setText(filename
                                            + " has been successfully installed on your android device!");
                                    GeneralDone.setIcon(
                                            new ImageIcon(Interface.class.getResource("/graphics/Done.png")));
                                } catch (Exception e1) {
                                    System.err.println(e1);
                                }
                            }
                        } catch (Exception e1) {
                        }
                    }
                    if (response == 1) {
                        GeneralDone.setText("");
                        JFileChooser chooser = new JFileChooser();
                        FileNameExtensionFilter filter = new FileNameExtensionFilter("APK Files", "apk");
                        chooser.setFileFilter(filter);
                        int returnVal = chooser.showOpenDialog(getParent());
                        if (returnVal == JFileChooser.APPROVE_OPTION) {
                            File file = chooser.getSelectedFile();
                            try {
                                ApplicationStatus.setText("Installing...");
                                Process p1 = Runtime.getRuntime().exec("adb remount");
                                p1.waitFor();
                                String[] pushcommand = new String[4];
                                pushcommand[0] = "adb";
                                pushcommand[1] = "push";
                                pushcommand[2] = file.getAbsolutePath();
                                pushcommand[3] = "/system/priv-app/";
                                ApplicationStatus.setText("Installing App...");
                                Process p2 = Runtime.getRuntime().exec(pushcommand, null);
                                p2.waitFor();
                                ApplicationStatus.setText("Rebooting your android device");
                                Process p3 = Runtime.getRuntime().exec("adb reboot");
                                p3.waitFor();
                                ApplicationStatus.setText("");
                                GeneralDone.setIcon(
                                        new ImageIcon(Interface.class.getResource("/graphics/Done.png")));
                            } catch (Exception e1) {
                                System.err.println(e1);
                            }
                        }
                    }
                    if (response == 2) {
                        GeneralDone.setText("");
                        JFileChooser chooser = new JFileChooser();
                        FileNameExtensionFilter filter = new FileNameExtensionFilter("APK Files", "apk");
                        chooser.setFileFilter(filter);
                        int returnVal = chooser.showOpenDialog(getParent());
                        if (returnVal == JFileChooser.APPROVE_OPTION) {
                            File file = chooser.getSelectedFile();
                            try {
                                ApplicationStatus.setText("Installing...");
                                Process p1 = Runtime.getRuntime().exec("adb remount");
                                p1.waitFor();
                                String[] pushcommand = new String[4];
                                pushcommand[0] = "adb";
                                pushcommand[1] = "push";
                                pushcommand[2] = file.getAbsolutePath();
                                pushcommand[3] = "/system/app/";
                                Process p2 = Runtime.getRuntime().exec(pushcommand, null);
                                p2.waitFor();
                                ApplicationStatus.setText("Rebooting your android device");
                                Process p3 = Runtime.getRuntime().exec("adb reboot");
                                p3.waitFor();
                                ApplicationStatus.setText("");
                                GeneralDone.setIcon(
                                        new ImageIcon(Interface.class.getResource("/graphics/Done.png")));
                            } catch (Exception e1) {
                                System.err.println(e1);
                            }
                        }
                    }
                } catch (Exception e1) {
                }
            }
            if (MainResponse == 1) {
                try {
                    GeneralDone.setText("");
                    String[] options = new String[] { "User apps", "Priv-apps", "System apps" };
                    int response = JOptionPane.showOptionDialog(null,
                            "Which kind of app you want to uninstall?", "Uninstaller",
                            JOptionPane.DEFAULT_OPTION, JOptionPane.PLAIN_MESSAGE, null, options, options[0]);
                    if (response == 0) {
                        try {
                            UninstallUserApps obj = new UninstallUserApps();
                            obj.setVisible(true);
                        } catch (Exception e1) {
                        }
                    }
                    if (response == 1) {
                        try {
                            UninstallPrivApps obj = new UninstallPrivApps();
                            obj.setVisible(true);
                        } catch (Exception e1) {
                        }
                    }
                    if (response == 2) {
                        try {
                            UninstallSystemApps obj = new UninstallSystemApps();
                            obj.setVisible(true);
                        } catch (Exception e1) {
                        }
                    }
                } catch (Exception e1) {
                }
            }
        }
    });
    btnAppManager.setToolTipText("Manage Apps on your android device");
    btnAppManager.setBounds(282, 27, 220, 75);
    panel_7.add(btnAppManager);

    JLabel lblInstallationAndUninstallation = new JLabel(
            "Installation and Uninstallation of apps to Priv-app is only for android 4.4 and higher, requires root and even simply may not work on your device!");
    lblInstallationAndUninstallation.setBounds(20, 356, 1046, 15);
    panel_7.add(lblInstallationAndUninstallation);

    JLabel lblInstallationAndUninstallation_1 = new JLabel(
            "Installation and Uninstallation of apps to System requires root, and may not work for your device!");
    lblInstallationAndUninstallation_1.setBounds(20, 341, 1046, 15);
    panel_7.add(lblInstallationAndUninstallation_1);

    JPanel panel_8 = new JPanel();
    panel_8.setBackground(Color.WHITE);
    tabbedPane.addTab("Advanced", null, panel_8, null);
    panel_8.setLayout(null);

    JButton btnMemoryInformation = new JButton("Memory Information");
    btnMemoryInformation.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            Memoryinfo obj = new Memoryinfo();
            obj.setVisible(true);
        }
    });

    JButton btnClearBatteryStats = new JButton("Clear Battery Stats *");
    btnClearBatteryStats.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            try {
                Process p1 = Runtime.getRuntime().exec("adb remount");
                p1.waitFor();
                Process p2 = Runtime.getRuntime().exec("adb shell su -c rm -r /data/system/batterystats.bin");
                p2.waitFor();
                String[] options = new String[] { "Yes", "No" };
                int response = JOptionPane.showOptionDialog(null, "Done, would you like to reboot your device?",
                        "Reboot device? (Recommended)", JOptionPane.DEFAULT_OPTION, JOptionPane.PLAIN_MESSAGE,
                        null, options, options[0]);
                if (response == 0) {
                    try {
                        Process p3 = Runtime.getRuntime().exec("adb reboot");
                        p3.waitFor();
                    } catch (Exception e1) {
                    }
                }
            } catch (Exception e1) {
                e1.printStackTrace();
            }
        }
    });
    btnClearBatteryStats.setToolTipText("Clear outdated or invalid battery stats");
    btnClearBatteryStats.setBounds(25, 131, 220, 75);
    panel_8.add(btnClearBatteryStats);
    btnMemoryInformation.setToolTipText("View current memory information of android device");
    btnMemoryInformation.setBounds(25, 236, 220, 75);
    panel_8.add(btnMemoryInformation);

    JButton btnBatteryInformation = new JButton("Battery Information");
    btnBatteryInformation.addActionListener(new ActionListener() {

        public void actionPerformed(ActionEvent e) {
            Batteryinfo obj = new Batteryinfo();
            obj.setVisible(true);
        }
    });
    btnBatteryInformation.setToolTipText("View current battery information of android device");
    btnBatteryInformation.setBounds(541, 27, 220, 75);
    panel_8.add(btnBatteryInformation);

    JButton btnCpuInformation = new JButton("CPU Information");
    btnCpuInformation.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            CPUinfo obj = new CPUinfo();
            obj.setVisible(true);
        }
    });
    btnCpuInformation.setToolTipText("View current CPU information of android device");
    btnCpuInformation.setBounds(282, 131, 220, 75);
    panel_8.add(btnCpuInformation);

    JButton btnAppInformation = new JButton("App Information");
    btnAppInformation.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            Appinfo obj = new Appinfo();
            obj.setVisible(true);
        }
    });
    btnAppInformation.setToolTipText("View current app information of android device");
    btnAppInformation.setBounds(25, 27, 220, 75);
    panel_8.add(btnAppInformation);

    JButton btnKillApps = new JButton("Kill Apps");
    btnKillApps.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            String[] options = new String[] { "Enter package name", "Kill all apps" };
            int response = JOptionPane.showOptionDialog(null, "Which app(s) should be killed?", "Kill Apps",
                    JOptionPane.DEFAULT_OPTION, JOptionPane.PLAIN_MESSAGE, null, options, options[0]);
            if (response == 0) {
                try {
                    JOptionPane.showMessageDialog(null,
                            "You can find an app package name from App Packages List");
                    String selectedapp = (JOptionPane.showInputDialog(null, "Enter app's package name:"));
                    Process p1 = Runtime.getRuntime().exec("adb shell am force-stop " + selectedapp);
                    p1.waitFor();
                    JOptionPane.showMessageDialog(null, selectedapp + " has been killed");
                } catch (Exception e1) {
                }
            }
            if (response == 1) {
                try {
                    Process p1 = Runtime.getRuntime().exec("adb shell am kill-all");
                    p1.waitFor();
                    JOptionPane.showMessageDialog(null, "All 'safe to kill' apps have been killed");
                } catch (Exception e1) {
                }
            }
        }
    });
    btnKillApps.setToolTipText("Kill any app currently running on android device");
    btnKillApps.setBounds(541, 131, 220, 75);
    panel_8.add(btnKillApps);

    JButton btnWifiInformation = new JButton("WiFi Information");
    btnWifiInformation.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            Wifiinfo obj = new Wifiinfo();
            obj.setVisible(true);
        }
    });
    btnWifiInformation.setToolTipText("View current wifi information of android device");
    btnWifiInformation.setBounds(541, 236, 220, 75);
    panel_8.add(btnWifiInformation);

    JButton btnAppPackageList = new JButton("App Packages List");
    btnAppPackageList.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            AppPackagesList obj = new AppPackagesList();
            obj.setVisible(true);
        }
    });
    btnAppPackageList.setToolTipText("View all installed app packages list information");
    btnAppPackageList.setBounds(282, 27, 220, 75);
    panel_8.add(btnAppPackageList);

    JLabel lblAdvancedToolsNote = new JLabel(
            "Note: All of the above tools are not supported by every device or ROM");
    lblAdvancedToolsNote.setBounds(25, 345, 736, 15);
    panel_8.add(lblAdvancedToolsNote);

    JButton btnUnroot = new JButton("Unroot Device");
    btnUnroot.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            try {
                File file1 = new File(".events");
                if (!file1.exists()) {
                    List<String> lines = Arrays.asList("Unroot_Warning_Shown = True");
                    Path file = Paths.get(".events");
                    Files.write(file, lines, Charset.forName("UTF-8"));
                    JOptionPane.showMessageDialog(null,
                            "Only the SU Binary will get removed since there are lot of different root management\napplications for android available, I can't regularly search for them and add their\nsupport to this application. If you think this concerns you, you can help me by sending\nme a list of root management applicationsfor android like supersu, kingroot, kingoroot,\netc. But I can't promise that I will add support for each of them. Cheers! :)");
                }
                JOptionPane.showMessageDialog(null, "Unrooting work only on non-production builds of android");
                Process p1 = Runtime.getRuntime().exec("adb pull /system/xbin/su");
                p1.waitFor();
                File file2 = new File("su");
                if (file2.exists() && !file2.isDirectory()) {
                    file2.delete();
                    Process p2 = Runtime.getRuntime().exec("adb remount");
                    p2.waitFor();
                    Process p3 = Runtime.getRuntime().exec("adb shell su -c rm -r /system/xbin/su");
                    p3.waitFor();
                    JOptionPane.showMessageDialog(null, "Operation completed");
                } else {
                    JOptionPane.showMessageDialog(null, "This device is not rooted");
                }
            } catch (Exception e1) {
                e1.printStackTrace();
            }
        }
    });
    btnUnroot.setToolTipText("Unroot device by removing SU binary from the device");
    btnUnroot.setBounds(282, 236, 220, 75);
    panel_8.add(btnUnroot);

    JLabel lblNewLabel_1 = new JLabel(
            "* Needs root access, also may not work with some devices regardless of root access");
    lblNewLabel_1.setBounds(25, 372, 736, 15);
    panel_8.add(lblNewLabel_1);

    JPanel panel_10 = new JPanel();
    panel_10.setBackground(Color.WHITE);
    tabbedPane.addTab("Developer", null, panel_10, null);
    panel_10.setLayout(null);

    JButton btnUnpackAPKs = new JButton("Unpack APKs");
    btnUnpackAPKs.addActionListener(new ActionListener() {
        private Component parentFrame;

        public void actionPerformed(ActionEvent e) {
            File path = null;
            JFileChooser chooser1 = new JFileChooser();
            chooser1.setDialogTitle("Select an APK file to extract");
            FileNameExtensionFilter filter = new FileNameExtensionFilter("APK Files", "apk");
            chooser1.setCurrentDirectory(new java.io.File("."));
            chooser1.setFileFilter(filter);
            int returnVal = chooser1.showOpenDialog(getParent());
            if (returnVal == JFileChooser.APPROVE_OPTION) {
                File file = chooser1.getSelectedFile();
                String filename = chooser1.getSelectedFile().getName();
                JFileChooser chooser2 = new JFileChooser();
                chooser2.setDialogTitle("Extract APK file to");
                chooser2.setCurrentDirectory(new java.io.File("."));
                chooser2.setAcceptAllFileFilterUsed(false);
                chooser2.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
                int userSelection = chooser2.showSaveDialog(parentFrame);
                if (userSelection == JFileChooser.APPROVE_OPTION) {
                    path = chooser2.getSelectedFile();
                }
                String outputDir = path.getAbsolutePath();
                java.util.zip.ZipFile zipFile = null;
                try {
                    zipFile = new ZipFile(file);
                    Enumeration<? extends ZipEntry> entries = zipFile.entries();
                    while (entries.hasMoreElements()) {
                        ZipEntry entry = entries.nextElement();
                        File entryDestination = new File(outputDir, entry.getName());
                        if (entry.isDirectory()) {
                            entryDestination.mkdirs();
                        } else {
                            entryDestination.getParentFile().mkdirs();
                            InputStream in = zipFile.getInputStream(entry);
                            OutputStream out = null;
                            out = new FileOutputStream(entryDestination);
                            IOUtils.copy(in, out);
                            IOUtils.closeQuietly(in);
                            out.close();
                        }
                    }
                    zipFile.close();
                    JOptionPane.showMessageDialog(null, filename + " has been successfully extracted");
                } catch (Exception e1) {
                    e1.printStackTrace();
                    JOptionPane.showMessageDialog(null, "An error occured");
                }
            }
        }
    });
    btnUnpackAPKs.setToolTipText("Unpack APKs stored on disk");
    btnUnpackAPKs.setBounds(541, 27, 220, 75);
    panel_10.add(btnUnpackAPKs);

    JButton btnRepackAPKs = new JButton("Repack APKs");
    btnRepackAPKs.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            new Repacker();
        }
    });
    btnRepackAPKs.setToolTipText("Repack previously unpacked APKs and save to them to disk");
    btnRepackAPKs.setBounds(25, 27, 220, 75);
    panel_10.add(btnRepackAPKs);

    JButton btnStartAnActivity = new JButton("Start an activity *");
    btnStartAnActivity.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            try {
                String packagename = JOptionPane.showInputDialog(null, "Enter the package name of the app",
                        "com.package.name");
                String activityname = JOptionPane.showInputDialog(null, "Enter the activity name of the app",
                        "MainActivity");
                Process p1 = Runtime.getRuntime().exec("adb shell am start -n " + packagename + "/"
                        + packagename + "com.package.name." + activityname);
                p1.waitFor();
            } catch (Exception e1) {
                e1.printStackTrace();
            }

        }
    });
    btnStartAnActivity.setToolTipText("Start an actvity of an android app on your android device");
    btnStartAnActivity.setBounds(282, 27, 220, 75);
    panel_10.add(btnStartAnActivity);

    JLabel lblActivityWill = new JLabel(
            "* An activity will not start if you enter wrong package name or activity name");
    lblActivityWill.setBounds(25, 381, 736, 15);
    panel_10.add(lblActivityWill);

    JPanel panel_5 = new JPanel();
    panel_5.setBackground(Color.WHITE);
    tabbedPane.addTab("Backup & Restore", null, panel_5, null);
    panel_5.setLayout(null);

    BackupAndRestoreDone = new JLabel("");
    BackupAndRestoreDone.setText("");
    BackupAndRestoreDone.setBounds(758, 70, 300, 220);
    panel_5.add(BackupAndRestoreDone);

    JLabel lblRestoreOperations = new JLabel("Restore Operations");
    lblRestoreOperations.setBounds(541, 12, 142, 36);
    panel_5.add(lblRestoreOperations);

    final JButton btnRestoreFromCustomLocationBackup = new JButton("From Custom Location");
    btnRestoreFromCustomLocationBackup
            .setToolTipText("Restore data to android device from the backup stored somewhere on the computer");
    btnRestoreFromCustomLocationBackup.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            BackupAndRestoreDone.setText("");
            JFileChooser chooser = new JFileChooser();
            FileNameExtensionFilter filter = new FileNameExtensionFilter("Android Backup Files", "ab");
            chooser.setFileFilter(filter);
            int returnVal = chooser.showOpenDialog(getParent());
            if (returnVal == JFileChooser.APPROVE_OPTION) {
                File file = chooser.getSelectedFile();
                try {
                    ApplicationStatus.setText("Restoring may take upto several minutes, please be patient...");
                    JOptionPane.showMessageDialog(null,
                            "Unlock your device and confirm the restore operation when asked");
                    String[] commands = new String[3];
                    commands[0] = "adb";
                    commands[1] = "restore";
                    commands[2] = file.getAbsolutePath();
                    ApplicationStatus.setText("Restoring...");
                    Process p1 = Runtime.getRuntime().exec(commands, null);
                    p1.waitFor();
                    ApplicationStatus.setText("Restore completed successfully!");
                    BackupAndRestoreDone
                            .setIcon(new ImageIcon(Interface.class.getResource("/graphics/Done.png")));
                    btnRestoreFromCustomLocationBackup.setSelected(false);
                } catch (Exception e1) {
                    System.err.println(e1);
                }
            }
        }
    });

    btnRestoreFromCustomLocationBackup.setBounds(510, 70, 220, 75);
    panel_5.add(btnRestoreFromCustomLocationBackup);

    JLabel lblBackup = new JLabel("Backup Operations");
    lblBackup.setBounds(192, 12, 142, 36);
    panel_5.add(lblBackup);

    final JButton btnBackupInternelStorage = new JButton("Internel Storage");
    btnBackupInternelStorage.setToolTipText("Backup android device internal storage");
    btnBackupInternelStorage.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            BackupAndRestoreDone.setText("");
            try {
                ApplicationStatus.setText("Backup can take upto several minutes, please be patient...");
                JOptionPane.showMessageDialog(null,
                        "Unlock your device and confirm the backup operation when asked");
                String[] commands = new String[3];
                commands[0] = "adb";
                commands[1] = "backup";
                commands[2] = "-shared";
                ApplicationStatus.setText("Performing backup...");
                Process p1 = Runtime.getRuntime().exec(commands, null);
                p1.waitFor();
                ApplicationStatus.setText("Backup completed successfully!");
                BackupAndRestoreDone.setIcon(new ImageIcon(Interface.class.getResource("/graphics/Done.png")));
                btnBackupInternelStorage.setSelected(false);
            } catch (Exception e1) {
                System.err.println(e1);
            }
        }
    });

    btnBackupInternelStorage.setBounds(270, 70, 220, 75);
    panel_5.add(btnBackupInternelStorage);

    final JButton btnBackupSingleApp = new JButton("Single App");
    btnBackupSingleApp.setToolTipText("Backup a single app from android device");
    btnBackupSingleApp.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            BackupAndRestoreDone.setText("");
            try {
                String message = JOptionPane.showInputDialog(null, "Please specify a package name to backup");
                ApplicationStatus.setText("Backup can take upto several minutes, please be patient...");
                JOptionPane.showMessageDialog(null,
                        "Unlock your device and confirm the backup operation when asked");
                String[] commands = new String[3];
                commands[0] = "adb";
                commands[1] = "backup";
                commands[2] = message;
                ApplicationStatus.setText("Performing backup...");
                Process p1 = Runtime.getRuntime().exec(commands, null);
                p1.waitFor();
                ApplicationStatus.setText("Backup completed successfully!");
                BackupAndRestoreDone.setIcon(new ImageIcon(Interface.class.getResource("/graphics/Done.png")));
                btnBackupSingleApp.setSelected(false);
            } catch (Exception e1) {
                System.err.println(e1);
            }
        }
    });

    btnBackupSingleApp.setBounds(25, 184, 220, 75);
    panel_5.add(btnBackupSingleApp);

    final JButton btnBackupAppAndAppData = new JButton("App and App Data");
    btnBackupAppAndAppData.setToolTipText("Backup app and it's data from android device");
    btnBackupAppAndAppData.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            BackupAndRestoreDone.setText("");
            try {
                ApplicationStatus.setText("Backup can take upto several minutes, please be patient...");
                JOptionPane.showMessageDialog(null,
                        "Unlock your device and confirm the backup operation when asked");
                String[] commands = new String[3];
                commands[0] = "adb";
                commands[1] = "backup";
                commands[2] = "-all";
                ApplicationStatus.setText("Performing backup...");
                Process p1 = Runtime.getRuntime().exec(commands, null);
                p1.waitFor();
                ApplicationStatus.setText("Backup completed successfully!");
                BackupAndRestoreDone.setIcon(new ImageIcon(Interface.class.getResource("/graphics/Done.png")));
                btnBackupAppAndAppData.setSelected(false);
            } catch (Exception e1) {
                System.err.println(e1);
            }
        }
    });

    btnBackupAppAndAppData.setBounds(25, 70, 220, 75);
    panel_5.add(btnBackupAppAndAppData);

    final JButton btnBackupWholeDevice = new JButton("Whole Device");
    btnBackupWholeDevice.setToolTipText("Backup whole android device");
    btnBackupWholeDevice.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            BackupAndRestoreDone.setText("");
            try {
                ApplicationStatus.setText("Backup can take upto several minutes, please be patient...");
                JOptionPane.showMessageDialog(null,
                        "Unlock your device and confirm the backup operation when asked");
                String[] commands = new String[6];
                commands[0] = "adb";
                commands[1] = "backup";
                commands[2] = "-all";
                commands[3] = "-apk";
                commands[4] = "-shared";
                commands[5] = "-system";
                ApplicationStatus.setText("Performing backup...");
                Process p1 = Runtime.getRuntime().exec(commands, null);
                p1.waitFor();
                ApplicationStatus.setText("Backup completed successfully");
                BackupAndRestoreDone.setIcon(new ImageIcon(Interface.class.getResource("/graphics/Done.png")));
                btnBackupWholeDevice.setSelected(false);
            } catch (Exception e1) {
                System.err.println(e1);
            }
        }
    });

    btnBackupWholeDevice.setBounds(25, 303, 220, 75);
    panel_5.add(btnBackupWholeDevice);

    final JButton btnRestorePreviousBackup = new JButton("Previous Backup");
    btnRestorePreviousBackup.setToolTipText("Restore data to android device from the previous backup");
    btnRestorePreviousBackup.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            BackupAndRestoreDone.setText("");
            try {
                ApplicationStatus.setText("Restoring can take upto several minutes, please be patient...");
                JOptionPane.showMessageDialog(null,
                        "Unlock your device and confirm the restore operation when asked");
                String[] commands = new String[3];
                commands[0] = "adb";
                commands[1] = "restore";
                commands[2] = "backup.ab";
                ApplicationStatus.setText("Restoring...");
                Process p1 = Runtime.getRuntime().exec(commands, null);
                p1.waitFor();
                ApplicationStatus.setText("Restore completed successfully!");
                BackupAndRestoreDone.setIcon(new ImageIcon(Interface.class.getResource("/graphics/Done.png")));
                btnRestorePreviousBackup.setSelected(false);
            } catch (Exception e1) {
                System.err.println(e1);
            }
        }
    });

    btnRestorePreviousBackup.setBounds(510, 184, 220, 75);
    panel_5.add(btnRestorePreviousBackup);

    final JButton btnBackupSystem = new JButton("System");
    btnBackupSystem.setToolTipText("Backup android device system");
    btnBackupSystem.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            BackupAndRestoreDone.setText("");
            try {
                ApplicationStatus.setText("Backup can take upto several minutes, please be patient...");
                JOptionPane.showMessageDialog(null,
                        "Unlock your device and confirm the backup operation when asked");
                String[] commands = new String[3];
                commands[0] = "adb";
                commands[1] = "backup";
                commands[2] = "-system";
                ApplicationStatus.setText("Performing backup...");
                Process p1 = Runtime.getRuntime().exec(commands, null);
                p1.waitFor();
                ApplicationStatus.setText("Backup completed successfully!");
                BackupAndRestoreDone.setIcon(new ImageIcon(Interface.class.getResource("/graphics/Done.png")));
                btnBackupSystem.setSelected(false);
            } catch (Exception e1) {
                System.err.println(e1);
            }
        }
    });

    btnBackupSystem.setBounds(270, 184, 220, 75);
    panel_5.add(btnBackupSystem);

    JPanel panel_2 = new JPanel();
    panel_2.setBackground(Color.WHITE);
    tabbedPane.addTab("Rebooter", null, panel_2, null);
    panel_2.setLayout(null);

    JLabel lblRebootFrom = new JLabel("Reboot from :");
    lblRebootFrom.setBounds(25, 180, 220, 15);
    panel_2.add(lblRebootFrom);

    JLabel lblRebootTo = new JLabel("Reboot to :");
    lblRebootTo.setBounds(25, 12, 220, 15);
    panel_2.add(lblRebootTo);

    JLabel lblNotFor = new JLabel("# Not for Samsung devices");
    lblNotFor.setBounds(514, 359, 238, 19);
    panel_2.add(lblNotFor);

    JLabel lblDeviceMust_1 = new JLabel("Device must be in fastboot mode (Except for Reboot System)");
    lblDeviceMust_1.setBounds(25, 332, 479, 19);
    panel_2.add(lblDeviceMust_1);

    JLabel lblYouMust_1 = new JLabel("* You must have a bootloader that supports fastboot commands");
    lblYouMust_1.setBounds(25, 359, 470, 19);
    panel_2.add(lblYouMust_1);

    JButton btnRebootFromFastboot = new JButton("Fastboot *");
    btnRebootFromFastboot.setToolTipText("Reboot android device from fastboot mode to normal");
    btnRebootFromFastboot.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            try {
                ApplicationStatus.setText("Rebooting...");
                Process p1 = Runtime.getRuntime().exec("fastboot reboot");
                p1.waitFor();
                ApplicationStatus.setText("Done");
            } catch (Exception e1) {
                System.err.println(e1);
            }
        }
    });

    btnRebootFromFastboot.setBounds(28, 232, 220, 75);
    panel_2.add(btnRebootFromFastboot);

    JButton btnRebootToBootloaderFromFastboot = new JButton("Fastboot to Bootloader *");
    btnRebootToBootloaderFromFastboot.setToolTipText("Reboot to Bootloader mode while accessing fastboot mode");
    btnRebootToBootloaderFromFastboot.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            try {
                ApplicationStatus.setText("Rebooting...");
                Process p1 = Runtime.getRuntime().exec("fasboot reboot-bootloader");
                p1.waitFor();
                ApplicationStatus.setText("Done");
            } catch (Exception e1) {
                System.err.println(e1);
            }
        }
    });

    btnRebootToBootloaderFromFastboot.setBounds(281, 232, 220, 75);
    panel_2.add(btnRebootToBootloaderFromFastboot);

    JButton btnRebootToFastboot = new JButton("Fastboot");
    btnRebootToFastboot.setToolTipText("Reboot android device to fastboot mode");
    btnRebootToFastboot.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            try {
                ApplicationStatus.setText("Rebooting...");
                Process p1 = Runtime.getRuntime().exec("adb reboot fastboot");
                p1.waitFor();
                ApplicationStatus.setText("Done");
            } catch (Exception e1) {
                System.err.println(e1);
            }
        }
    });

    btnRebootToFastboot.setBounds(281, 55, 220, 75);
    panel_2.add(btnRebootToFastboot);

    JButton btnRebootToBootloader = new JButton("Bootloader #");
    btnRebootToBootloader.setToolTipText("Reboot android device to bootloader mode");
    btnRebootToBootloader.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            try {
                ApplicationStatus.setText("Rebooting...");
                Process p1 = Runtime.getRuntime().exec("adb reboot bootloader");
                p1.waitFor();
                ApplicationStatus.setText("Done");
            } catch (Exception e1) {
                System.err.println(e1);
            }
        }
    });

    btnRebootToBootloader.setBounds(28, 55, 220, 75);
    panel_2.add(btnRebootToBootloader);

    JButton btnRebootToRecovery = new JButton("Recovery");
    btnRebootToRecovery.setToolTipText("Reboot android device to recovery mode");
    btnRebootToRecovery.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            try {
                ApplicationStatus.setText("Rebooting...");
                Process p1 = Runtime.getRuntime().exec("adb reboot recovery");
                p1.waitFor();
                ApplicationStatus.setText("Done");
            } catch (Exception e1) {
                System.err.println(e1);
            }
        }
    });

    btnRebootToRecovery.setBounds(532, 55, 220, 75);
    panel_2.add(btnRebootToRecovery);

    JButton btnRebootSystem = new JButton("System");
    btnRebootSystem.setToolTipText("Reboot android device normally");
    btnRebootSystem.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            try {
                ApplicationStatus.setText("Rebooting...");
                Process p1 = Runtime.getRuntime().exec("adb reboot");
                p1.waitFor();
                ApplicationStatus.setText("Done");
            } catch (Exception e1) {
                System.err.println(e1);
            }
        }
    });

    btnRebootSystem.setBounds(785, 55, 220, 75);
    panel_2.add(btnRebootSystem);

    JPanel panel_9 = new JPanel();
    panel_9.setBackground(Color.WHITE);
    tabbedPane.addTab("Bypass Security", null, panel_9, null);
    panel_9.setLayout(null);

    JLabel lblRootOperationsexperimental = new JLabel(
            "Method #1 : Root Operations (Recommended) [EXPERIMENTAL] :");
    lblRootOperationsexperimental.setBounds(12, 12, 507, 15);
    panel_9.add(lblRootOperationsexperimental);

    JButton btnPattern = new JButton("Pattern #");
    btnPattern.setToolTipText("Remove pattern security from android device (Experimental)");
    btnPattern.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            try {
                ApplicationStatus.setText("Trying to break into security...");
                Process p1 = Runtime.getRuntime().exec("adb shell su -c rm /data/system/gesture.key");
                p1.waitFor();
                ApplicationStatus.setText(
                        "Done, now try to unlock the device with a random pattern then change security manually from settings");
            } catch (Exception e1) {
            }
        }
    });

    btnPattern.setBounds(220, 75, 220, 75);
    panel_9.add(btnPattern);

    JButton btnPasswordPin = new JButton("Password/ PIN #");
    btnPasswordPin.setToolTipText("Remove password or pin security from android device (Experimental)");
    btnPasswordPin.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            try {
                ApplicationStatus.setText("Trying to break into security...");
                Process p1 = Runtime.getRuntime().exec("adb shell su -c rm /data/system/password.key");
                p1.waitFor();
                ApplicationStatus.setText("Done, check your device...");
            } catch (Exception e1) {
                System.err.println(e1);
            }
        }
    });

    btnPasswordPin.setBounds(630, 75, 220, 75);
    panel_9.add(btnPasswordPin);

    JLabel lblMayNot = new JLabel("# Works on Android 4.4.x and lower");
    lblMayNot.setBounds(630, 250, 366, 15);
    panel_9.add(lblMayNot);

    JLabel lblNonRoot = new JLabel("Method # 2 : Non - Root/ Root Operations [EXPERIMENTAL] :");
    lblNonRoot.setBounds(12, 191, 507, 15);
    panel_9.add(lblNonRoot);

    JButton btnJellyBeanPatternPinPassword = new JButton("Pattern/ PIN/ Password *");
    btnJellyBeanPatternPinPassword
            .setToolTipText("Remove pattern, pin or password security from android device (Experimental)");
    btnJellyBeanPatternPinPassword.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            try {
                ApplicationStatus.setText("Trying to break into security...");
                Process p1 = Runtime.getRuntime().exec(
                        "adb shell am start -n com.android.settings/com.android.settings.ChooseLockGeneric --ez confirm_credentials false --ei lockscreen.password_type 0 --activity-clear-task");
                p1.waitFor();
                ApplicationStatus.setText("Rebooting...");
                Process p2 = Runtime.getRuntime().exec("adb reboot");
                p2.waitFor();
                ApplicationStatus.setText("Done, check your device...");
            } catch (Exception e1) {
                System.err.println(e1);
            }
        }
    });

    btnJellyBeanPatternPinPassword.setBounds(220, 250, 220, 75);
    panel_9.add(btnJellyBeanPatternPinPassword);

    JLabel lblWorksWell = new JLabel("* Works well on Jelly Bean Devices but may or");
    lblWorksWell.setBounds(630, 273, 366, 15);
    panel_9.add(lblWorksWell);

    JLabel lblNewLabel = new JLabel("may not work for older/ newer android versions");
    lblNewLabel.setBounds(640, 293, 356, 15);
    panel_9.add(lblNewLabel);

    JPanel panel_4 = new JPanel();
    panel_4.setBackground(Color.WHITE);
    tabbedPane.addTab("Logger", null, panel_4, null);
    panel_4.setLayout(null);

    JScrollPane scrollPane = new JScrollPane();
    scrollPane.setBounds(0, 72, 1072, 285);
    panel_4.add(scrollPane);

    LogViewer = new JTextArea();
    LogViewer.setEditable(false);
    scrollPane.setViewportView(LogViewer);

    JButton btnSaveAsTextFile = new JButton("Save as a text file");
    btnSaveAsTextFile.setToolTipText("Save printed logcat as a text file on computer");
    btnSaveAsTextFile.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            if (LogViewer.getText().equals("")) {
                JOptionPane.showMessageDialog(null, "No log found, please click view log");
            } else {
                ApplicationStatus.setText("");
                JFrame parentFrame = new JFrame();
                JFileChooser fileChooser = new JFileChooser();
                FileNameExtensionFilter filter = new FileNameExtensionFilter("Text Files", "txt");
                fileChooser.setFileFilter(filter);
                fileChooser.setDialogTitle("Save as a text file");
                int userSelection = fileChooser.showSaveDialog(parentFrame);
                if (userSelection == JFileChooser.APPROVE_OPTION) {
                    File fileToSave = fileChooser.getSelectedFile();
                    FileWriter write = null;
                    try {
                        write = new FileWriter(fileToSave.getAbsolutePath() + ".txt");
                        LogViewer.write(write);
                        ApplicationStatus.setText("Logcat saved");
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        if (write != null)
                            try {
                                write.close();
                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                    }
                }
            }
        }
    });

    btnSaveAsTextFile.setBounds(420, 13, 220, 47);
    panel_4.add(btnSaveAsTextFile);

    JButton btnClearLogcat = new JButton("Clear");
    btnClearLogcat.setToolTipText("Clean the printed logcat from the screen");
    btnClearLogcat.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            LogViewer.setText("");
            File file = new File(".logcat.txt");
            if (file.exists() && !file.isDirectory()) {
                file.delete();
            }
            ApplicationStatus.setText("Logcat cleared");
        }
    });
    btnClearLogcat.setBounds(12, 13, 220, 48);
    panel_4.add(btnClearLogcat);

    JButton btnViewLogcat = new JButton("View Logcat");
    btnViewLogcat.setToolTipText("Print android device logcat on screen");
    btnViewLogcat.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            ApplicationStatus.setText("Generating logcat, please wait a moment...");
            try {
                Process p1 = Runtime.getRuntime().exec("adb logcat -d > /sdcard/.logcat.txt");
                p1.waitFor();
                Process p2 = Runtime.getRuntime().exec("adb logcat -c");
                p2.waitFor();
                Process p3 = Runtime.getRuntime().exec("adb pull /sdcard/.logcat.txt");
                p3.waitFor();
                Process p4 = Runtime.getRuntime().exec("adb shell rm /sdcard/.logcat.txt");
                p4.waitFor();
                try {
                    Reader reader = new FileReader(new File(".logcat.txt"));
                    LogViewer.read(reader, "");
                } catch (Exception e) {
                    e.printStackTrace();
                }
                File file = new File(".logcat.txt");
                if (file.exists() && !file.isDirectory()) {
                    file.delete();
                }
                ApplicationStatus.setText("");
            } catch (Exception e) {
                System.err.println(e);
            }
        }
    });

    btnViewLogcat.setBounds(838, 13, 220, 47);
    panel_4.add(btnViewLogcat);

    JLabel lblNoteLogcatG = new JLabel(
            "Note: Logcat generation takes some time, program may not respond for a few moments");
    lblNoteLogcatG.setBounds(12, 364, 1046, 15);
    panel_4.add(lblNoteLogcatG);

    JPanel panel = new JPanel();
    panel.setBackground(Color.WHITE);
    tabbedPane.addTab("Flasher", null, panel, null);
    panel.setLayout(null);

    final JButton btnFlashSystem = new JButton("System");
    btnFlashSystem.setToolTipText("Flash system partition");
    btnFlashSystem.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            FlasherDone.setText("");
            JFileChooser chooser = new JFileChooser();
            FileNameExtensionFilter filter = new FileNameExtensionFilter("IMG Files", "img");
            chooser.setFileFilter(filter);
            int returnVal = chooser.showOpenDialog(getParent());
            if (returnVal == JFileChooser.APPROVE_OPTION) {
                File file = chooser.getSelectedFile();
                String filename = chooser.getSelectedFile().getName();
                try {
                    ApplicationStatus.setText("Flashing...");
                    Process p1 = Runtime.getRuntime().exec("fastboot erase system");
                    p1.waitFor();
                    String[] commands = new String[4];
                    commands[0] = "fastboot";
                    commands[1] = "flash";
                    commands[2] = "system";
                    commands[3] = file.getAbsolutePath();
                    Process p2 = Runtime.getRuntime().exec(commands, null);
                    p2.waitFor();
                    ApplicationStatus
                            .setText(filename + "has been successfully flashed on your android device");
                    FlasherDone.setIcon(new ImageIcon(Interface.class.getResource("/graphics/Done.png")));
                    btnFlashSystem.setSelected(false);
                } catch (Exception e1) {
                    System.err.println(e1);
                }
            }
        }
    });

    final JButton btnFlashData = new JButton("Data");
    btnFlashData.setToolTipText("Flash data partition");
    btnFlashData.addActionListener(new ActionListener() {

        public void actionPerformed(ActionEvent e) {
            FlasherDone.setText("");
            JFileChooser chooser = new JFileChooser();
            FileNameExtensionFilter filter = new FileNameExtensionFilter("IMG Files", "img");
            chooser.setFileFilter(filter);
            int returnVal = chooser.showOpenDialog(getParent());
            if (returnVal == JFileChooser.APPROVE_OPTION) {
                File file = chooser.getSelectedFile();
                String filename = chooser.getSelectedFile().getName();
                try {
                    ApplicationStatus.setText("Flashing...");
                    Process p1 = Runtime.getRuntime().exec("fastboot erase data");
                    p1.waitFor();
                    String[] commands = new String[4];
                    commands[0] = "fastboot";
                    commands[1] = "flash";
                    commands[2] = "data";
                    commands[3] = file.getAbsolutePath();
                    Process p2 = Runtime.getRuntime().exec(commands, null);
                    p2.waitFor();
                    ApplicationStatus
                            .setText(filename + "has been successfully flashed on your android device");
                    FlasherDone.setIcon(new ImageIcon(Interface.class.getResource("/graphics/Done.png")));
                    btnFlashData.setSelected(false);
                } catch (Exception e1) {
                    System.err.println(e1);
                }
            }
        }
    });

    final JButton btnFlashViaRecovery = new JButton("Flash via Recovery");
    btnFlashViaRecovery.setToolTipText("Flash a zip archive using recovery");
    btnFlashViaRecovery.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            FlasherDone.setText("");
            JFileChooser chooser = new JFileChooser();
            FileNameExtensionFilter filter = new FileNameExtensionFilter("zip Files", "zip");
            chooser.setFileFilter(filter);
            int returnVal = chooser.showOpenDialog(getParent());
            if (returnVal == JFileChooser.APPROVE_OPTION) {
                File file = chooser.getSelectedFile();
                try {
                    JOptionPane.showMessageDialog(null,
                            "Select Update via ADB from recovery menu using physical keys on your device");
                    String[] commands = new String[3];
                    commands[0] = "adb";
                    commands[1] = "sideload";
                    commands[2] = file.getAbsolutePath();
                    ApplicationStatus.setText("Flashing...");
                    Process p1 = Runtime.getRuntime().exec(commands, null);
                    p1.waitFor();
                    ApplicationStatus.setText("Sideloaded...");
                    FlasherDone.setIcon(new ImageIcon(Interface.class.getResource("/graphics/Done.png")));
                    btnFlashViaRecovery.setSelected(false);
                } catch (Exception e1) {
                    System.err.println(e1);
                }
            }
        }
    });

    FlasherDone = new JLabel("");
    FlasherDone.setText("");
    FlasherDone.setBounds(760, 29, 300, 220);
    panel.add(FlasherDone);
    btnFlashViaRecovery.setBounds(25, 131, 220, 75);
    panel.add(btnFlashViaRecovery);
    btnFlashData.setBounds(541, 27, 220, 75);
    panel.add(btnFlashData);
    btnFlashSystem.setBounds(282, 236, 220, 75);
    panel.add(btnFlashSystem);

    final JButton btnFlashCache = new JButton("Cache");
    btnFlashCache.setToolTipText("Flash cache partition");
    btnFlashCache.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            FlasherDone.setText("");
            JFileChooser chooser = new JFileChooser();
            FileNameExtensionFilter filter = new FileNameExtensionFilter("IMG Files", "img");
            chooser.setFileFilter(filter);
            int returnVal = chooser.showOpenDialog(getParent());
            if (returnVal == JFileChooser.APPROVE_OPTION) {
                File file = chooser.getSelectedFile();
                String filename = chooser.getSelectedFile().getName();
                try {
                    ApplicationStatus.setText("Flashing...");
                    Process p1 = Runtime.getRuntime().exec("fastboot erase cache");
                    p1.waitFor();
                    String[] commands = new String[4];
                    commands[0] = "fastboot";
                    commands[1] = "flash";
                    commands[2] = "cache";
                    commands[3] = file.getAbsolutePath();
                    Process p2 = Runtime.getRuntime().exec(commands, null);
                    p2.waitFor();
                    ApplicationStatus
                            .setText(filename + "has been successfully flashed on your android device");
                    FlasherDone.setIcon(new ImageIcon(Interface.class.getResource("/graphics/Done.png")));
                    btnFlashCache.setSelected(false);
                } catch (Exception e1) {
                    System.err.println(e1);
                }
            }
        }
    });

    btnFlashCache.setBounds(282, 27, 220, 75);
    panel.add(btnFlashCache);

    final JButton btnBootImage = new JButton("Boot");
    btnBootImage.setToolTipText("Flash boot partition");
    btnBootImage.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            FlasherDone.setText("");
            JFileChooser chooser = new JFileChooser();
            FileNameExtensionFilter filter = new FileNameExtensionFilter("IMG Files", "img");
            chooser.setFileFilter(filter);
            int returnVal = chooser.showOpenDialog(getParent());
            if (returnVal == JFileChooser.APPROVE_OPTION) {
                File file = chooser.getSelectedFile();
                String filename = chooser.getSelectedFile().getName();
                try {
                    ApplicationStatus.setText("Flashing...");
                    Process p1 = Runtime.getRuntime().exec("fastboot erase boot");
                    p1.waitFor();
                    String[] commands = new String[4];
                    commands[0] = "fastboot";
                    commands[1] = "flash";
                    commands[2] = "boot";
                    commands[3] = file.getAbsolutePath();
                    Process p2 = Runtime.getRuntime().exec(commands, null);
                    p2.waitFor();
                    ApplicationStatus
                            .setText(filename + "has been successfully flashed on your android device");
                    FlasherDone.setIcon(new ImageIcon(Interface.class.getResource("/graphics/Done.png")));
                    btnBootImage.setSelected(false);
                } catch (Exception e1) {
                    System.err.println(e1);
                }
            }
        }
    });

    btnBootImage.setBounds(25, 27, 220, 75);
    panel.add(btnBootImage);

    final JButton btnFlashZipArchive = new JButton("Zip Archive");
    btnFlashZipArchive.setToolTipText("Flash a zip archive");
    btnFlashZipArchive.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            FlasherDone.setText("");
            JFileChooser chooser = new JFileChooser();
            FileNameExtensionFilter filter = new FileNameExtensionFilter("zip Files", "zip");
            chooser.setFileFilter(filter);
            int returnVal = chooser.showOpenDialog(getParent());
            if (returnVal == JFileChooser.APPROVE_OPTION) {
                File file = chooser.getSelectedFile();
                String filename = chooser.getSelectedFile().getName();
                try {
                    ApplicationStatus.setText("Flashing...");
                    String[] commands = new String[3];
                    commands[0] = "fastboot";
                    commands[1] = "flash";
                    commands[2] = file.getAbsolutePath();
                    Process p1 = Runtime.getRuntime().exec(commands, null);
                    p1.waitFor();
                    ApplicationStatus
                            .setText(filename + "has been successfully flashed on your android device");
                    FlasherDone.setIcon(new ImageIcon(Interface.class.getResource("/graphics/Done.png")));
                    btnFlashZipArchive.setSelected(false);
                } catch (Exception e1) {
                    System.err.println(e1);
                }
            }
        }
    });

    btnFlashZipArchive.setBounds(541, 236, 220, 75);
    panel.add(btnFlashZipArchive);

    final JButton btnFlashRecovery = new JButton("Recovery");
    btnFlashRecovery.setToolTipText("Flash recovery partition");
    btnFlashRecovery.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            FlasherDone.setText("");
            JFileChooser chooser = new JFileChooser();
            FileNameExtensionFilter filter = new FileNameExtensionFilter("IMG Files", "img");
            chooser.setFileFilter(filter);
            int returnVal = chooser.showOpenDialog(getParent());
            if (returnVal == JFileChooser.APPROVE_OPTION) {
                File file = chooser.getSelectedFile();
                String filename = chooser.getSelectedFile().getName();
                try {
                    ApplicationStatus.setText("Flashing...");
                    Process p1 = Runtime.getRuntime().exec("fastboot erase recovery");
                    p1.waitFor();
                    String[] commands = new String[4];
                    commands[0] = "fastboot";
                    commands[1] = "flash";
                    commands[2] = "recovery";
                    commands[3] = file.getAbsolutePath();
                    Process p2 = Runtime.getRuntime().exec(commands, null);
                    p2.waitFor();
                    ApplicationStatus
                            .setText(filename + "has been successfully flashed on your android device");
                    FlasherDone.setIcon(new ImageIcon(Interface.class.getResource("/graphics/Done.png")));
                    btnFlashRecovery.setSelected(false);
                } catch (Exception e1) {
                    System.err.println(e1);
                }
            }
        }
    });

    btnFlashRecovery.setBounds(541, 131, 220, 75);
    panel.add(btnFlashRecovery);

    JLabel lblYouMust = new JLabel(
            "Note: Your device's bootloader must support fastboot commands and should be in fastboot mode");
    lblYouMust.setBounds(25, 356, 835, 19);
    panel.add(lblYouMust);

    final JButton btnFlashSplash = new JButton("Splash");
    btnFlashSplash.setToolTipText("Flash splash partition");
    btnFlashSplash.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            FlasherDone.setIcon(new ImageIcon(Interface.class.getResource("/graphics/Done.png")));
            JFileChooser chooser = new JFileChooser();
            FileNameExtensionFilter filter = new FileNameExtensionFilter("IMG Files", "img");
            chooser.setFileFilter(filter);
            int returnVal = chooser.showOpenDialog(getParent());
            if (returnVal == JFileChooser.APPROVE_OPTION) {
                File file = chooser.getSelectedFile();
                String filename = chooser.getSelectedFile().getName();
                try {
                    ApplicationStatus.setText("Flashing...");
                    Process p1 = Runtime.getRuntime().exec("fastboot erase splash");
                    p1.waitFor();
                    String[] commands = new String[4];
                    commands[0] = "fastboot";
                    commands[1] = "flash";
                    commands[2] = "splash";
                    commands[3] = file.getAbsolutePath();
                    Process p2 = Runtime.getRuntime().exec(commands, null);
                    p2.waitFor();
                    ApplicationStatus
                            .setText(filename + "has been successfully flashed on your android device");
                    FlasherDone.setIcon(new ImageIcon(Interface.class.getResource("/graphics/Done.png")));
                    btnFlashSplash.setSelected(false);
                } catch (Exception e1) {
                    System.err.println(e1);
                }
            }
        }
    });

    btnFlashSplash.setBounds(25, 236, 220, 75);
    panel.add(btnFlashSplash);

    JButton btnFlashRadio = new JButton("Radio");
    btnFlashRadio.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            FlasherDone.setIcon(new ImageIcon(Interface.class.getResource("/graphics/Done.png")));
            JFileChooser chooser = new JFileChooser();
            FileNameExtensionFilter filter = new FileNameExtensionFilter("IMG Files", "img");
            chooser.setFileFilter(filter);
            int returnVal = chooser.showOpenDialog(getParent());
            if (returnVal == JFileChooser.APPROVE_OPTION) {
                File file = chooser.getSelectedFile();
                String filename = chooser.getSelectedFile().getName();
                try {
                    ApplicationStatus.setText("Flashing...");
                    Process p1 = Runtime.getRuntime().exec("fastboot erase radio");
                    p1.waitFor();
                    String[] commands = new String[4];
                    commands[0] = "fastboot";
                    commands[1] = "flash";
                    commands[2] = "radio";
                    commands[3] = file.getAbsolutePath();
                    Process p2 = Runtime.getRuntime().exec(commands, null);
                    p2.waitFor();
                    ApplicationStatus
                            .setText(filename + "has been successfully flashed on your android device");
                    FlasherDone.setIcon(new ImageIcon(Interface.class.getResource("/graphics/Done.png")));
                    btnFlashSplash.setSelected(false);
                } catch (Exception e1) {
                    System.err.println(e1);
                }
            }
        }
    });
    btnFlashRadio.setToolTipText("Flash radio partition");
    btnFlashRadio.setBounds(282, 131, 220, 75);
    panel.add(btnFlashRadio);

    JPanel panel_1 = new JPanel();
    panel_1.setBackground(Color.WHITE);
    tabbedPane.addTab("Wiper", null, panel_1, null);
    panel_1.setLayout(null);

    WiperDone = new JLabel("");
    WiperDone.setText("");
    WiperDone.setBounds(758, 26, 300, 220);
    panel_1.add(WiperDone);

    JLabel label_13 = new JLabel("** Device must be rooted");
    label_13.setBounds(25, 336, 252, 19);
    panel_1.add(label_13);

    JButton btnWipeRecovery = new JButton("Recovery");
    btnWipeRecovery.setToolTipText("Wipe recovery partition");
    btnWipeRecovery.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            WiperDone.setText("");
            try {
                ApplicationStatus.setText("Wiping...");
                Process p1 = Runtime.getRuntime().exec("fastboot erase cache");
                p1.waitFor();
                ApplicationStatus.setText("Recovery has been wiped");
                WiperDone.setIcon(new ImageIcon(Interface.class.getResource("/graphics/Done.png")));
            } catch (Exception e1) {
                System.err.println(e1);
            }
        }
    });

    btnWipeRecovery.setBounds(541, 131, 220, 75);
    panel_1.add(btnWipeRecovery);

    JButton btnWipeBoot = new JButton("Boot");
    btnWipeBoot.setToolTipText("Flash boot partition");
    btnWipeBoot.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            WiperDone.setText("");
            try {
                ApplicationStatus.setText("Wiping...");
                Process p1 = Runtime.getRuntime().exec("fastboot erase boot");
                p1.waitFor();
                ApplicationStatus.setText("Boot has been wiped");
                WiperDone.setIcon(new ImageIcon(Interface.class.getResource("/graphics/Done.png")));
            } catch (Exception e1) {
                System.err.println(e1);
            }
        }
    });

    btnWipeBoot.setBounds(25, 27, 220, 75);
    panel_1.add(btnWipeBoot);

    JButton btnWipeSystem = new JButton("System");
    btnWipeSystem.setToolTipText("Wipe system partition");
    btnWipeSystem.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            WiperDone.setText("");
            try {
                ApplicationStatus.setText("Wiping...");
                Process p1 = Runtime.getRuntime().exec("fastboot erase system");
                p1.waitFor();
                ApplicationStatus.setText("System has been wiped");
                WiperDone.setIcon(new ImageIcon(Interface.class.getResource("/graphics/Done.png")));
            } catch (Exception e1) {
                System.err.println(e1);
            }
        }
    });

    btnWipeSystem.setBounds(282, 236, 220, 75);
    panel_1.add(btnWipeSystem);

    JButton btnWipeSplash = new JButton("Splash");
    btnWipeSplash.setToolTipText("Wipe splash partition");
    btnWipeSplash.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            WiperDone.setText("");
            try {
                ApplicationStatus.setText("Wiping...");
                Process p1 = Runtime.getRuntime().exec("fastboot erase splash");
                p1.waitFor();
                ApplicationStatus.setText("Splash has been wiped");
                WiperDone.setIcon(new ImageIcon(Interface.class.getResource("/graphics/Done.png")));
            } catch (Exception e1) {
                System.err.println(e1);
            }
        }
    });

    btnWipeSplash.setBounds(25, 236, 220, 75);
    panel_1.add(btnWipeSplash);

    JButton btnWipeData = new JButton("Data");
    btnWipeData.setToolTipText("Wipe data partition");
    btnWipeData.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            WiperDone.setText("");
            try {
                ApplicationStatus.setText("Wiping...");
                Process p1 = Runtime.getRuntime().exec("fastboot erase data");
                p1.waitFor();
                ApplicationStatus.setText("Data has been wiped");
                WiperDone.setIcon(new ImageIcon(Interface.class.getResource("/graphics/Done.png")));
            } catch (Exception e1) {
                System.err.println(e1);
            }
        }
    });

    btnWipeData.setBounds(25, 131, 220, 75);
    panel_1.add(btnWipeData);

    JButton btnFlashDalvikCache = new JButton("Dalvik Cache **");
    btnFlashDalvikCache.setToolTipText("Wipe dalvik cache");
    btnFlashDalvikCache.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            WiperDone.setText("");
            try {
                ApplicationStatus.setText("Wiping...");
                Process p1 = Runtime.getRuntime().exec("adb shell su -c rm * /data/dalvik-cache");
                p1.waitFor();
                Process p2 = Runtime.getRuntime().exec("adb shell su -c rm * /cache/dalvik-cache");
                p2.waitFor();
                ApplicationStatus.setText("Dalvik Cache has been wiped! Now rebooting device...");
                Process p3 = Runtime.getRuntime().exec("adb reboot");
                p3.waitFor();
                ApplicationStatus.setText("Done");
                WiperDone.setIcon(new ImageIcon(Interface.class.getResource("/graphics/Done.png")));
            } catch (Exception e1) {
                System.err.println(e1);
            }
        }
    });

    btnFlashDalvikCache.setBounds(541, 27, 220, 75);
    panel_1.add(btnFlashDalvikCache);

    JButton btnWipeCache = new JButton("Cache");
    btnWipeCache.setToolTipText("Wipe cache partition");
    btnWipeCache.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            WiperDone.setText("");
            try {
                ApplicationStatus.setText("Wiping...");
                Process p1 = Runtime.getRuntime().exec("fastboot erase cache");
                p1.waitFor();
                ApplicationStatus.setText("Cache has been wiped! Now rebooting device...");
                Process p2 = Runtime.getRuntime().exec("adb reboot");
                p2.waitFor();
                ApplicationStatus.setText("Done");
                WiperDone.setIcon(new ImageIcon(Interface.class.getResource("/graphics/Done.png")));
            } catch (Exception e1) {
                System.err.println(e1);
            }
        }
    });

    btnWipeCache.setBounds(282, 27, 220, 75);
    panel_1.add(btnWipeCache);

    JButton btnWipeRadio = new JButton("Radio");
    btnWipeRadio.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            WiperDone.setText("");
            try {
                ApplicationStatus.setText("Wiping...");
                Process p1 = Runtime.getRuntime().exec("fastboot erase radio");
                p1.waitFor();
                ApplicationStatus.setText("Radio has been wiped");
                WiperDone.setIcon(new ImageIcon(Interface.class.getResource("/graphics/Done.png")));
            } catch (Exception e1) {
                System.err.println(e1);
            }
        }
    });
    btnWipeRadio.setToolTipText("Wipe radio partition");
    btnWipeRadio.setBounds(282, 131, 220, 75);
    panel_1.add(btnWipeRadio);

    JLabel lblNoteYourDevices = new JLabel(
            "Note: Your device's bootloader must support fastboot commands and should be in fastboot mode");
    lblNoteYourDevices.setBounds(25, 357, 835, 19);
    panel_1.add(lblNoteYourDevices);

    JPanel panel_3 = new JPanel();
    panel_3.setBackground(Color.WHITE);
    tabbedPane.addTab("Bootloader", null, panel_3, null);
    panel_3.setLayout(null);

    JLabel label_17 = new JLabel("Note: Don't worry if the app says to connect your device while");
    label_17.setBounds(66, 320, 600, 19);
    panel_3.add(label_17);

    JLabel label_18 = new JLabel("android is not booted ex. fastboot, bootloader, booting etc.");
    label_18.setBounds(66, 337, 600, 19);
    panel_3.add(label_18);

    JLabel lblOnlyForNexus = new JLabel(
            "Works only with specific devices ex. Nexus, Android One, FEW MTK devices etc.");
    lblOnlyForNexus.setBounds(66, 351, 600, 24);
    panel_3.add(lblOnlyForNexus);

    JButton btnUnlockBootloader = new JButton("Unlock Bootloader");
    btnUnlockBootloader.setToolTipText("Unlock android device bootloader");
    btnUnlockBootloader.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            try {
                ApplicationStatus.setText(
                        "Unlocking bootloader will factory reset your device and may void your device warranty!");
                JOptionPane.showMessageDialog(null,
                        "You will need to re-enable USB debugging later as your device will get factory reset");
                Process p1 = Runtime.getRuntime().exec("adb reboot bootloader");
                p1.waitFor();
                Process p2 = Runtime.getRuntime().exec("fastboot oem unlock");
                p2.waitFor();
            } catch (Exception e1) {
                System.err.println(e1);
            }
        }
    });

    btnUnlockBootloader.setBounds(282, 27, 220, 75);
    panel_3.add(btnUnlockBootloader);

    JButton btnLockBootloader = new JButton("Lock Bootloader");
    btnLockBootloader.setToolTipText("Lock android device bootloader");
    btnLockBootloader.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            try {
                Process p1 = Runtime.getRuntime().exec("adb reboot bootloader");
                p1.waitFor();
                Process p2 = Runtime.getRuntime().exec("fastboot oem lock");
                p2.waitFor();
            } catch (Exception e1) {
                System.err.println(e1);
            }
        }
    });

    btnLockBootloader.setBounds(25, 27, 220, 75);
    panel_3.add(btnLockBootloader);

    JPanel panel_6 = new JPanel();
    panel_6.setBackground(Color.WHITE);
    tabbedPane.addTab("Crypto", null, panel_6, null);
    panel_6.setLayout(null);

    JButton btnSHA512 = new JButton("SHA-512");
    btnSHA512.setToolTipText("Calculate SHA-512 sum of a file");
    btnSHA512.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            JFileChooser chooser = new JFileChooser();
            int returnVal = chooser.showOpenDialog(getParent());
            if (returnVal == JFileChooser.APPROVE_OPTION) {
                File file = new File("");
                ApplicationStatus.setText("Calculating...");
                CalculatedCrypto.setText(DigestUtils.sha512Hex(file.getAbsolutePath()));
                ApplicationStatus.setText("");
            }
        }
    });

    btnSHA512.setBounds(541, 131, 220, 75);
    panel_6.add(btnSHA512);

    JScrollPane scrollPane_2 = new JScrollPane();
    scrollPane_2.setBounds(12, 332, 900, 25);
    panel_6.add(scrollPane_2);

    InputCrypto = new JTextArea();
    InputCrypto.setToolTipText("Input sum to be compared with calculated sum");
    scrollPane_2.setViewportView(InputCrypto);

    JLabel lblLabelCalculatedSum = new JLabel("Calculated Sum :");
    lblLabelCalculatedSum.setBounds(12, 240, 235, 17);
    panel_6.add(lblLabelCalculatedSum);

    JScrollPane scrollPane_1 = new JScrollPane();
    scrollPane_1.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_NEVER);
    scrollPane_1.setBounds(12, 268, 900, 28);
    panel_6.add(scrollPane_1);

    CalculatedCrypto = new JTextArea();
    CalculatedCrypto.setToolTipText("Calclated sum");
    scrollPane_1.setViewportView(CalculatedCrypto);
    CalculatedCrypto.setEditable(false);

    JButton btnSHA384 = new JButton("SHA-384");
    btnSHA384.setToolTipText("Calculate SHA-384 sum of a file");
    btnSHA384.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            JFileChooser chooser = new JFileChooser();
            int returnVal = chooser.showOpenDialog(getParent());
            if (returnVal == JFileChooser.APPROVE_OPTION) {
                File file = new File("");
                ApplicationStatus.setText("Calculating...");
                CalculatedCrypto.setText(DigestUtils.sha384Hex(file.getAbsolutePath()));
                ApplicationStatus.setText("");
            }
        }
    });

    btnSHA384.setBounds(282, 131, 220, 75);
    panel_6.add(btnSHA384);

    JButton btnSHA256 = new JButton("SHA-256");
    btnSHA256.setToolTipText("Calculate SHA-256 sum of a file");
    btnSHA256.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            JFileChooser chooser = new JFileChooser();
            int returnVal = chooser.showOpenDialog(getParent());
            if (returnVal == JFileChooser.APPROVE_OPTION) {
                File file = new File("");
                ApplicationStatus.setText("Calculating...");
                CalculatedCrypto.setText(DigestUtils.sha256Hex(file.getAbsolutePath()));
                ApplicationStatus.setText("");
            }
        }
    });

    btnSHA256.setBounds(25, 131, 220, 75);
    panel_6.add(btnSHA256);

    JButton btnSHA1 = new JButton("SHA-1");
    btnSHA1.setToolTipText("Calculate SHA-1 sum of a file");
    btnSHA1.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            JFileChooser chooser = new JFileChooser();
            int returnVal = chooser.showOpenDialog(getParent());
            if (returnVal == JFileChooser.APPROVE_OPTION) {
                File file = new File("");
                ApplicationStatus.setText("Calculating...");
                CalculatedCrypto.setText(DigestUtils.sha1Hex(file.getAbsolutePath()));
                ApplicationStatus.setText("");
            }
        }
    });

    btnSHA1.setBounds(541, 27, 220, 75);
    panel_6.add(btnSHA1);

    JButton btnMD5 = new JButton("MD5");
    btnMD5.setToolTipText("Calculate MD5 sum of a file");
    btnMD5.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            JFileChooser chooser = new JFileChooser();
            int returnVal = chooser.showOpenDialog(getParent());
            if (returnVal == JFileChooser.APPROVE_OPTION) {
                File file = new File("");
                ApplicationStatus.setText("Calculating...");
                CalculatedCrypto.setText(DigestUtils.md5Hex(file.getAbsolutePath()));
                ApplicationStatus.setText("");
            }
        }
    });

    btnMD5.setBounds(282, 27, 220, 75);
    panel_6.add(btnMD5);

    JLabel lblInputSumTo = new JLabel("Input Sum to be compared :");
    lblInputSumTo.setBounds(12, 308, 235, 15);
    panel_6.add(lblInputSumTo);

    JButton btnCompare = new JButton("Compare");
    btnCompare.setToolTipText("Click to compare calculated sum and input sum");
    btnCompare.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            if (InputCrypto.getText().equals("")) {
                JOptionPane.showMessageDialog(null, "Please select algorithm and a file");
            }
            if (CalculatedCrypto.getText().equals("")) {
                JOptionPane.showMessageDialog(null, "Please input a sum to be compared");
            } else {
                if (InputCrypto.getText().equalsIgnoreCase(CalculatedCrypto.getText())) {
                    JOptionPane.showMessageDialog(null, "Both sums are matched");
                } else {
                    JOptionPane.showMessageDialog(null, "Sums are not matched!");
                }
            }
        }
    });
    btnCompare.setBounds(924, 268, 134, 89);
    panel_6.add(btnCompare);

    JButton btnClearCalculatedCrypto = new JButton("Clear");
    btnClearCalculatedCrypto.setToolTipText("Clear the calculated sum");
    btnClearCalculatedCrypto.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            CalculatedCrypto.setText("");
            InputCrypto.setText("");
        }
    });
    btnClearCalculatedCrypto.setBounds(25, 27, 220, 75);
    panel_6.add(btnClearCalculatedCrypto);

    JLabel label_2 = new JLabel("");
    label_2.setBounds(50, 0, 1038, 256);
    label_2.setIcon(new ImageIcon(Interface.class.getResource("/graphics/Interface_logo.png")));
    contentPane.add(label_2);

    new Updater();

    Thread t = new Thread(r); // Background services
    t.start();

    Runtime.getRuntime().addShutdownHook(new Thread() { // Exit sequence
        public void run() {
            try {
                System.out.println("Killing ADB instance...");
                Process p1 = Runtime.getRuntime().exec("adb kill-server");
                p1.waitFor();
                System.out.println("Cleaning cache...");
                File file2 = new File(".CheckADBConnection");
                if (file2.exists() && !file2.isDirectory()) {
                    file2.delete();
                }
                File file3 = new File("su");
                if (file3.exists() && !file3.isDirectory()) {
                    file3.delete();
                }
                File file4 = new File(".logcat.txt");
                if (file4.exists() && !file4.isDirectory()) {
                    file4.delete();
                }
                File file5 = new File(".userapps.txt");
                if (file5.exists() && !file5.isDirectory()) {
                    file5.delete();
                }
                File file6 = new File(".privapps.txt");
                if (file6.exists() && !file6.isDirectory()) {
                    file6.delete();
                }
                File file7 = new File(".systemapps.txt");
                if (file7.exists() && !file7.isDirectory()) {
                    file4.delete();
                }
                System.out.println("Droid PC Suite terminated");
            } catch (Exception e1) {
                e1.printStackTrace();
            }
        }
    });
}

From source file:edu.ku.brc.specify.tasks.subpane.images.ImagesPane.java

/**
 * @param index//from  w  w  w .j a va  2 s  .c o  m
 * @param isInfoBtn
 */
private void showBubble(final int index, final int whichBtn) {
    //log.debug("showBubble - index: "+index+"  whichBtn: "+whichBtn);

    final ImageDataItem item = index > -1 && index < rowsVector.size() ? rowsVector.get(index) : null;
    if (item == null)
        return;

    bubblePane = new BubbleGlassPane();
    bubblePane.addMouseListener(new MouseAdapter() {
        @Override
        public void mousePressed(MouseEvent e) {
            if (showingGlassPane) {
                clearBubblePane();

                SwingUtilities.invokeLater(new Runnable() {
                    @Override
                    public void run() {
                        if (bubblePane.getBtnClicked() != -1) {
                            showItemsInForm(item);
                            /*int index = rowsVector.indexOf(item);
                            if (index > -1)
                            {
                            showFullImage(index);
                            }*/
                        }
                    }
                });
            }
        }
    });

    int linesAdded = 0;
    List<Triple<String, String, Object>> values = null;
    if (whichBtn == ImageCellDisplay.INFO_BTN) {
        values = getImageData(item);
        if (values != null) {
            for (int i = 0; i < values.size() - 1; i++) // Minus 1, Do not want to show the 'Id' field
            {
                Triple<String, String, Object> p = values.get(i);
                bubblePane.addLine(p.second, p.third != null ? p.third.toString() : "");
                linesAdded++;
            }
        }
    }

    if (linesAdded > 0 && values != null) {
        String btnTitle = UIRegistry.getLocalizedMessage("ATTCH_SHOW_TBL",
                DBTableIdMgr.getInstance().getTitleForId(item.getTableId()));
        bubblePane.addBtn(btnTitle, null);

        oldGlassPane = getGlassPane();
        if (oldGlassPane != null) {
            oldGlassPane.finishedWithDragAndDrop();
        }

        if (bubblePane != null && getTopWindow() != null) {
            ((JFrame) getTopWindow()).setGlassPane(bubblePane);
            bubblePane.setVisible(true);
            showingGlassPane = true;

        } else {
            oldGlassPane = null;
            showingGlassPane = false;
        }
    } else {
        writeTimedSimpleGlassPaneMsg(getResourceString("ATTCH_NO_INFO_AVAIL"));
    }
}

From source file:com.t3.client.ui.T3Frame.java

public JLabel getChatActionLabel() {
    if (chatActionLabel == null) {
        chatActionLabel = new JLabel(new ImageIcon(AppStyle.chatImage));
        chatActionLabel.setSize(chatActionLabel.getPreferredSize());
        chatActionLabel.setVisible(false);
        chatActionLabel.addMouseListener(new MouseAdapter() {
            @Override//from ww  w  .j ava2  s.  c o  m
            public void mousePressed(MouseEvent e) {
                showCommandPanel();
            }
        });
    }
    return chatActionLabel;
}