Examples with ListSelectionListener javax.swing.event.ListSelectionListener used on opensource projects

Example 81 with ListSelectionListener

use of javax.swing.event.ListSelectionListener in project pmd by pmd.

the class GUI method makeMatchList.

private JComponent makeMatchList() {
    resultsTable.getSelectionModel().addListSelectionListener(new ListSelectionListener() {

        @Override
        public void valueChanged(ListSelectionEvent e) {
            populateResultArea();
        }
    });
    resultsTable.registerKeyboardAction(new ActionListener() {

        @Override
        public void actionPerformed(ActionEvent e) {
            copyMatchListSelectionsToClipboard();
        }
    }, "Copy", COPY_KEY_STROKE, JComponent.WHEN_FOCUSED);
    resultsTable.registerKeyboardAction(new ActionListener() {

        @Override
        public void actionPerformed(ActionEvent e) {
            deleteMatchlistSelections();
        }
    }, "Del", DELETE_KEY_STROKE, JComponent.WHEN_FOCUSED);
    int[] alignments = new int[matchColumns.length];
    for (int i = 0; i < alignments.length; i++) {
        alignments[i] = matchColumns[i].alignment();
    }
    resultsTable.setDefaultRenderer(Object.class, new AlignmentRenderer(alignments));
    final JTableHeader header = resultsTable.getTableHeader();
    header.addMouseListener(new MouseAdapter() {

        @Override
        public void mouseClicked(MouseEvent e) {
            sortOnColumn(header.columnAtPoint(new Point(e.getX(), e.getY())));
        }
    });
    return new JScrollPane(resultsTable);
}

Example 82 with ListSelectionListener

use of javax.swing.event.ListSelectionListener in project protege-client by protegeproject.

the class ChangeHistoryPanel method getHistoryComponent.

private JComponent getHistoryComponent() {
    HistoryTableModel model = new HistoryTableModel(changes);
    final JTable table = new JTable(model);
    table.getSelectionModel().addListSelectionListener(new ListSelectionListener() {

        @Override
        public void valueChanged(ListSelectionEvent listSelectionEvent) {
            List<OWLOntologyChange> changesToDisplay = new ArrayList<OWLOntologyChange>();
            for (int row : table.getSelectedRows()) {
                OntologyDocumentRevision start = changes.getStartRevision().add(table.convertRowIndexToModel(row));
                changesToDisplay.addAll(changes.cropChanges(start, start.next()).getChanges(ontology));
            }
            changeListTableModel.setChangeList(changesToDisplay);
        }
    });
    SimpleDateFormat format = new SimpleDateFormat("MMM dd, yyyy hh:mm a, z");
    TableCellRenderer renderer = new FormatRenderer(format);
    TableColumnModel columnModel = table.getColumnModel();
    columnModel.getColumn(0).setCellRenderer(renderer);
    // Allow user to sort
    TableRowSorter<TableModel> sorter = new TableRowSorter<TableModel>(model);
    table.setRowSorter(sorter);
    // Sort initially by the date column in descending order
    List<RowSorter.SortKey> sortKeys = new ArrayList<RowSorter.SortKey>();
    sortKeys.add(new RowSorter.SortKey(0, SortOrder.DESCENDING));
    sorter.setSortKeys(sortKeys);
    JScrollPane scrollPane = new JScrollPane(table);
    scrollPane.setAlignmentX(Component.LEFT_ALIGNMENT);
    return scrollPane;
}

Example 83 with ListSelectionListener

use of javax.swing.event.ListSelectionListener in project CCDD by nasa.

the class CcddSchedulerEditorHandler method initialize.

/**
 ********************************************************************************************
 * Create a telemetry table
 ********************************************************************************************
 */
@SuppressWarnings("serial")
private void initialize() {
    // Create a border for the table and list panes, and an empty border
    Border border = BorderFactory.createCompoundBorder(BorderFactory.createBevelBorder(BevelBorder.LOWERED, Color.LIGHT_GRAY, Color.GRAY), BorderFactory.createEmptyBorder(ModifiableSpacingInfo.INPUT_FIELD_PADDING.getSpacing(), ModifiableSpacingInfo.INPUT_FIELD_PADDING.getSpacing(), ModifiableSpacingInfo.INPUT_FIELD_PADDING.getSpacing(), ModifiableSpacingInfo.INPUT_FIELD_PADDING.getSpacing()));
    Border emptyBorder = BorderFactory.createEmptyBorder();
    // Initialize the layout constraints
    GridBagConstraints gbc = new GridBagConstraints(0, 0, 1, 1, 1.0, 0.0, GridBagConstraints.LINE_START, GridBagConstraints.BOTH, new Insets(0, 0, 0, 0), 0, 0);
    // Initialize the telemetry scheduler
    initializeSchedulerTable();
    // Initialize the scheduler table object
    schedulerTable = new CcddJTableHandler(5) {

        /**
         ************************************************************************************
         * Allow multiple line display in the specified column only
         ************************************************************************************
         */
        @Override
        protected boolean isColumnMultiLine(int column) {
            return column == SchedulerColumn.NAME.ordinal();
        }

        /**
         ************************************************************************************
         * Allow resizing of the specified column only
         ************************************************************************************
         */
        @Override
        protected boolean isColumnResizable(int column) {
            return column == SchedulerColumn.NAME.ordinal();
        }

        /**
         ************************************************************************************
         * Allow editing of the table cells in the specified columns only
         ************************************************************************************
         */
        @Override
        public boolean isCellEditable(int row, int column) {
            return column == SchedulerColumn.NAME.ordinal() || (column == SchedulerColumn.ID.ordinal() && messages.get(row).getNumberOfSubMessages() <= 1) || (column > SchedulerColumn.ID.ordinal() && messages.get(row).getNumberOfSubMessages() > 1 && column <= SchedulerColumn.ID.ordinal() + messages.get(row).getNumberOfSubMessages());
        }

        /**
         ************************************************************************************
         * Validate changes to the data field value cells; e.g., verify cell content and, if
         * found invalid, revert to the original value
         *
         * @param tableData
         *            list containing the table data row arrays
         *
         * @param row
         *            table model row number
         *
         * @param column
         *            table model column number
         *
         * @param oldValue
         *            original cell contents
         *
         * @param newValue
         *            new cell contents
         *
         * @param showMessage
         *            unused
         *
         * @param isMultiple
         *            unused
         *
         * @return Value of ShowMessage
         ***********************************************************************************
         */
        @Override
        protected Boolean validateCellContent(List<Object[]> tableData, int row, int column, Object oldValue, Object newValue, Boolean showMessage, boolean isMultiple) {
            // Reset the flag that indicates the last edited cell's content is invalid
            setLastCellValid(true);
            // Create a string version of the new value
            String newValueS = newValue.toString();
            try {
                // Check if this is the name column
                if (column == SchedulerColumn.NAME.ordinal()) {
                    // Check if the value name is blank
                    if (newValueS.isEmpty()) {
                        // Inform the user that the message name cannot be blank
                        throw new CCDDException("Message name must be entered");
                    }
                    // Check if the message name is an alphanumeric
                    if (!newValueS.matches(InputDataType.ALPHANUMERIC.getInputMatch())) {
                        // Inform the user that the message name contains invalid characters
                        throw new CCDDException("Invalid characters in message name");
                    }
                    // Step through each message
                    for (Message message : messages) {
                        // Check if the new name matches an existing one
                        if (messages.indexOf(message) != row && message.getName().equals(newValueS)) {
                            // Inform the user that the message name already is in use
                            throw new CCDDException("Message name is already in use");
                        }
                    }
                    // Store the new message name
                    messages.get(row).setName(newValueS);
                    // Update the assigned variables tab and options list with the new name
                    tabbedPane.setTitleAt(tabbedPane.getSelectedIndex(), newValueS);
                    schedulerHndlr.getTelemetryOptions();
                    // Change references to the original message name to the new name in the
                    // assignment tree so that the tree builds correctly
                    assignmentTree.updateMessageName(oldValue.toString(), newValueS);
                } else // Check if this is an ID column
                if (column >= SchedulerColumn.ID.ordinal()) {
                    // Check if the message ID is a hexadecimal
                    if (!newValueS.matches(InputDataType.HEXADECIMAL.getInputMatch())) {
                        // Inform the user that the message name contains invalid characters
                        throw new CCDDException("Invalid characters in message ID");
                    }
                    // Format the hexadecimal value
                    newValueS = InputDataType.HEXADECIMAL.formatInput(newValueS);
                    // Check that the new value isn't a blank
                    if (!newValueS.isEmpty()) {
                        // Convert the ID to an integer
                        int id = Integer.decode(newValueS);
                        // Step through each row in the table
                        for (int checkRow = 0; checkRow < tableData.size(); checkRow++) {
                            // Step through each column containing an ID
                            for (int checkCol = SchedulerColumn.ID.ordinal(); checkCol < tableData.get(checkRow).length; checkCol++) {
                                // updated, and that the new ID matches that in another ID cell
                                if (!(row == checkRow && column == checkCol) && !tableData.get(checkRow)[checkCol].toString().isEmpty() && id == Integer.decode(tableData.get(checkRow)[checkCol].toString())) {
                                    // Inform the user that the message name already is in use
                                    throw new CCDDException("Message ID is already in use");
                                }
                            }
                        }
                    }
                    // Update the table with the formatted value
                    tableData.get(row)[column] = newValueS;
                    // Check if this is the parent message's ID
                    if (column == SchedulerColumn.ID.ordinal()) {
                        // Store the new message ID
                        messages.get(row).setID(newValueS);
                    } else // This is a sub-message ID
                    {
                        // Store the new sub-message ID
                        messages.get(row).getSubMessage(column - SchedulerColumn.ID.ordinal() - 1).setID(newValueS);
                    }
                }
            } catch (CCDDException ce) {
                // Set the flag that indicates the last edited cell's content is invalid
                setLastCellValid(false);
                // Inform the user that the input value is invalid
                new CcddDialogHandler().showMessageDialog(schedulerHndlr.getSchedulerDialog().getDialog(), "<html><b>" + ce.getMessage(), "Invalid Input", JOptionPane.WARNING_MESSAGE, DialogOption.OK_OPTION);
                // Restore the cell contents to its original value
                tableData.get(row)[column] = oldValue;
                getUndoManager().undoRemoveEdit();
            }
            return showMessage;
        }

        /**
         ************************************************************************************
         * Load the table data field definition values into the table and format the table
         * cells
         ************************************************************************************
         */
        @Override
        protected void loadAndFormatData() {
            // Place the data into the table model along with the column names, set up the
            // editors and renderers for the table cells, set up the table grid lines, and
            // calculate the minimum width required to display the table information
            setUpdatableCharacteristics(currentData, getColumnNames(), null, null, true, true, true);
        }

        /**
         ************************************************************************************
         * Override prepareRenderer to allow adjusting the background colors of table cells
         ************************************************************************************
         */
        @Override
        public Component prepareRenderer(TableCellRenderer renderer, int row, int column) {
            JComponent comp = (JComponent) super.prepareRenderer(renderer, row, column);
            // color
            if (comp.getBackground() != ModifiableColorInfo.FOCUS_BACK.getColor() && comp.getBackground() != ModifiableColorInfo.SELECTED_BACK.getColor() && !isCellEditable(row, column)) {
                // Shade the cell's foreground and background colors
                comp.setForeground(getValueAt(row, column).toString().startsWith("-") ? ModifiableColorInfo.INVALID_TEXT.getColor() : ModifiableColorInfo.PROTECTED_TEXT.getColor());
                comp.setBackground(ModifiableColorInfo.PROTECTED_BACK.getColor());
            }
            return comp;
        }

        /**
         ************************************************************************************
         * Override the CcddJTableHandler method to handle sorting the Size column
         ************************************************************************************
         */
        @Override
        protected void setTableSortable() {
            // Remove the current sorter, if present. The number of columns may have changed
            // (due to adding/removing sub-messages) so the sorter must be rebuilt
            setRowSorter(null);
            super.setTableSortable();
            // Create a runnable object to be executed
            SwingUtilities.invokeLater(new Runnable() {

                /**
                 ****************************************************************************
                 * Execute after all pending Swing events are finished. This allows the number
                 * of viewable columns to catch up with the column model when a column is added
                 * or removed
                 ****************************************************************************
                 */
                @Override
                public void run() {
                    // Get the table's row sorter
                    TableRowSorter<?> sorter = (TableRowSorter<?>) getRowSorter();
                    // Check if the table has a sorter (i.e., has at least one row)
                    if (sorter != null) {
                        // the telemetry scheduler)
                        for (int column = SchedulerColumn.ID.ordinal(); column < getModel().getColumnCount(); column++) {
                            // Add a hexadecimal sort comparator
                            sorter.setComparator(column, new Comparator<String>() {

                                /**
                                 ************************************************************
                                 * Override the comparison when sorting columns with a
                                 * hexadecimal input type format
                                 ************************************************************
                                 */
                                @Override
                                public int compare(String cell1, String cell2) {
                                    int result;
                                    // Check if either cell is empty
                                    if (cell1.isEmpty() || cell2.isEmpty()) {
                                        // Compare as text (alphabetically)
                                        result = cell1.compareTo(cell2);
                                    } else // Neither cell is empty
                                    {
                                        // Get the hexadecimal cell values and convert them to
                                        // base 10 integers for comparison
                                        result = Integer.compare(Integer.decode(cell1), Integer.decode(cell2));
                                    }
                                    return result;
                                }
                            });
                        }
                    }
                }
            });
        }
    };
    // Create a listener for scheduler table row and column selection changes
    ListSelectionListener rowColListener = new ListSelectionListener() {

        /**
         ************************************************************************************
         * Handle a scheduler table row or column selection change
         ************************************************************************************
         */
        @Override
        public void valueChanged(ListSelectionEvent lse) {
            // Check if this is the last of the series of changes
            if (!lse.getValueIsAdjusting() && (schedulerTable.getSelectedRow() != previousRow || schedulerTable.getSelectedColumn() != previousColumn)) {
                // Update the tabbed pane for the selected message
                updateAssignedVariablesTabs();
                // Update the assignment tree/list
                updateAssignmentList();
                // Store the selected row and column indices for comparison when another cell
                // is selected
                previousRow = schedulerTable.getSelectedRow();
                previousColumn = schedulerTable.getSelectedColumn();
            }
        }
    };
    // Add a listener for changes to the table's row selection
    schedulerTable.getSelectionModel().addListSelectionListener(rowColListener);
    // Add a listener for changes to the table's column selection
    schedulerTable.getColumnModel().getSelectionModel().addListSelectionListener(rowColListener);
    // Place the table into a scroll pane
    JScrollPane schedulerScrollPane = new JScrollPane(schedulerTable);
    schedulerScrollPane.setBorder(border);
    // Set common table parameters and characteristics
    schedulerTable.setFixedCharacteristics(schedulerScrollPane, false, ListSelectionModel.SINGLE_SELECTION, TableSelectionMode.SELECT_BY_CELL, false, ModifiableColorInfo.TABLE_BACK.getColor(), true, true, ModifiableFontInfo.DATA_TABLE_CELL.getFont(), true);
    // Get the table model and undo manager to shorten later calls
    schTableModel = (UndoableTableModel) schedulerTable.getModel();
    // Create a scroll pane to contain the assignment tree/list
    JScrollPane assignScrollPane = null;
    // Check if this is the telemetry scheduler
    if (schedulerHndlr.getSchedulerOption() == TELEMETRY_SCHEDULER) {
        // Get a reference to the telemetry scheduler input to shorten subsequent calls
        CcddTelemetrySchedulerInput tlmInput = (CcddTelemetrySchedulerInput) schedulerHndlr.getSchedulerInput();
        // Create an assignment tree specifying a null rate & message so the tree is initially
        // empty
        assignmentTree = new CcddAssignmentTreeHandler(ccddMain, null, tlmInput.getLinkTree().getLinkHandler(), tlmInput.getVariableTree().getTableTreePathList(null, tlmInput.getVariableTree().getNodeByNodeName(UNLINKED_VARIABLES_NODE_NAME), -1), ccddMain.getMainFrame());
    } else // Check if this is the application scheduler
    if (schedulerHndlr.getSchedulerOption() == APPLICATION_SCHEDULER) {
        // Initialize the assignment list and add it to a scroll pane that will be placed next
        // to the variable list
        assignmentList = new JList<String>();
        assignmentList.setModel(new DefaultListModel<String>());
        assignmentList.setFont(ModifiableFontInfo.LABEL_PLAIN.getFont());
        assignScrollPane = new JScrollPane(assignmentList);
        assignScrollPane.setBorder(border);
        // Set the size of the assignment scroll pane
        assignScrollPane.setPreferredSize(new Dimension(Math.min(Math.max(assignScrollPane.getPreferredSize().width, 150), 250), assignScrollPane.getPreferredSize().height));
        assignScrollPane.setMinimumSize(assignScrollPane.getPreferredSize());
    }
    // Create panels to hold the components tablePnl = new JPanel(new GridBagLayout());
    JPanel schedulerPnl = new JPanel(new GridBagLayout());
    JPanel assignmentPnl = new JPanel(new GridBagLayout());
    schedulerPnl.setBorder(emptyBorder);
    assignmentPnl.setBorder(emptyBorder);
    // Set the scheduler panel size so that the panel can't be resized in width less than that
    // needed to display the default columns
    int[] colWidths = schedulerTable.getColumnWidths();
    int prefWidth = 8 + colWidths[0] + colWidths[1] + (schedulerHndlr.getSchedulerOption() == TELEMETRY_SCHEDULER ? colWidths[2] : 0);
    schedulerScrollPane.setPreferredSize(new Dimension(prefWidth, schedulerScrollPane.getPreferredSize().height));
    schedulerPnl.setMinimumSize(schedulerScrollPane.getPreferredSize());
    // Create the scheduler table label
    JLabel schedulerLbl = new JLabel("Scheduler");
    schedulerLbl.setFont(ModifiableFontInfo.LABEL_BOLD.getFont());
    schedulerLbl.setForeground(ModifiableColorInfo.SPECIAL_LABEL_TEXT.getColor());
    // Add the scheduler label and scroll pane to the panel
    schedulerPnl.add(schedulerLbl, gbc);
    gbc.weighty = 1.0;
    gbc.insets.top = ModifiableSpacingInfo.LABEL_VERTICAL_SPACING.getSpacing() / 2;
    gbc.insets.bottom = ModifiableSpacingInfo.LABEL_VERTICAL_SPACING.getSpacing() / 2;
    gbc.gridy++;
    schedulerPnl.add(schedulerScrollPane, gbc);
    // Create the assignment list label and add it to the panel
    JLabel assignmentLbl = new JLabel("");
    assignmentLbl.setFont(ModifiableFontInfo.LABEL_BOLD.getFont());
    assignmentLbl.setForeground(ModifiableColorInfo.SPECIAL_LABEL_TEXT.getColor());
    gbc.insets.top = 0;
    gbc.weighty = 0.0;
    gbc.gridx = 0;
    gbc.gridy = 0;
    assignmentPnl.add(assignmentLbl, gbc);
    gbc.weighty = 1.0;
    gbc.gridy = 1;
    // Check if this is the telemetry scheduler
    if (schedulerHndlr.getSchedulerOption() == TELEMETRY_SCHEDULER) {
        // Adjust the tab area's insets so that the scheduler and tabs are aligned. Note that
        // the Nimbus L&F has hard-coded insets, so can't be changed;
        UIManager.getDefaults().put("TabbedPane.tabAreaInsets", new Insets(0, 0, 0, 0));
        UIManager.getDefaults().put("TabbedPane.tabsOverlapBorder", true);
        // Create a tabbed pane to contain the variable tree for the message and any
        // sub-messages
        tabbedPane = new JTabbedPane(JTabbedPane.TOP);
        tabbedPane.setFont(ModifiableFontInfo.LABEL_BOLD.getFont());
        // Listen for tab selection changes
        tabbedPane.addChangeListener(new ChangeListener() {

            /**
             ********************************************************************************
             * Handle tab selection change
             ********************************************************************************
             */
            @Override
            public void stateChanged(ChangeEvent ce) {
                // update the assignment tree
                if (!isTabUpdate) {
                    // Get the currently selected tab index
                    int tabIndex = tabbedPane.getSelectedIndex();
                    // Check if a tab is selected
                    if (tabIndex != -1) {
                        // Get the currently selected message in the scheduler table
                        Message message = getSelectedMessage();
                        // Check if a message is selected
                        if (message != null) {
                            // Select the row and column in the scheduler table corresponding
                            // to the selected message tab
                            schedulerTable.changeSelection(schedulerTable.getSelectedRow(), SchedulerColumn.ID.ordinal() + tabIndex, false, false);
                        }
                    }
                    // Update the assignment tree/list
                    updateAssignmentList();
                }
            }
        });
        // Set the assignment tree title
        assignmentLbl.setText("Assigned Variables");
        // Create the assignment tree and place it within the tabbed pane
        tabbedPane.insertTab("<html><i>No message selected", null, assignmentTree.createTreePanel(TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION), null, 0);
        // Add the tabbed pane to the panel
        assignmentPnl.add(tabbedPane, gbc);
    } else // Check if this is the application scheduler
    if (schedulerHndlr.getSchedulerOption() == APPLICATION_SCHEDULER) {
        // Set the assignment list title
        assignmentLbl.setText("Assigned Applications");
        // Add the assignment list to the panel
        gbc.insets.top = 0;
        assignmentPnl.add(assignScrollPane, gbc);
        // Set the tabbed pane to null so that the application scheduler ignores it
        tabbedPane = null;
    }
    // Add the scheduler table and assignment tree/list to the split pane
    tableSpltPn = new CustomSplitPane(schedulerPnl, assignmentPnl, null, JSplitPane.HORIZONTAL_SPLIT);
}

Example 84 with ListSelectionListener

use of javax.swing.event.ListSelectionListener in project CCDD by nasa.

the class CcddScriptManagerDialog method initialize.

/**
 ********************************************************************************************
 * Create the script association manager dialog. This is executed in a separate thread since it
 * can take a noticeable amount time to complete, and by using a separate thread the GUI is
 * allowed to continue to update. The GUI menu commands, however, are disabled until the
 * telemetry scheduler initialization completes execution
 ********************************************************************************************
 */
private void initialize() {
    // user confirms ignoring the changes
    if (ccddMain.ignoreUncommittedChanges("Script Manager", "Ignore changes?", false, null, CcddScriptManagerDialog.this)) {
        // Build the script association manager dialog in the background
        CcddBackgroundCommand.executeInBackground(ccddMain, new BackgroundCommand() {

            // Create panels to hold the components of the dialog
            JPanel dialogPnl = new JPanel(new GridBagLayout());

            JPanel buttonPnl = new JPanel();

            /**
             ********************************************************************************
             * Build the script association manager dialog
             ********************************************************************************
             */
            @Override
            protected void execute() {
                isNodeSelectionChanging = false;
                // Create borders for the input fields
                border = BorderFactory.createCompoundBorder(BorderFactory.createBevelBorder(BevelBorder.LOWERED, Color.LIGHT_GRAY, Color.GRAY), BorderFactory.createEmptyBorder(ModifiableSpacingInfo.INPUT_FIELD_PADDING.getSpacing(), ModifiableSpacingInfo.INPUT_FIELD_PADDING.getSpacing(), ModifiableSpacingInfo.INPUT_FIELD_PADDING.getSpacing(), ModifiableSpacingInfo.INPUT_FIELD_PADDING.getSpacing()));
                Border emptyBorder = BorderFactory.createEmptyBorder();
                // Set the initial layout manager characteristics
                GridBagConstraints gbc = new GridBagConstraints(0, 0, 1, 1, 0.0, 0.0, GridBagConstraints.LINE_START, GridBagConstraints.BOTH, new Insets(0, 0, ModifiableSpacingInfo.LABEL_VERTICAL_SPACING.getSpacing(), ModifiableSpacingInfo.LABEL_HORIZONTAL_SPACING.getSpacing()), 0, 0);
                dialogPnl.setBorder(emptyBorder);
                // Create a panel to contain the script file name, association name, and
                // association description labels and fields
                JPanel inputPnl = new JPanel(new GridBagLayout());
                // Add the script file selection components to the input panel
                inputPnl.add(createScriptSelectionPanel(), gbc);
                // Create the name label and field, and add these to the input panel
                JLabel nameLbl = new JLabel("Script association name");
                nameLbl.setFont(ModifiableFontInfo.LABEL_BOLD.getFont());
                gbc.insets.top = ModifiableSpacingInfo.LABEL_VERTICAL_SPACING.getSpacing() / 2;
                gbc.gridy++;
                inputPnl.add(nameLbl, gbc);
                nameFld = new JTextField("", 1);
                nameFld.setFont(ModifiableFontInfo.INPUT_TEXT.getFont());
                nameFld.setEditable(true);
                nameFld.setForeground(ModifiableColorInfo.INPUT_TEXT.getColor());
                nameFld.setBackground(ModifiableColorInfo.INPUT_BACK.getColor());
                nameFld.setBorder(border);
                gbc.insets.top = 0;
                gbc.insets.left = ModifiableSpacingInfo.LABEL_HORIZONTAL_SPACING.getSpacing();
                gbc.weightx = 1.0;
                gbc.gridy++;
                inputPnl.add(nameFld, gbc);
                // Create the description label and field, and add these to the input panel
                JLabel descriptionLbl = new JLabel("Script association description");
                descriptionLbl.setFont(ModifiableFontInfo.LABEL_BOLD.getFont());
                gbc.insets.top = ModifiableSpacingInfo.LABEL_VERTICAL_SPACING.getSpacing() / 2;
                gbc.insets.left = 0;
                gbc.weightx = 0.0;
                gbc.gridy++;
                inputPnl.add(descriptionLbl, gbc);
                descriptionFld = new JTextArea("", 3, 1);
                descriptionFld.setFont(ModifiableFontInfo.INPUT_TEXT.getFont());
                descriptionFld.setEditable(true);
                descriptionFld.setWrapStyleWord(true);
                descriptionFld.setLineWrap(true);
                descriptionFld.setForeground(ModifiableColorInfo.INPUT_TEXT.getColor());
                descriptionFld.setBackground(ModifiableColorInfo.INPUT_BACK.getColor());
                descriptionFld.setBorder(emptyBorder);
                JScrollPane scrollPane = new JScrollPane(descriptionFld);
                scrollPane.setBackground(ModifiableColorInfo.INPUT_BACK.getColor());
                scrollPane.setBorder(emptyBorder);
                scrollPane.setViewportBorder(border);
                scrollPane.setMinimumSize(scrollPane.getPreferredSize());
                gbc.insets.top = 0;
                gbc.insets.left = ModifiableSpacingInfo.LABEL_HORIZONTAL_SPACING.getSpacing();
                gbc.insets.bottom = ModifiableSpacingInfo.LABEL_VERTICAL_SPACING.getSpacing() * 2;
                gbc.gridwidth = GridBagConstraints.REMAINDER;
                gbc.weightx = 1.0;
                gbc.weighty = 1.0;
                gbc.gridy++;
                inputPnl.add(scrollPane, gbc);
                // Add the input panel and the table selection components to the inputs pane
                // within a horizontally split pane. Use a separator to denote the split pane's
                // drag component
                JSeparator inputSep = new JSeparator(SwingConstants.VERTICAL);
                inputSep.setForeground(dialogPnl.getBackground().darker());
                CustomSplitPane inputsPane = new CustomSplitPane(inputPnl, createSelectionPanel("Select associated tables", TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION), inputSep, JSplitPane.HORIZONTAL_SPLIT);
                // Add the inputs pane and the script association table components to the
                // dialog within a vertically split pane. Use a separator to denote the split
                // pane's drag component
                JSeparator assnSep = new JSeparator();
                assnSep.setForeground(dialogPnl.getBackground().darker());
                gbc.weighty = 1.0;
                gbc.insets.top = ModifiableSpacingInfo.LABEL_VERTICAL_SPACING.getSpacing();
                gbc.insets.bottom = 0;
                gbc.gridy = 0;
                dialogPnl.add(new CustomSplitPane(inputsPane, scriptHandler.getAssociationsPanel("Script Associations", true, CcddScriptManagerDialog.this), assnSep, JSplitPane.VERTICAL_SPLIT), gbc);
                // Get a reference to the script associations table to shorten subsequent calls
                assnsTable = scriptHandler.getAssociationsTable();
                // Store the initial table data
                doAssnUpdatesComplete(false);
                // Add a listener for script association table row selection changes
                assnsTable.getSelectionModel().addListSelectionListener(new ListSelectionListener() {

                    /**
                     ************************************************************************
                     * Handle a table row selection change. Populate the script description
                     * field, file field, and table tree based on the first selected
                     * associations table row
                     ************************************************************************
                     */
                    @Override
                    public void valueChanged(ListSelectionEvent lse) {
                        // for a keyboard input this returns false)
                        if (!lse.getValueIsAdjusting()) {
                            // Get the first selected table row
                            int row = assnsTable.getSelectedRow();
                            // Check if a table row item is selected
                            if (row != -1) {
                                // Store the association name in the the name field
                                nameFld.setText(assnsTable.getValueAt(row, assnsTable.convertColumnIndexToView(AssociationsTableColumnInfo.NAME.ordinal())).toString());
                                // Store the association description in the the description
                                // field
                                descriptionFld.setText(assnsTable.getValueAt(row, assnsTable.convertColumnIndexToView(AssociationsTableColumnInfo.DESCRIPTION.ordinal())).toString());
                                // Store the script file name with path in the the script file
                                // field
                                scriptFld.setText(assnsTable.getValueAt(row, assnsTable.convertColumnIndexToView(AssociationsTableColumnInfo.SCRIPT_FILE.ordinal())).toString());
                                // Separate the table member portion into the individual table
                                // names. The line breaks used for HTML formatting must be
                                // replaced by line feed characters so that the split is made
                                // correctly
                                String[] tableNames = CcddUtilities.removeHTMLTags(assnsTable.getValueAt(row, assnsTable.convertColumnIndexToView(AssociationsTableColumnInfo.MEMBERS.ordinal())).toString().replaceAll("<br>", "\n")).split(Pattern.quote(ASSN_TABLE_SEPARATOR));
                                List<TreePath> paths = new ArrayList<>();
                                // Step through each table name
                                for (String tableName : tableNames) {
                                    ToolTipTreeNode node;
                                    // Check if the name refers to a group
                                    if (tableName.startsWith(GROUP_DATA_FIELD_IDENT)) {
                                        // Get the node in the table tree for this group
                                        node = tableTree.getNodeByNodeName(tableName.substring(GROUP_DATA_FIELD_IDENT.length()));
                                    } else // The name refers to a table
                                    {
                                        // Get the node in the table tree for this table name
                                        node = tableTree.getNodeByNodePath(tableName);
                                    }
                                    // Check if the table name is in the tree
                                    if (node != null) {
                                        // Add the path to the list
                                        paths.add(CcddCommonTreeHandler.getPathFromNode(node));
                                    }
                                }
                                // Select the associated tables in the table tree
                                tableTree.setSelectionPaths(paths.toArray(new TreePath[0]));
                            }
                        }
                    }
                });
                // Define the buttons for the lower panel: Add association button
                JButton btnAddAssn = CcddButtonPanelHandler.createButton("Add", INSERT_ICON, KeyEvent.VK_A, "Add the currently defined script association");
                // Add a listener for the Add button
                btnAddAssn.addActionListener(new ActionListener() {

                    /**
                     ************************************************************************
                     * Add a new script association
                     ************************************************************************
                     */
                    @Override
                    public void actionPerformed(ActionEvent ae) {
                        // Check that a script is specified
                        if (!scriptFld.getText().trim().isEmpty()) {
                            addAssociation(TableInsertionPoint.START);
                        } else // The script file field is blank
                        {
                            // Inform the user that a script must be selected
                            new CcddDialogHandler().showMessageDialog(ccddMain.getMainFrame(), "<html><b>Must enter or select a script", "Script Missing", JOptionPane.WARNING_MESSAGE, DialogOption.OK_OPTION);
                        }
                    }
                });
                // Remove script association(s) button
                JButton btnRemoveAssn = CcddButtonPanelHandler.createButton("Remove", DELETE_ICON, KeyEvent.VK_R, "Remove the selected script association(s)");
                // Add a listener for the Remove button
                btnRemoveAssn.addActionListener(new ActionListener() {

                    /**
                     ************************************************************************
                     * Remove the selected script association(s)
                     ************************************************************************
                     */
                    @Override
                    public void actionPerformed(ActionEvent ae) {
                        removeAssociations();
                    }
                });
                // Replace script association(s) button
                JButton btnReplaceAssn = CcddButtonPanelHandler.createButton("Replace", REPLACE_ICON, KeyEvent.VK_P, "Replace the selected script association");
                // Add a listener for the Replace button
                btnReplaceAssn.addActionListener(new ActionListener() {

                    /**
                     ************************************************************************
                     * Replace the selected script association
                     ************************************************************************
                     */
                    @Override
                    public void actionPerformed(ActionEvent ae) {
                        replaceAssociation();
                    }
                });
                // Move Up button
                JButton btnMoveUp = CcddButtonPanelHandler.createButton("Up", UP_ICON, KeyEvent.VK_U, "Move the selected row(s) up");
                // Create a listener for the Move Up command
                btnMoveUp.addActionListener(new ValidateCellActionListener() {

                    /**
                     ************************************************************************
                     * Move the selected row(s) up in the table
                     ************************************************************************
                     */
                    @Override
                    protected void performAction(ActionEvent ae) {
                        assnsTable.moveRowUp();
                    }

                    /**
                     ************************************************************************
                     * Get the reference to the currently displayed table
                     ************************************************************************
                     */
                    @Override
                    protected CcddJTableHandler getTable() {
                        return assnsTable;
                    }
                });
                // Move Down button
                JButton btnMoveDown = CcddButtonPanelHandler.createButton("Down", DOWN_ICON, KeyEvent.VK_W, "Move the selected row(s) down");
                // Create a listener for the Move Down command
                btnMoveDown.addActionListener(new ValidateCellActionListener() {

                    /**
                     ************************************************************************
                     * Move the selected row(s) down in the table
                     ************************************************************************
                     */
                    @Override
                    protected void performAction(ActionEvent ae) {
                        assnsTable.moveRowDown();
                    }

                    /**
                     ************************************************************************
                     * Get the reference to the currently displayed table
                     ************************************************************************
                     */
                    @Override
                    protected CcddJTableHandler getTable() {
                        return assnsTable;
                    }
                });
                // Undo button
                JButton btnUndo = CcddButtonPanelHandler.createButton("Undo", UNDO_ICON, KeyEvent.VK_Z, "Undo the last edit action");
                // Create a listener for the Undo command
                btnUndo.addActionListener(new ValidateCellActionListener() {

                    /**
                     ************************************************************************
                     * Undo the last addition to the script association table
                     ************************************************************************
                     */
                    @Override
                    protected void performAction(ActionEvent ae) {
                        assnsTable.getUndoManager().undo();
                    }

                    /**
                     ************************************************************************
                     * Get the reference to the currently displayed table
                     ************************************************************************
                     */
                    @Override
                    protected CcddJTableHandler getTable() {
                        return assnsTable;
                    }
                });
                // Redo button
                JButton btnRedo = CcddButtonPanelHandler.createButton("Redo", REDO_ICON, KeyEvent.VK_Y, "Redo the last undone edit action");
                // Create a listener for the Redo command
                btnRedo.addActionListener(new ValidateCellActionListener() {

                    /**
                     ************************************************************************
                     * Redo the last addition to the script association table that was undone
                     ************************************************************************
                     */
                    @Override
                    protected void performAction(ActionEvent ae) {
                        assnsTable.getUndoManager().redo();
                    }

                    /**
                     ************************************************************************************
                     * Get the reference to the currently displayed table
                     ************************************************************************************
                     */
                    @Override
                    protected CcddJTableHandler getTable() {
                        return assnsTable;
                    }
                });
                // Script execution button
                btnExecute = CcddButtonPanelHandler.createButton("Execute", EXECUTE_ICON, KeyEvent.VK_E, "Execute the selected script association(s)");
                // Add a listener for the Execute button
                btnExecute.addActionListener(new ActionListener() {

                    /**
                     ************************************************************************
                     * Execute the selected script association(s)
                     ************************************************************************
                     */
                    @Override
                    public void actionPerformed(ActionEvent ae) {
                        // Execute the selected associations
                        scriptHandler.executeScriptAssociations(tableTree, CcddScriptManagerDialog.this);
                    }
                });
                // Store script associations button
                JButton btnStoreAssns = CcddButtonPanelHandler.createButton("Store", STORE_ICON, KeyEvent.VK_S, "Store the updated script associations to the database");
                // Add a listener for the Store button
                btnStoreAssns.addActionListener(new ActionListener() {

                    /**
                     ************************************************************************
                     * Store the script associations in the database
                     ************************************************************************
                     */
                    @Override
                    public void actionPerformed(ActionEvent ae) {
                        // associations
                        if (assnsTable.isTableChanged(committedAssnsData, Arrays.asList(new Integer[] { AssociationsTableColumnInfo.AVAILABLE.ordinal() })) && new CcddDialogHandler().showMessageDialog(CcddScriptManagerDialog.this, "<html><b>Store script associations?", "Store Associations", JOptionPane.QUESTION_MESSAGE, DialogOption.OK_CANCEL_OPTION) == OK_BUTTON) {
                            // Disable the dialog buttons until the updates complete
                            setControlsEnabled(false);
                            // Store the script associations list into the database
                            dbTable.storeInformationTableInBackground(InternalTable.ASSOCIATIONS, createAssociationsFromTable(), null, CcddScriptManagerDialog.this);
                        }
                    }
                });
                // Close button
                JButton btnClose = CcddButtonPanelHandler.createButton("Close", CLOSE_ICON, KeyEvent.VK_C, "Close the script association manager");
                // Add a listener for the Close button
                btnClose.addActionListener(new ActionListener() {

                    /**
                     ************************************************************************
                     * Close the script association dialog
                     ************************************************************************
                     */
                    @Override
                    public void actionPerformed(ActionEvent ae) {
                        // user elects to discard the changes
                        if (!isAssociationsChanged() || new CcddDialogHandler().showMessageDialog(CcddScriptManagerDialog.this, "<html><b>Discard changes?", "Discard Changes", JOptionPane.QUESTION_MESSAGE, DialogOption.OK_CANCEL_OPTION) == OK_BUTTON) {
                            // Reset the reference to the script associations manager in the
                            // script handler since the handler remains active)
                            scriptHandler.setScriptDialog(null);
                            // Close the dialog
                            closeFrame();
                        }
                    }
                });
                // Add buttons in the order in which they'll appear (left to right, top to
                // bottom)
                buttonPnl.add(btnAddAssn);
                buttonPnl.add(btnReplaceAssn);
                buttonPnl.add(btnMoveUp);
                buttonPnl.add(btnUndo);
                buttonPnl.add(btnStoreAssns);
                buttonPnl.add(btnRemoveAssn);
                buttonPnl.add(btnExecute);
                buttonPnl.add(btnMoveDown);
                buttonPnl.add(btnRedo);
                buttonPnl.add(btnClose);
                // Distribute the buttons across two rows
                setButtonRows(2);
            }

            /**
             ********************************************************************************
             * Script association manager dialog creation complete
             ********************************************************************************
             */
            @Override
            protected void complete() {
                // Display the script association management dialog
                createFrame(ccddMain.getMainFrame(), dialogPnl, buttonPnl, btnExecute, DIALOG_TITLE, null);
            }
        });
    }
}

Example 85 with ListSelectionListener

use of javax.swing.event.ListSelectionListener in project mafscaling by vimsh.

the class WotPullsGroups method getGroups.

public void getGroups(JMultiSelectionBox wotPlotsColumn, ArrayList<TreeSet<String>> wotYAxisGroups) {
    columns = wotPlotsColumn.getSelectedItems();
    if (columns == null || columns.size() < 2)
        return;
    Collections.sort(columns);
    columnsPanel = new JPanel();
    GridBagLayout gbl_dataPanel = new GridBagLayout();
    gbl_dataPanel.columnWidths = new int[] { 0, 0, 0, 0, 0, 0 };
    gbl_dataPanel.rowHeights = new int[] { 0, 0, 0 };
    gbl_dataPanel.columnWeights = new double[] { 1.0, 0.0, 1.0, 0.0, 1.0, 1.0 };
    gbl_dataPanel.rowWeights = new double[] { 0.0, 1.0, 1.0 };
    columnsPanel.setLayout(gbl_dataPanel);
    JPanel buttons = new JPanel();
    buttons.setLayout(new BoxLayout(buttons, BoxLayout.X_AXIS));
    buttons.setBorder(BorderFactory.createEmptyBorder(5, 0, 5, 0));
    JButton button = new JButton("Add group");
    button.setActionCommand("addgrp");
    button.addActionListener(this);
    buttons.add(button);
    buttons.add(Box.createRigidArea(new Dimension(5, 0)));
    button = new JButton("Remove group");
    button.setActionCommand("remgrp");
    button.addActionListener(this);
    buttons.add(button);
    GridBagConstraints gbc_pane = new GridBagConstraints();
    gbc_pane.insets = insets0;
    gbc_pane.anchor = GridBagConstraints.PAGE_START;
    gbc_pane.fill = GridBagConstraints.HORIZONTAL;
    gbc_pane.gridx = 0;
    gbc_pane.gridy = 0;
    gbc_pane.gridwidth = 5;
    columnsPanel.add(buttons, gbc_pane);
    gbc_pane = new GridBagConstraints();
    gbc_pane.insets = insets2;
    gbc_pane.anchor = GridBagConstraints.PAGE_START;
    gbc_pane.fill = GridBagConstraints.BOTH;
    gbc_pane.gridx = 0;
    gbc_pane.gridy = 1;
    gbc_pane.gridheight = 2;
    groupTable = createTable(true, "Groups");
    groupTable.getSelectionModel().addListSelectionListener(new ListSelectionListener() {

        @Override
        public void valueChanged(ListSelectionEvent event) {
            int idx = groupTable.getSelectedRow();
            if (idx >= 0) {
                while (selectionModel.getRowCount() > 0) selectionModel.removeRow(0);
                TreeSet<String> group = groups.get(groupTable.getValueAt(idx, 0));
                for (String val : group) selectionModel.addRow(new Object[] { val });
            }
        }
    });
    groupModel = (DefaultTableModel) groupTable.getModel();
    JScrollPane tableScroll = new JScrollPane(groupTable);
    tableScroll.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
    tableScroll.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
    tableScroll.getViewport().setBackground(Color.WHITE);
    tableScroll.setPreferredSize(new Dimension(200, 200));
    columnsPanel.add(tableScroll, gbc_pane);
    gbc_pane = new GridBagConstraints();
    gbc_pane.insets = insets2;
    gbc_pane.anchor = GridBagConstraints.PAGE_START;
    gbc_pane.fill = GridBagConstraints.BOTH;
    gbc_pane.gridx = 2;
    gbc_pane.gridy = 1;
    gbc_pane.gridheight = 2;
    selectionTable = createTable(false, "Grouped Columns");
    selectionModel = (DefaultTableModel) selectionTable.getModel();
    tableScroll = new JScrollPane(selectionTable);
    tableScroll.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
    tableScroll.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
    tableScroll.getViewport().setBackground(Color.WHITE);
    tableScroll.setPreferredSize(new Dimension(200, 200));
    columnsPanel.add(tableScroll, gbc_pane);
    gbc_pane = new GridBagConstraints();
    gbc_pane.insets = insets2;
    gbc_pane.anchor = GridBagConstraints.PAGE_START;
    gbc_pane.fill = GridBagConstraints.BOTH;
    gbc_pane.gridx = 4;
    gbc_pane.gridy = 1;
    gbc_pane.gridheight = 2;
    columnsTable = createTable(false, "Available Columns");
    columnsModel = (DefaultTableModel) columnsTable.getModel();
    for (String column : columns) columnsModel.addRow(new Object[] { column });
    tableScroll = new JScrollPane(columnsTable);
    tableScroll.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
    tableScroll.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
    tableScroll.getViewport().setBackground(Color.WHITE);
    tableScroll.setPreferredSize(new Dimension(200, 200));
    columnsPanel.add(tableScroll, gbc_pane);
    gbc_pane = new GridBagConstraints();
    gbc_pane.anchor = GridBagConstraints.NORTH;
    gbc_pane.insets = insets0;
    gbc_pane.gridx = 1;
    gbc_pane.gridy = 1;
    gbc_pane.gridheight = 2;
    columnsPanel.add(Box.createRigidArea(new Dimension(25, 0)), gbc_pane);
    gbc_pane = new GridBagConstraints();
    gbc_pane.anchor = GridBagConstraints.SOUTH;
    gbc_pane.insets = insets0;
    gbc_pane.gridx = 3;
    gbc_pane.gridy = 1;
    button = new JButton("", arrowImageLeft);
    button.putClientProperty("Nimbus.Overrides", zeroInsets);
    button.setMargin(insets0);
    button.setBorderPainted(false);
    button.setContentAreaFilled(false);
    button.setActionCommand("select");
    button.addActionListener(this);
    columnsPanel.add(button, gbc_pane);
    gbc_pane = new GridBagConstraints();
    gbc_pane.anchor = GridBagConstraints.NORTH;
    gbc_pane.insets = insets0;
    gbc_pane.gridx = 3;
    gbc_pane.gridy = 2;
    button = new JButton("", arrowImageRigth);
    button.putClientProperty("Nimbus.Overrides", zeroInsets);
    button.setMargin(insets0);
    button.setBorderPainted(false);
    button.setContentAreaFilled(false);
    button.setActionCommand("unselect");
    button.addActionListener(this);
    columnsPanel.add(button, gbc_pane);
    columnsPanel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
    for (int i = 0; i < wotYAxisGroups.size(); ++i) {
        if (wotYAxisGroups.get(i).size() > 1) {
            String group = "Group " + (i + 1);
            groups.put(group, wotYAxisGroups.get(i));
            groupModel.addRow(new Object[] { group });
            for (String val : wotYAxisGroups.get(i)) {
                int idx = columns.indexOf(val);
                columns.remove(idx);
                columnsModel.removeRow(idx);
            }
        }
    }
    if (groupModel.getRowCount() > 0)
        groupTable.changeSelection(0, 0, false, false);
    if (JOptionPane.OK_OPTION != JOptionPane.showConfirmDialog(null, columnsPanel, "Columns Y-Axis Grouping", JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE))
        return;
    wotYAxisGroups.clear();
    for (String key : groups.keySet()) {
        TreeSet<String> group = groups.get(key);
        if (group.size() > 0)
            wotYAxisGroups.add(group);
    }
}