Example 21 with BackgroundCommand
use of CCDD.CcddBackgroundCommand.BackgroundCommand in project CCDD by nasa.
the class CcddFieldTableEditorDialog method displayDataFieldTableEditor.
/**
********************************************************************************************
* Create the data field table editor 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 displayDataFieldTableEditor() {
// Build the data field editor table 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();
JButton btnClose;
/**
************************************************************************************
* Build the data field table editor dialog
************************************************************************************
*/
@Override
protected void execute() {
// Set the initial layout manager characteristics
GridBagConstraints gbc = new GridBagConstraints(0, 0, 1, 1, 1.0, 1.0, GridBagConstraints.LINE_START, GridBagConstraints.HORIZONTAL, new Insets(ModifiableSpacingInfo.LABEL_VERTICAL_SPACING.getSpacing(), 0, 0, 0), ModifiableSpacingInfo.LABEL_HORIZONTAL_SPACING.getSpacing(), 0);
// Define the panel to contain the table
JPanel tablePnl = new JPanel();
tablePnl.setLayout(new BoxLayout(tablePnl, BoxLayout.X_AXIS));
tablePnl.setBorder(BorderFactory.createEtchedBorder(EtchedBorder.LOWERED));
tablePnl.add(createDataFieldTableEditorTable());
// Add the table to the dialog
gbc.gridx = 0;
gbc.gridy++;
gbc.gridwidth = GridBagConstraints.REMAINDER;
gbc.fill = GridBagConstraints.BOTH;
gbc.weighty = 1.0;
dialogPnl.add(tablePnl, gbc);
// Add the field display filter label and a filter check box for each field owner
// type
JLabel fieldFilterLbl = new JLabel("Show fields belonging to:");
fieldFilterLbl.setFont(ModifiableFontInfo.LABEL_BOLD.getFont());
fieldFilterLbl.setBorder(emptyBorder);
gbc.gridwidth = 1;
gbc.weightx = 0.0;
gbc.weighty = 0.0;
gbc.gridy++;
dialogPnl.add(fieldFilterLbl, gbc);
final JCheckBox projectFilterCbx = new JCheckBox("Project", isProjectFilter);
projectFilterCbx.setFont(ModifiableFontInfo.LABEL_BOLD.getFont());
projectFilterCbx.setBorder(emptyBorder);
gbc.gridx++;
dialogPnl.add(projectFilterCbx, gbc);
final JCheckBox tableFilterCbx = new JCheckBox("Tables", isTableFilter);
tableFilterCbx.setFont(ModifiableFontInfo.LABEL_BOLD.getFont());
tableFilterCbx.setBorder(emptyBorder);
gbc.gridx++;
dialogPnl.add(tableFilterCbx, gbc);
final JCheckBox groupFilterCbx = new JCheckBox("Groups", isGroupFilter);
groupFilterCbx.setFont(ModifiableFontInfo.LABEL_BOLD.getFont());
groupFilterCbx.setBorder(emptyBorder);
gbc.gridx++;
dialogPnl.add(groupFilterCbx, gbc);
final JCheckBox typeFilterCbx = new JCheckBox("Table types", isTypeFilter);
typeFilterCbx.setFont(ModifiableFontInfo.LABEL_BOLD.getFont());
typeFilterCbx.setBorder(emptyBorder);
gbc.gridx++;
dialogPnl.add(typeFilterCbx, gbc);
// Create a row filter for displaying the fields based on selected filter
rowFilter = new RowFilter<TableModel, Object>() {
/**
****************************************************************************
* Override method that determines if a row should be displayed
****************************************************************************
*/
@Override
public boolean include(Entry<? extends TableModel, ? extends Object> owner) {
boolean isFilter = true;
// Get the data field owner's name
String ownerName = highlightFieldOwner(owner.getValue(FieldTableEditorColumnInfo.OWNER.ordinal()).toString(), false);
// Check if this field belongs to the project
if (ownerName.startsWith(CcddFieldHandler.getFieldProjectName())) {
// Show this row if the project filter check box is selected
isFilter = projectFilterCbx.isSelected();
} else // Check if this field belongs to a group
if (ownerName.startsWith(CcddFieldHandler.getFieldGroupName(""))) {
// Show this row if the group filter check box is selected
isFilter = groupFilterCbx.isSelected();
} else // Check if this field belongs to a table type
if (ownerName.startsWith(CcddFieldHandler.getFieldTypeName(""))) {
// Show this row if the table type filter check box is selected
isFilter = typeFilterCbx.isSelected();
} else // The field belongs to a table
{
// Show this row if the table filter check box is selected
isFilter = tableFilterCbx.isSelected();
}
return isFilter;
}
};
// Create a listener for check box selection changes
ActionListener filterListener = new ActionListener() {
/**
****************************************************************************
* Handle check box selection changes
****************************************************************************
*/
@Override
public void actionPerformed(ActionEvent ae) {
// Set the table's row sorter based on whether or not any rows are visible
dataFieldTable.setRowSorter(null);
dataFieldTable.setTableSortable();
// Issue a table change event so the rows are filtered
((DefaultTableModel) dataFieldTable.getModel()).fireTableDataChanged();
((DefaultTableModel) dataFieldTable.getModel()).fireTableStructureChanged();
}
};
// Add the listener to the filter check boxes
projectFilterCbx.addActionListener(filterListener);
tableFilterCbx.addActionListener(filterListener);
groupFilterCbx.addActionListener(filterListener);
typeFilterCbx.addActionListener(filterListener);
// Define the buttons for the lower panel: Select data fields button
JButton btnSelect = CcddButtonPanelHandler.createButton("Select", OK_ICON, KeyEvent.VK_L, "Select new data fields");
// Add a listener for the Select button
btnSelect.addActionListener(new ValidateCellActionListener(dataFieldTable) {
/**
****************************************************************************
* Select the data fields and update the data field editor table
****************************************************************************
*/
@Override
protected void performAction(ActionEvent ae) {
// Confirm discarding pending changes if any exist
if ((!isFieldTableChanged() || new CcddDialogHandler().showMessageDialog(CcddFieldTableEditorDialog.this, "<html><b>Discard changes?", "Discard Changes", JOptionPane.QUESTION_MESSAGE, DialogOption.OK_CANCEL_OPTION) == OK_BUTTON)) {
// Store the current filter selections
isProjectFilter = projectFilterCbx.isSelected();
isTableFilter = tableFilterCbx.isSelected();
isGroupFilter = groupFilterCbx.isSelected();
isTypeFilter = typeFilterCbx.isSelected();
// Allow the user to select the data fields to display
selectDataFields();
}
}
});
// Delete data fields button
JButton btnRemove = CcddButtonPanelHandler.createButton("Remove", DELETE_ICON, KeyEvent.VK_R, "Remove the selected data field(s) from their table(s)");
// Add a listener for the Remove button
btnRemove.addActionListener(new ValidateCellActionListener(dataFieldTable) {
/**
****************************************************************************
* Toggle the removal state of the selected data field(s)
****************************************************************************
*/
@Override
protected void performAction(ActionEvent ae) {
toggleRemoveFields();
}
});
// Open tables button
JButton btnOpen = CcddButtonPanelHandler.createButton("Open", TABLE_ICON, KeyEvent.VK_O, "Open the table(s) associated with the selected data field(s)");
// Add a listener for the Open button
btnOpen.addActionListener(new ValidateCellActionListener(dataFieldTable) {
/**
****************************************************************************
* Open the table(s) associated with the selected data field(s)
****************************************************************************
*/
@Override
protected void performAction(ActionEvent ae) {
openTables();
}
});
// Print data field editor table button
JButton btnPrint = CcddButtonPanelHandler.createButton("Print", PRINT_ICON, KeyEvent.VK_P, "Print the data field editor table");
// Add a listener for the Print button
btnPrint.addActionListener(new ValidateCellActionListener(dataFieldTable) {
/**
****************************************************************************
* Print the data field editor table
****************************************************************************
*/
@Override
protected void performAction(ActionEvent ae) {
dataFieldTable.printTable("Data Field Contents", null, CcddFieldTableEditorDialog.this, PageFormat.LANDSCAPE);
}
});
// 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(dataFieldTable) {
/**
****************************************************************************
* Undo the last cell edit
****************************************************************************
*/
@Override
protected void performAction(ActionEvent ae) {
dataFieldTable.getUndoManager().undo();
}
});
// 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(dataFieldTable) {
/**
****************************************************************************
* Redo the last cell edit that was undone
****************************************************************************
*/
@Override
protected void performAction(ActionEvent ae) {
dataFieldTable.getUndoManager().redo();
}
});
// Store data field values button
JButton btnStore = CcddButtonPanelHandler.createButton("Store", STORE_ICON, KeyEvent.VK_S, "Store data field changes");
// Add a listener for the Store button
btnStore.addActionListener(new ValidateCellActionListener(dataFieldTable) {
/**
****************************************************************************
* Store changes to the data field values
****************************************************************************
*/
@Override
protected void performAction(ActionEvent ae) {
// and the user confirms the action
if (isFieldTableChanged() && new CcddDialogHandler().showMessageDialog(CcddFieldTableEditorDialog.this, "<html><b>Store changes in project database?", "Store Changes", JOptionPane.QUESTION_MESSAGE, DialogOption.OK_CANCEL_OPTION) == OK_BUTTON) {
// Build the update lists
buildUpdates();
// Store the changes to the data fields in the database
dbTable.modifyDataFields(fieldModifications, fieldDeletions, CcddFieldTableEditorDialog.this);
}
}
});
// Close button
btnClose = CcddButtonPanelHandler.createButton("Close", CLOSE_ICON, KeyEvent.VK_C, "Close the data field editor dialog");
// Add a listener for the Close button
btnClose.addActionListener(new ValidateCellActionListener(dataFieldTable) {
/**
****************************************************************************
* Close the data field editor dialog
****************************************************************************
*/
@Override
protected void performAction(ActionEvent ae) {
windowCloseButtonAction();
}
});
// Add the buttons to the panel
buttonPnl.add(btnSelect);
buttonPnl.add(btnOpen);
buttonPnl.add(btnUndo);
buttonPnl.add(btnStore);
buttonPnl.add(btnRemove);
buttonPnl.add(btnPrint);
buttonPnl.add(btnRedo);
buttonPnl.add(btnClose);
// Distribute the buttons across two rows
setButtonRows(2);
}
/**
************************************************************************************
* Data field table editor dialog creation complete
************************************************************************************
*/
@Override
protected void complete() {
// Display the data field table editor dialog
createFrame(ccddMain.getMainFrame(), dialogPnl, buttonPnl, btnClose, DIALOG_TITLE, null);
// Reposition the field table editor dialog
positionFieldEditorDialog();
}
});
}
Also used :
JPanel(javax.swing.JPanel)
GridBagConstraints(java.awt.GridBagConstraints)
Insets(java.awt.Insets)
GridBagLayout(java.awt.GridBagLayout)
ActionEvent(java.awt.event.ActionEvent)
BoxLayout(javax.swing.BoxLayout)
JButton(javax.swing.JButton)
JLabel(javax.swing.JLabel)
JCheckBox(javax.swing.JCheckBox)
RowFilter(javax.swing.RowFilter)
ActionListener(java.awt.event.ActionListener)
ValidateCellActionListener(CCDD.CcddClassesComponent.ValidateCellActionListener)
ValidateCellActionListener(CCDD.CcddClassesComponent.ValidateCellActionListener)
BackgroundCommand(CCDD.CcddBackgroundCommand.BackgroundCommand)
TableModel(javax.swing.table.TableModel)
DefaultTableModel(javax.swing.table.DefaultTableModel)
Example 22 with BackgroundCommand
use of CCDD.CcddBackgroundCommand.BackgroundCommand in project CCDD by nasa.
the class CcddTableTypeEditorDialog method initialize.
/**
********************************************************************************************
* Create the table type editor 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
*
* @param typeNames
* array containing the table type names
********************************************************************************************
*/
private void initialize(final String[] typeNames) {
// Build the table type editor dialog in the background
CcddBackgroundCommand.executeInBackground(ccddMain, new BackgroundCommand() {
// Create panel to hold the dialog buttons
JPanel buttonPnl = new JPanel();
/**
************************************************************************************
* Build the table type editor dialog
************************************************************************************
*/
@Override
protected void execute() {
// Menu ///////////////////////////////////////////////////////////////////////////
// Create the table menu bar
JMenuBar menuBar = new JMenuBar();
setJMenuBar(menuBar);
// Create the File menu and menu items
mnFile = ccddMain.createMenu(menuBar, "File", KeyEvent.VK_F, 1, null);
mntmNewType = ccddMain.createMenuItem(mnFile, "New type", KeyEvent.VK_N, 1, "Create a new table type");
mntmCopyType = ccddMain.createMenuItem(mnFile, "Copy type", KeyEvent.VK_O, 1, "Copy the current table type");
mntmRenameType = ccddMain.createMenuItem(mnFile, "Rename type", KeyEvent.VK_R, 1, "Rename the current table type");
mntmDeleteType = ccddMain.createMenuItem(mnFile, "Delete type", KeyEvent.VK_D, 1, "Delete the current table type");
mnFile.addSeparator();
mntmStore = ccddMain.createMenuItem(mnFile, "Store current", KeyEvent.VK_U, 1, "Store changes to the curent table type in the database");
mntmStoreAll = ccddMain.createMenuItem(mnFile, "Store all", KeyEvent.VK_L, 1, "Store changes to all table types in the database");
mnFile.addSeparator();
mntmPrint = ccddMain.createMenuItem(mnFile, "Print current", KeyEvent.VK_P, 1, "Print the current table type information");
mnFile.addSeparator();
mntmClose = ccddMain.createMenuItem(mnFile, "Close", KeyEvent.VK_C, 1, "Close the table type editor");
// Create the Edit menu and menu items
JMenu mnEdit = ccddMain.createMenu(menuBar, "Edit", 1, KeyEvent.VK_E, null);
mntmCopy = ccddMain.createMenuItem(mnEdit, "Copy", KeyEvent.VK_O, 1, "Copy the currently selected cell(s) to the clipboard");
mntmPaste = ccddMain.createMenuItem(mnEdit, "Paste (Ctrl-V)", KeyEvent.VK_V, 1, "Paste the clipboard contents at the current focus location");
mntmInsert = ccddMain.createMenuItem(mnEdit, "Insert", KeyEvent.VK_I, 1, "Insert the clipboard contents at the current focus location");
mnEdit.addSeparator();
mntmUndo = ccddMain.createMenuItem(mnEdit, "Undo (Ctrl-Z)", KeyEvent.VK_Z, 1, "Undo the last edit operation");
mntmRedo = ccddMain.createMenuItem(mnEdit, "Redo (Ctrl-Y)", KeyEvent.VK_Y, 1, "Redo the last undone edit operation");
mnEdit.addSeparator();
mntmClear = ccddMain.createMenuItem(mnEdit, "Clear data", KeyEvent.VK_L, 1, "Clear the current table type contents");
mntmInsertCmdArgs = ccddMain.createMenuItem(mnEdit, "Add command arguments", KeyEvent.VK_A, 1, "Add the default columns for a command argument");
// Create the Row menu and menu items
JMenu mnRow = ccddMain.createMenu(menuBar, "Row", KeyEvent.VK_R, 1, null);
mntmInsertRow = ccddMain.createMenuItem(mnRow, "Insert row", KeyEvent.VK_I, 1, "Insert a row below the current focus location");
mntmDeleteRow = ccddMain.createMenuItem(mnRow, "Delete row(s)", KeyEvent.VK_D, 1, "Delete the currently selected row(s)");
mnRow.addSeparator();
mntmMoveUp = ccddMain.createMenuItem(mnRow, "Move up", KeyEvent.VK_U, 1, "Move the currently selected row(s) up one row");
mntmMoveDown = ccddMain.createMenuItem(mnRow, "Move down", KeyEvent.VK_N, 1, "Move the currently selected row(s) down one row");
// Create the Field menu and menu items
JMenu mnField = ccddMain.createMenu(menuBar, "Field", KeyEvent.VK_L, 1, null);
mntmManageFields = ccddMain.createMenuItem(mnField, "Manage fields", KeyEvent.VK_M, 1, "Open the data field manager");
mntmClearValues = ccddMain.createMenuItem(mnField, "Clear values", KeyEvent.VK_C, 1, "Clear the data field values");
mntmOverwrite = ccddMain.createCheckBoxMenuItem(mnField, "Overwrite values", KeyEvent.VK_O, 1, "Overwrite/don't overwrite existing data field values", false);
// Add a listener for the New Type command
mntmNewType.addActionListener(new ValidateCellActionListener() {
/**
****************************************************************************
* Create a new table type
****************************************************************************
*/
@Override
protected void performAction(ActionEvent ae) {
new CcddTableTypeManagerDialog(ccddMain, CcddTableTypeEditorDialog.this, ManagerDialogType.NEW);
}
/**
****************************************************************************
* Get the table for which the action is performed
*
* @return Table for which the action is performed
****************************************************************************
*/
@Override
protected CcddJTableHandler getTable() {
return getActiveTable();
}
});
// Add a listener for the Copy Type command
mntmCopyType.addActionListener(new ValidateCellActionListener() {
/**
****************************************************************************
* Copy a table type
****************************************************************************
*/
@Override
protected void performAction(ActionEvent ae) {
new CcddTableTypeManagerDialog(ccddMain, CcddTableTypeEditorDialog.this, ManagerDialogType.COPY);
}
/**
****************************************************************************
* Get the table for which the action is performed
*
* @return Table for which the action is performed
****************************************************************************
*/
@Override
protected CcddJTableHandler getTable() {
return getActiveTable();
}
});
// Add a listener for the Rename Type command
mntmRenameType.addActionListener(new ValidateCellActionListener() {
/**
****************************************************************************
* Rename a table type
****************************************************************************
*/
@Override
protected void performAction(ActionEvent ae) {
new CcddTableTypeManagerDialog(ccddMain, CcddTableTypeEditorDialog.this, ManagerDialogType.RENAME);
}
/**
****************************************************************************
* Get the table for which the action is performed
*
* @return Table for which the action is performed
****************************************************************************
*/
@Override
protected CcddJTableHandler getTable() {
return getActiveTable();
}
});
// Add a listener for the Delete Type command
mntmDeleteType.addActionListener(new ValidateCellActionListener() {
/**
****************************************************************************
* Delete a table type
****************************************************************************
*/
@Override
protected void performAction(ActionEvent ae) {
new CcddTableTypeManagerDialog(ccddMain, CcddTableTypeEditorDialog.this, ManagerDialogType.DELETE);
}
/**
****************************************************************************
* Get the table for which the action is performed
*
* @return Table for which the action is performed
****************************************************************************
*/
@Override
protected CcddJTableHandler getTable() {
return getActiveTable();
}
});
// Add a listener for the Print command
mntmPrint.addActionListener(new ValidateCellActionListener() {
/**
****************************************************************************
* Output the type to the printer
****************************************************************************
*/
@Override
protected void performAction(ActionEvent ae) {
activeEditor.getTable().printTable("Table Type: " + activeEditor.getTypeName(), activeEditor.getFieldHandler(), CcddTableTypeEditorDialog.this, PageFormat.LANDSCAPE);
}
/**
****************************************************************************
* Get the table for which the action is performed
*
* @return Table for which the action is performed
****************************************************************************
*/
@Override
protected CcddJTableHandler getTable() {
return getActiveTable();
}
});
// Add a listener for the Copy command
mntmCopy.addActionListener(new ValidateCellActionListener() {
/**
****************************************************************************
* Copy the selected table cell(s) contents into the clipboard
****************************************************************************
*/
@Override
protected void performAction(ActionEvent ae) {
// Send a Ctrl-C key press
controlKeyAction(KeyEvent.VK_C);
}
/**
****************************************************************************
* Get the table for which the action is performed
*
* @return Table for which the action is performed
****************************************************************************
*/
@Override
protected CcddJTableHandler getTable() {
return getActiveTable();
}
});
// Add a listener for the Paste command
mntmPaste.addActionListener(new ValidateCellActionListener() {
/**
****************************************************************************
* Paste the clipboard contents in the table, overwriting any existing data in
* the target cells and adding new rows at the end of the table if needed
****************************************************************************
*/
@Override
protected void performAction(ActionEvent ae) {
// Send a Ctrl-V key press
controlKeyAction(KeyEvent.VK_V);
}
/**
****************************************************************************
* Get the table for which the action is performed
*
* @return Table for which the action is performed
****************************************************************************
*/
@Override
protected CcddJTableHandler getTable() {
return getActiveTable();
}
});
// Add a listener for the Insert command
mntmInsert.addActionListener(new ValidateCellActionListener() {
/**
****************************************************************************
* Insert the clipboard contents in the table, creating new rows to contain the
* data
****************************************************************************
*/
@Override
protected void performAction(ActionEvent ae) {
// Send a ctrl-I key press
controlKeyAction(KeyEvent.VK_I);
}
/**
****************************************************************************
* Get the table for which the action is performed
*
* @return Table for which the action is performed
****************************************************************************
*/
@Override
protected CcddJTableHandler getTable() {
return getActiveTable();
}
});
// Add a listener for the Clear command
mntmClear.addActionListener(new ValidateCellActionListener() {
/**
****************************************************************************
* Clear the table contents
****************************************************************************
*/
@Override
protected void performAction(ActionEvent ae) {
// Check if there are any rows to clear
if (activeEditor.getTable().getModel().getRowCount() != 0) {
// Select all rows and remove them
activeEditor.getTable().selectAll();
activeEditor.getTable().removeRows(activeEditor.getTable().getSelectedRows());
}
}
/**
****************************************************************************
* Get the table for which the action is performed
*
* @return Table for which the action is performed
****************************************************************************
*/
@Override
protected CcddJTableHandler getTable() {
return getActiveTable();
}
});
// Add a listener for the Insert command arguments command
mntmInsertCmdArgs.addActionListener(new ValidateCellActionListener() {
/**
****************************************************************************
* Insert the default columns for a command argument
****************************************************************************
*/
@Override
protected void performAction(ActionEvent ae) {
boolean isIndexUsed;
int argumentIndex = 1;
do {
// Set the flag to indicate that the argument index isn't used
isIndexUsed = false;
// Step through each column name in the table type
for (String columnName : activeEditor.getTypeDefinition().getColumnNamesUser()) {
// argument name for this argument index
if (columnName.startsWith(COL_ARGUMENT + " " + argumentIndex + " ")) {
// Set the flag to indicate that the argument index is used,
// increment the argument index, and stop searching
isIndexUsed = true;
argumentIndex++;
break;
}
}
} while (isIndexUsed);
// Continue to search the column names while a match is found
int newArgStartIndex = activeEditor.getTypeDefinition().getColumnCountVisible();
// Create the command argument columns for the next unused argument index
activeEditor.getTypeDefinition().addCommandArgumentColumns(argumentIndex);
// Step through each new command argument column
for (; newArgStartIndex < activeEditor.getTypeDefinition().getColumnCountVisible(); newArgStartIndex++) {
// Insert the column into the table type editor
activeEditor.getTable().insertRow(false, TableInsertionPoint.END, activeEditor.getTypeDefinition().getData()[newArgStartIndex]);
}
}
/**
****************************************************************************
* Get the table for which the action is performed
*
* @return Table for which the action is performed
****************************************************************************
*/
@Override
protected CcddJTableHandler getTable() {
return getActiveTable();
}
});
// Add a listener for the Store All command
mntmStoreAll.addActionListener(new ValidateCellActionListener() {
/**
****************************************************************************
* Store the changes to all open table contents, if any, in the database
****************************************************************************
*/
@Override
protected void performAction(ActionEvent ae) {
// confirms the action
if (isTypesChanged() && new CcddDialogHandler().showMessageDialog(CcddTableTypeEditorDialog.this, "<html><b>Store changes for all?", "Store Changes", JOptionPane.QUESTION_MESSAGE, DialogOption.OK_CANCEL_OPTION) == OK_BUTTON && ccddMain.ignoreUncommittedChanges("Store Changes", "Discard table changes?", false, changedTypes, CcddTableTypeEditorDialog.this)) {
// Commit the changes for all of the editors
storeAllChanges();
}
}
/**
****************************************************************************
* Get the table for which the action is performed
*
* @return Table for which the action is performed
****************************************************************************
*/
@Override
protected CcddJTableHandler getTable() {
return getActiveTable();
}
});
// Add a listener for the Manage Fields command
mntmManageFields.addActionListener(new ValidateCellActionListener() {
/**
****************************************************************************
* Manage the data fields
****************************************************************************
*/
@Override
protected void performAction(ActionEvent ae) {
new CcddFieldEditorDialog(ccddMain, activeEditor, CcddFieldHandler.getFieldTypeName(activeEditor.getTypeName()), tableTypeHandler.getTypeDefinition(activeEditor.getTypeName()).isStructure(), MIN_WINDOW_WIDTH);
// Enable/disable the Clear values command depending on if any data fields
// remain
mntmClearValues.setEnabled(!activeEditor.getFieldHandler().getFieldInformation().isEmpty());
}
/**
****************************************************************************
* Get the table for which the action is performed
*
* @return Table for which the action is performed
****************************************************************************
*/
@Override
protected CcddJTableHandler getTable() {
return getActiveTable();
}
});
// Add a listener for the Clear Values command
mntmClearValues.addActionListener(new ValidateCellActionListener() {
/**
****************************************************************************
* Clear the table data field values
****************************************************************************
*/
@Override
protected void performAction(ActionEvent ae) {
// Check if there are any data fields to clear
if (!activeEditor.getFieldHandler().getFieldInformation().isEmpty()) {
// Remove all of the data field values
activeEditor.getInputFieldPanelHandler().clearFieldValues();
}
}
/**
****************************************************************************
* Get the table for which the action is performed
*
* @return Table for which the action is performed
****************************************************************************
*/
@Override
protected CcddJTableHandler getTable() {
return getActiveTable();
}
});
// Insert new row button
JButton btnInsertRow = CcddButtonPanelHandler.createButton("Ins Row", INSERT_ICON, KeyEvent.VK_I, "Insert a new row into the table");
// Create a listener for the Insert Row command
ActionListener insertAction = new ValidateCellActionListener() {
/**
****************************************************************************
* Insert a new row into the table at the selected location
****************************************************************************
*/
@Override
protected void performAction(ActionEvent ae) {
activeEditor.getTable().insertEmptyRow(true);
}
/**
****************************************************************************
* Get the table for which the action is performed
*
* @return Table for which the action is performed
****************************************************************************
*/
@Override
protected CcddJTableHandler getTable() {
return getActiveTable();
}
};
// Add the insert listener to the Insert Row button and menu command
btnInsertRow.addActionListener(insertAction);
mntmInsertRow.addActionListener(insertAction);
// Delete row button
JButton btnDeleteRow = CcddButtonPanelHandler.createButton("Del Row", DELETE_ICON, KeyEvent.VK_D, "Delete the selected row(s) from the table");
// Create a listener for the Delete Row command
ActionListener deleteAction = new ValidateCellActionListener() {
/**
****************************************************************************
* Delete the selected row(s) from the table
****************************************************************************
*/
@Override
protected void performAction(ActionEvent ae) {
activeEditor.getTable().deleteRow(true);
}
/**
****************************************************************************
* Get the table for which the action is performed
*
* @return Table for which the action is performed
****************************************************************************
*/
@Override
protected CcddJTableHandler getTable() {
return getActiveTable();
}
};
// Add the delete listener to the Delete Row button and menu command
btnDeleteRow.addActionListener(deleteAction);
mntmDeleteRow.addActionListener(deleteAction);
// 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
ActionListener moveUpAction = new ValidateCellActionListener() {
/**
****************************************************************************
* Move the selected row(s) up in the table
****************************************************************************
*/
@Override
protected void performAction(ActionEvent ae) {
activeEditor.getTable().moveRowUp();
}
/**
****************************************************************************
* Get the table for which the action is performed
*
* @return Table for which the action is performed
****************************************************************************
*/
@Override
protected CcddJTableHandler getTable() {
return getActiveTable();
}
};
// Add the move up listener to the Move Up button and menu command
btnMoveUp.addActionListener(moveUpAction);
mntmMoveUp.addActionListener(moveUpAction);
// Move Down button
JButton btnMoveDown = CcddButtonPanelHandler.createButton("Down", DOWN_ICON, KeyEvent.VK_N, "Move the selected row(s) down");
// Create a listener for the Move Down command
ActionListener moveDownAction = new ValidateCellActionListener() {
/**
****************************************************************************
* Move the selected row(s) down in the table
****************************************************************************
*/
@Override
protected void performAction(ActionEvent ae) {
activeEditor.getTable().moveRowDown();
}
/**
****************************************************************************
* Get the table for which the action is performed
*
* @return Table for which the action is performed
****************************************************************************
*/
@Override
protected CcddJTableHandler getTable() {
return getActiveTable();
}
};
// Add the move down listener to the Move Down button and menu command
btnMoveDown.addActionListener(moveDownAction);
mntmMoveDown.addActionListener(moveDownAction);
// Undo button
JButton btnUndo = CcddButtonPanelHandler.createButton("Undo", UNDO_ICON, KeyEvent.VK_Z, "Undo the last edit action");
// Create a listener for the Undo command
ActionListener undoAction = new ValidateCellActionListener() {
/**
****************************************************************************
* Undo the last cell edit
****************************************************************************
*/
@Override
protected void performAction(ActionEvent ae) {
activeEditor.getFieldPanelUndoManager().undo();
// Update the data field background colors
activeEditor.getInputFieldPanelHandler().setFieldBackgound();
}
/**
****************************************************************************
* Get the table for which the action is performed
*
* @return Table for which the action is performed
****************************************************************************
*/
@Override
protected CcddJTableHandler getTable() {
return getActiveTable();
}
};
// Add the undo listener to the Undo button and menu command
mntmUndo.addActionListener(undoAction);
btnUndo.addActionListener(undoAction);
// 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
ActionListener redoAction = new ValidateCellActionListener() {
/**
****************************************************************************
* Redo the last cell edit that was undone
****************************************************************************
*/
@Override
protected void performAction(ActionEvent ae) {
activeEditor.getFieldPanelUndoManager().redo();
// Update the data field background colors
activeEditor.getInputFieldPanelHandler().setFieldBackgound();
}
/**
****************************************************************************
* Get the table for which the action is performed
*
* @return Table for which the action is performed
****************************************************************************
*/
@Override
protected CcddJTableHandler getTable() {
return getActiveTable();
}
};
// Add the redo listener to the Redo button and menu command
mntmRedo.addActionListener(redoAction);
btnRedo.addActionListener(redoAction);
// Store button
JButton btnStore = CcddButtonPanelHandler.createButton("Store", STORE_ICON, KeyEvent.VK_S, "Store the table type updates in the database");
// Create a listener for the Store command
ActionListener storeAction = new ValidateCellActionListener() {
/**
****************************************************************************
* Store the changes to the table contents, if any, in the database
****************************************************************************
*/
@Override
protected void performAction(ActionEvent ae) {
// Set the list of changed table types to the active editor's type
changedTypes.clear();
changedTypes.add(activeEditor.getTypeName());
// the action
if (activeEditor.isTableChanged() && !activeEditor.checkForMissingColumns() && new CcddDialogHandler().showMessageDialog(CcddTableTypeEditorDialog.this, "<html><b>Store changes in project database?", "Store Changes", JOptionPane.QUESTION_MESSAGE, DialogOption.OK_CANCEL_OPTION) == OK_BUTTON && ccddMain.ignoreUncommittedChanges("Store Changes", "Discard table changes?", false, changedTypes, CcddTableTypeEditorDialog.this)) {
// Store the changes for the currently displayed editor in the database
storeChanges(activeEditor);
}
}
/**
****************************************************************************
* Get the table for which the action is performed
*
* @return Table for which the action is performed
****************************************************************************
*/
@Override
protected CcddJTableHandler getTable() {
return getActiveTable();
}
};
// Add the store listener to the Store button and menu command
btnStore.addActionListener(storeAction);
mntmStore.addActionListener(storeAction);
// Close button
btnClose = CcddButtonPanelHandler.createButton("Close", CLOSE_ICON, KeyEvent.VK_C, "Close the table type editor");
// Add a listener for the Close table type editor command
ActionListener closeAction = new ValidateCellActionListener() {
/**
****************************************************************************
* Close the type editor
****************************************************************************
*/
@Override
protected void performAction(ActionEvent ae) {
windowCloseButtonAction();
}
/**
****************************************************************************
* Get the table for which the action is performed
*
* @return Table for which the action is performed
****************************************************************************
*/
@Override
protected CcddJTableHandler getTable() {
return getActiveTable();
}
};
// Add the close listener to the Close button and menu command
btnClose.addActionListener(closeAction);
mntmClose.addActionListener(closeAction);
// Add buttons in the order in which they'll appear (left to right, top to bottom)
buttonPnl.add(btnInsertRow);
buttonPnl.add(btnMoveUp);
buttonPnl.add(btnUndo);
buttonPnl.add(btnStore);
buttonPnl.add(btnDeleteRow);
buttonPnl.add(btnMoveDown);
buttonPnl.add(btnRedo);
buttonPnl.add(btnClose);
// Distribute the buttons across two rows
setButtonRows(2);
// Table Editors //////////////////////////////////////////////////////////////////
// Create a tabbed pane for the editors to appear in
tabbedPane = new DnDTabbedPane(JTabbedPane.TOP) {
/**
****************************************************************************
* Update the table type editor list order following a tab move
****************************************************************************
*/
@Override
protected Object tabMoveCleanup(int oldTabIndex, int newTabIndex, Object tabContents) {
// Get the reference to the moved tab's original location in the list
CcddTableTypeEditorHandler editor = typeEditors.get(oldTabIndex);
// Remove the tab
typeEditors.remove(oldTabIndex);
// Add the tab at its new location
typeEditors.add(newTabIndex - (newTabIndex > oldTabIndex ? 1 : 0), editor);
// Update the active tab pointer to the moved tab
activeEditor = typeEditors.get(tabbedPane.getSelectedIndex());
return editor;
}
};
tabbedPane.setFont(ModifiableFontInfo.LABEL_BOLD.getFont());
// Listen for tab selection changes
tabbedPane.addChangeListener(new ChangeListener() {
/**
****************************************************************************
* Update the editor to the one associated with the selected tab
****************************************************************************
*/
@Override
public void stateChanged(ChangeEvent ce) {
// Check if a table type exists
if (!typeEditors.isEmpty()) {
// Set the active editor to the one indicated by the currently selected
// tab
activeEditor = typeEditors.get(tabbedPane.getSelectedIndex());
} else // No table type exists
{
// initialize the active editor to null
activeEditor = null;
}
// Update the editor controls state
setControlsEnabled(!typeEditors.isEmpty());
}
});
// Add each table as a tab in the editor dialog tabbed pane
addTypePanes(typeNames, dbTable.retrieveInformationTable(InternalTable.FIELDS, CcddTableTypeEditorDialog.this));
// Check if a table type exists
if (!typeEditors.isEmpty()) {
// Set the first tab as the active editor
activeEditor = typeEditors.get(0);
} else // No table type exists
{
// initialize the active editor to null
activeEditor = null;
}
}
/**
************************************************************************************
* Table type editor dialog creation complete
************************************************************************************
*/
@Override
protected void complete() {
// Display the table type editor dialog
createFrame(ccddMain.getMainFrame(), tabbedPane, buttonPnl, null, "Table Type Editor", null);
// Enable the editor controls
setControlsEnabled(true);
}
});
}
Also used :
JPanel(javax.swing.JPanel)
ActionEvent(java.awt.event.ActionEvent)
JButton(javax.swing.JButton)
TableInsertionPoint(CCDD.CcddConstants.TableInsertionPoint)
DnDTabbedPane(CCDD.CcddClassesComponent.DnDTabbedPane)
ActionListener(java.awt.event.ActionListener)
ValidateCellActionListener(CCDD.CcddClassesComponent.ValidateCellActionListener)
ChangeEvent(javax.swing.event.ChangeEvent)
ValidateCellActionListener(CCDD.CcddClassesComponent.ValidateCellActionListener)
ChangeListener(javax.swing.event.ChangeListener)
BackgroundCommand(CCDD.CcddBackgroundCommand.BackgroundCommand)
JMenuBar(javax.swing.JMenuBar)
JMenu(javax.swing.JMenu)
Example 23 with BackgroundCommand
use of CCDD.CcddBackgroundCommand.BackgroundCommand in project CCDD by nasa.
the class CcddGroupManagerDialog method initialize.
/**
********************************************************************************************
* Create the group 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() {
// Build the group 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();
JButton btnClose;
/**
************************************************************************************
* Build the group manager dialog
************************************************************************************
*/
@Override
protected void execute() {
isNodeSelectionChanging = false;
// Set the flag to indicate the group manager dialog is being initialized
isInitializing = true;
// Create borders for the dialog components
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()));
emptyBorder = BorderFactory.createEmptyBorder();
// Set the initial layout manager characteristics
GridBagConstraints gbc = new GridBagConstraints(0, 0, 1, 1, 1.0, 0.0, GridBagConstraints.LINE_START, GridBagConstraints.BOTH, new Insets(ModifiableSpacingInfo.LABEL_VERTICAL_SPACING.getSpacing() / 2, ModifiableSpacingInfo.LABEL_HORIZONTAL_SPACING.getSpacing() / 2, 0, 0), 0, 0);
selectedGroup = null;
deletedGroups = new ArrayList<String>();
// Add an undo edit manager
undoManager = new CcddUndoManager() {
/**
****************************************************************************
* Update the change indicator if the editor panel has changed
****************************************************************************
*/
@Override
protected void ownerHasChanged() {
// during initialization are ignored
if (!isInitializing) {
updateChangeIndicator();
}
}
};
// Create the undo handler for the components with undoable actions. Disable
// storage of edit actions during dialog creation
undoHandler = new CcddUndoHandler(undoManager);
nodeSelect = undoHandler.new UndoableTreePathSelection();
undoHandler.setAllowUndo(false);
// Build the group tree
groupTree = new CcddGroupTreeHandler(ccddMain, undoHandler, ccddMain.getMainFrame()) {
/**
****************************************************************************
* Respond to changes in selection of a node in the group tree
****************************************************************************
*/
@Override
protected void updateTableSelection() {
// Check that a node selection change is not in progress
if (!isNodeSelectionChanging) {
// Set the flag to prevent link tree updates
isNodeSelectionChanging = true;
// Needed for the group manager dialog's size to be adjusted for the
// data fields
groupMgr.setPreferredSize(null);
// Store any changes to the currently selected group, if applicable
updateSelectedGroupInformation();
// Update the description field text so that it can be undone/redone.
// The focus change, which is usually used to perform the update,
// occurs after the node selection edit and would cause the wrong
// description field to be changed
fieldPnlHndlr.updateDescriptionField(true);
// Get the name of the selected group(s)
String[] selected = getTopLevelSelectedNodeNames();
// If a single group is selected then set the selected group, enable
// and populate the description field, and display the group's data
// fields; otherwise clear the selected group, disable and clear the
// description field, and remove any data fields
setGroupAndFields(selected.length == 1 ? selected[0] : null);
// operation isn't recorded on the undo/redo stack
if (undoHandler.isAllowUndo()) {
// Add the node path selection change to the undo/redo stack and
// store the field information in the undo handler
nodeSelect.selectTreePath(getSelectedPaths());
fieldPnlHndlr.storeCurrentFieldInformation();
}
// Reset the flag to allow link tree updates
isNodeSelectionChanging = false;
}
}
};
// Get the references to the group and data field handlers created by the group
// tree. These are used to shorten subsequent calls
groupHandler = groupTree.getGroupHandler();
fieldHandler = groupTree.getFieldHandler();
// Set the data field handler and group tree references in the undo handler so that
// data field and tree edits can be undone/redone
undoHandler.setFieldHandler(fieldHandler);
undoHandler.setTree(groupTree);
// Store the initial group information
copyGroupInformation();
// Create panels to hold the components of the dialog
JPanel titlePnl = new JPanel(new GridBagLayout());
JPanel treePnl = new JPanel(new GridBagLayout());
dialogPnl.setBorder(emptyBorder);
titlePnl.setBorder(emptyBorder);
treePnl.setBorder(emptyBorder);
// Create the group manager dialog labels and fields
JLabel dlgLabel = new JLabel("Assign tables to groups");
dlgLabel.setFont(ModifiableFontInfo.LABEL_BOLD.getFont());
titlePnl.add(dlgLabel, gbc);
// Add the upper panel components to the dialog panel
dialogPnl.add(titlePnl, gbc);
// Build the table tree showing both table prototypes and table instances; i.e.,
// parent tables with their child tables (i.e., parents with children)
tableTree = new CcddTableTreeHandler(ccddMain, null, TableTreeType.TABLES, false, true, ccddMain.getMainFrame()) {
/**
****************************************************************************
* Respond to changes in selection of a node in the table tree
****************************************************************************
*/
@Override
protected void updateTableSelection() {
// Check that a node selection change is not in progress
if (!isNodeSelectionChanging) {
// Select the associated group in the group tree if a table is selected
// in the table tree. Note that below any linked variables are
// deselected, so this call must occur first
selectGroupByTable();
// Set the flag to prevent variable tree updates
isNodeSelectionChanging = true;
// Deselect any nodes that don't represent a table or the level
// immediately above the table level
clearNonTableNodes(1);
// Reset the flag to allow variable tree updates
isNodeSelectionChanging = false;
}
}
};
// Create a table tree panel and add it to another panel (in order to control
// spacing)
gbc.insets.top = 0;
gbc.insets.bottom = ModifiableSpacingInfo.LABEL_VERTICAL_SPACING.getSpacing() / 2;
gbc.weighty = 1.0;
treePnl.add(tableTree.createTreePanel("Tables", TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION, ccddMain.getMainFrame()), gbc);
gbc.insets.top = ModifiableSpacingInfo.LABEL_VERTICAL_SPACING.getSpacing() / 2;
gbc.insets.bottom = 0;
// Create a split pane containing the table tree in the left pane and the group
// tree in the right pane and add it to the panel. The arrow button panel is used
// as the split pane divider
gbc.insets.left = ModifiableSpacingInfo.LABEL_HORIZONTAL_SPACING.getSpacing();
gbc.insets.right = ModifiableSpacingInfo.LABEL_HORIZONTAL_SPACING.getSpacing();
gbc.gridy++;
dialogPnl.add(new CustomSplitPane(treePnl, groupTree.createTreePanel("Groups", TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION, false, ccddMain.getMainFrame()), createArrowButtonPanel(), JSplitPane.HORIZONTAL_SPLIT), gbc);
// Create the field panel for the description and data fields
fieldPnlHndlr = new CcddInputFieldPanelHandler() {
/**
****************************************************************************
* Update the group manager change indicator
****************************************************************************
*/
@Override
protected void updateOwnerChangeIndicator() {
updateChangeIndicator();
}
};
// Set the undo/redo manager and handler for the description and data field values
fieldPnlHndlr.setEditPanelUndo(undoManager, undoHandler);
// Create the description and data fields
fieldPnlHndlr.createDescAndDataFieldPanel(groupMgr, null, null, null, fieldHandler);
// Set the modal undo manager in the keyboard handler while the group manager is
// active
ccddMain.getKeyboardHandler().setModalDialogReference(undoManager, null);
// Re-enable storage of edit actions
undoHandler.setAllowUndo(true);
// Add the field panel to the dialog
gbc.insets.top = ModifiableSpacingInfo.LABEL_VERTICAL_SPACING.getSpacing() / 2;
gbc.insets.left = 0;
gbc.insets.bottom = 0;
gbc.insets.right = 0;
gbc.weighty = 0.0;
gbc.gridy++;
dialogPnl.add(fieldPnlHndlr.getFieldPanel(), gbc);
// Create a check box for showing/changing the group CFS application status
applicationCb = undoHandler.new UndoableCheckBox("Group represents a CFS application", false);
applicationCb.setFont(ModifiableFontInfo.LABEL_BOLD.getFont());
applicationCb.setBorder(emptyBorder);
applicationCb.setEnabled(false);
gbc.insets.top = ModifiableSpacingInfo.LABEL_VERTICAL_SPACING.getSpacing();
gbc.insets.left = ModifiableSpacingInfo.LABEL_HORIZONTAL_SPACING.getSpacing();
gbc.gridy = 0;
fieldPnlHndlr.getFieldPanel().add(applicationCb, gbc, 0);
// Add a listener for the application check box
applicationCb.addActionListener(new ActionListener() {
/**
****************************************************************************
* Handle a change in the application check box status
****************************************************************************
*/
@Override
public void actionPerformed(ActionEvent ae) {
// Check if the application check box is selected and a group is selected
if (((JCheckBox) ae.getSource()).isSelected() && selectedGroup != null) {
// The application check box selection and the added CFS application
// data fields should be a single edit action so that both are removed
// if an undo is performed. Remove the check box selection from the
// undo stack, disable automatic edit sequence ending, then perform the
// check box selection again so that it's added to the undo stack
// without ending the edit sequence
undoManager.undoRemoveEdit();
undoHandler.setAutoEndEditSequence(false);
applicationCb.setSelected(true);
// Get the field information for the group
GroupInformation groupInfo = groupHandler.getGroupInformationByName(selectedGroup.getName());
List<FieldInformation> fieldInformation = groupInfo.getFieldInformation();
// Step through each default application data field
for (DefaultApplicationField field : DefaultApplicationField.values()) {
// Create a new data field
FieldInformation newField = field.createFieldInformation(CcddFieldHandler.getFieldGroupName(selectedGroup.getName()));
boolean isExists = false;
// Step through the group's existing data fields
for (FieldInformation fieldInfo : fieldInformation) {
// Check if the data field already exists
if (newField.getFieldName().equals(fieldInfo.getFieldName())) {
// Set the flag indicating the field exists and stop
// searching
isExists = true;
break;
}
}
// Check if the field doesn't exists
if (!isExists) {
// Add the field to the group
fieldInformation.add(newField);
}
}
// Needed for the group manager dialog's size to be adjusted for the
// data fields
groupMgr.setPreferredSize(null);
// Store the data field additions so that the added fields appear in
// the dialog
fieldHandler.setFieldInformation(CcddFieldHandler.getFieldInformationCopy(fieldInformation));
// Rebuild the data field panel and update the dialog's size
recreateDataFieldPanel(true);
// Re-enable automatic edit sequence ending, then end the edit sequence
// to group the check box and added data fields
undoHandler.setAutoEndEditSequence(true);
undoManager.endEditSequence();
}
}
});
// Define the buttons for the lower panel: New group button
JButton btnNewGroup = CcddButtonPanelHandler.createButton("New", INSERT_ICON, KeyEvent.VK_N, "Create a new group");
// Add a listener for the New button
btnNewGroup.addActionListener(new ActionListener() {
/**
****************************************************************************
* Add a new group
****************************************************************************
*/
@Override
public void actionPerformed(ActionEvent ae) {
newGroup();
}
});
// Delete group button
JButton btnDeleteGroup = CcddButtonPanelHandler.createButton("Delete", DELETE_ICON, KeyEvent.VK_D, "Delete an existing group");
// Add a listener for the Delete button
btnDeleteGroup.addActionListener(new ActionListener() {
/**
****************************************************************************
* Delete the selected group(s)
****************************************************************************
*/
@Override
public void actionPerformed(ActionEvent ae) {
deleteGroup();
}
});
// Rename group button
btnRenameGroup = CcddButtonPanelHandler.createButton("Rename", RENAME_ICON, KeyEvent.VK_D, "Rename an existing group");
// Add a listener for the Rename button
btnRenameGroup.addActionListener(new ActionListener() {
/**
****************************************************************************
* Rename the selected group
****************************************************************************
*/
@Override
public void actionPerformed(ActionEvent ae) {
renameGroup();
}
});
// Copy group button
btnCopyGroup = CcddButtonPanelHandler.createButton("Copy", COPY_ICON, KeyEvent.VK_P, "Copy an existing group");
// Add a listener for the Copy button
btnCopyGroup.addActionListener(new ActionListener() {
/**
****************************************************************************
* Copy the selected group
****************************************************************************
*/
@Override
public void actionPerformed(ActionEvent ae) {
copyGroup();
}
});
// Manage fields button
btnManageFields = CcddButtonPanelHandler.createButton("Fields", FIELD_ICON, KeyEvent.VK_F, "Manage the data fields");
// Add a listener for the Manage Fields command
btnManageFields.addActionListener(new ActionListener() {
/**
****************************************************************************
* Manage the data fields
****************************************************************************
*/
@Override
public void actionPerformed(ActionEvent ae) {
// Create the field editor dialog showing the fields for this group
new CcddFieldEditorDialog(ccddMain, fieldPnlHndlr, CcddFieldHandler.getFieldGroupName(selectedGroup.getName()), false, ModifiableSizeInfo.MIN_DIALOG_WIDTH.getSize());
// Set the undo manager in the keyboard handler back to the group manager
ccddMain.getKeyboardHandler().setModalDialogReference(undoManager, null);
// Enable/disable the Clear values button depending on if any data fields
// remain
btnClearValues.setEnabled(!fieldHandler.getFieldInformation().isEmpty());
}
});
// Clear fields button
btnClearValues = CcddButtonPanelHandler.createButton("Clear", CLEAR_ICON, KeyEvent.VK_C, "Clear the data fields");
// Add a listener for the Clear values command
btnClearValues.addActionListener(new ActionListener() {
/**
****************************************************************************
* Clear the table data field values
****************************************************************************
*/
@Override
public void actionPerformed(ActionEvent ae) {
// Clear all of the data field values for the group
fieldPnlHndlr.clearFieldValues();
}
});
// Undo button
JButton btnUndo = CcddButtonPanelHandler.createButton("Undo", UNDO_ICON, KeyEvent.VK_Z, "Undo the last edit action");
// Create a listener for the Undo command
ActionListener undoAction = new ActionListener() {
/**
****************************************************************************
* Undo the last edit
****************************************************************************
*/
@Override
public void actionPerformed(ActionEvent ae) {
undoManager.undo();
// Update the group selection following an undo
undoHandler.setAllowUndo(false);
groupTree.updateTableSelection();
undoHandler.setAllowUndo(true);
// Update the data field background colors
fieldPnlHndlr.setFieldBackgound();
}
};
// Add the undo listener to the Undo button and menu command
btnUndo.addActionListener(undoAction);
// 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
ActionListener redoAction = new ActionListener() {
/**
****************************************************************************
* Redo the last cell that was undone
****************************************************************************
*/
@Override
public void actionPerformed(ActionEvent ae) {
undoManager.redo();
// Update the data field background colors
fieldPnlHndlr.setFieldBackgound();
}
};
// Add the redo listener to the Redo button and menu command
btnRedo.addActionListener(redoAction);
// Store groups button
JButton btnStoreGroups = CcddButtonPanelHandler.createButton("Store", STORE_ICON, KeyEvent.VK_S, "Store group updates in the database");
// Add a listener for the Store button
btnStoreGroups.addActionListener(new ActionListener() {
/**
****************************************************************************
* Store the groups in the database
****************************************************************************
*/
@Override
public void actionPerformed(ActionEvent ae) {
// editor is open and has changes that the user confirms discarding them
if (isGroupsChanged() && new CcddDialogHandler().showMessageDialog(groupMgr, "<html><b>Store groups?", "Store Groups", JOptionPane.QUESTION_MESSAGE, DialogOption.OK_CANCEL_OPTION) == OK_BUTTON && ignoreFieldTableChanges()) {
// Store the group list into the database
dbTable.storeInformationTableInBackground(InternalTable.GROUPS, currentGroups, updateFields, deletedGroups, null, null, groupMgr);
}
}
});
// Close button
btnClose = CcddButtonPanelHandler.createButton("Close", CLOSE_ICON, KeyEvent.VK_C, "Close the group manager");
// Add a listener for the Close button
btnClose.addActionListener(new ActionListener() {
/**
****************************************************************************
* Close the group selection dialog
****************************************************************************
*/
@Override
public void actionPerformed(ActionEvent ae) {
// discard the changes
if (!isGroupsChanged() || new CcddDialogHandler().showMessageDialog(groupMgr, "<html><b>Discard changes?", "Discard Changes", JOptionPane.QUESTION_MESSAGE, DialogOption.OK_CANCEL_OPTION) == OK_BUTTON) {
// Close the dialog
closeDialog();
// Clear the modal dialog references in the keyboard handler
ccddMain.getKeyboardHandler().setModalDialogReference(null, null);
}
}
});
// Set the initial enable status of the buttons
setGroupButtonsEnabled(false);
// Add buttons in the order in which they'll appear (left to right, top to bottom)
buttonPnl.add(btnNewGroup);
buttonPnl.add(btnRenameGroup);
buttonPnl.add(btnManageFields);
buttonPnl.add(btnUndo);
buttonPnl.add(btnStoreGroups);
buttonPnl.add(btnDeleteGroup);
buttonPnl.add(btnCopyGroup);
buttonPnl.add(btnClearValues);
buttonPnl.add(btnRedo);
buttonPnl.add(btnClose);
// Distribute the buttons across two rows
setButtonRows(2);
// Update the undo manager so that all group manager edits up to the press of the
// Store button can be undone/redone
fieldPnlHndlr.storeCurrentFieldInformation();
undoManager.endEditSequence();
// Reset the flag now that initialization is complete
isInitializing = false;
}
/**
************************************************************************************
* Group manager dialog creation complete
************************************************************************************
*/
@Override
protected void complete() {
// Display the group manager dialog
showOptionsDialog(ccddMain.getMainFrame(), dialogPnl, buttonPnl, btnClose, DIALOG_TITLE, true);
}
});
}
Also used :
JPanel(javax.swing.JPanel)
GridBagConstraints(java.awt.GridBagConstraints)
Insets(java.awt.Insets)
GridBagLayout(java.awt.GridBagLayout)
ActionEvent(java.awt.event.ActionEvent)
JButton(javax.swing.JButton)
ArrayList(java.util.ArrayList)
DefaultApplicationField(CCDD.CcddConstants.DefaultApplicationField)
CustomSplitPane(CCDD.CcddClassesComponent.CustomSplitPane)
UndoableCheckBox(CCDD.CcddUndoHandler.UndoableCheckBox)
GroupInformation(CCDD.CcddClassesDataTable.GroupInformation)
UndoableTreePathSelection(CCDD.CcddUndoHandler.UndoableTreePathSelection)
JLabel(javax.swing.JLabel)
ActionListener(java.awt.event.ActionListener)
BackgroundCommand(CCDD.CcddBackgroundCommand.BackgroundCommand)
FieldInformation(CCDD.CcddClassesDataTable.FieldInformation)
Example 24 with BackgroundCommand
use of CCDD.CcddBackgroundCommand.BackgroundCommand in project CCDD by nasa.
the class CcddScriptExecutiveDialog method initialize.
/**
********************************************************************************************
* Create the script executive 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, CcddScriptExecutiveDialog.this)) {
// Build the script executive 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 executive dialog
********************************************************************************
*/
@Override
protected void execute() {
// Set the initial layout manager characteristics
GridBagConstraints gbc = new GridBagConstraints(0, 0, 1, 1, 1.0, 0.0, GridBagConstraints.LINE_START, GridBagConstraints.BOTH, new Insets(ModifiableSpacingInfo.LABEL_VERTICAL_SPACING.getSpacing() / 2, ModifiableSpacingInfo.LABEL_HORIZONTAL_SPACING.getSpacing(), 0, ModifiableSpacingInfo.LABEL_HORIZONTAL_SPACING.getSpacing()), 0, 0);
dialogPnl.setBorder(BorderFactory.createEmptyBorder());
// Create the table group selection dialog labels and fields
JLabel scriptLbl = new JLabel("Select script association(s) to execute");
scriptLbl.setFont(ModifiableFontInfo.LABEL_BOLD.getFont());
dialogPnl.add(scriptLbl, gbc);
// Create the list to display the stored script associations and add it to the
// dialog
gbc.weighty = 1.0;
gbc.insets.top = 0;
gbc.gridy++;
dialogPnl.add(scriptHandler.getAssociationsPanel(null, false, CcddScriptExecutiveDialog.this), gbc);
// Execute selected script association(s) 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, CcddScriptExecutiveDialog.this);
}
});
// Close button
btnClose = CcddButtonPanelHandler.createButton("Close", CLOSE_ICON, KeyEvent.VK_C, "Close the script executive");
// Add a listener for the Close button
btnClose.addActionListener(new ActionListener() {
/**
************************************************************************
* Close the script execution dialog
************************************************************************
*/
@Override
public void actionPerformed(ActionEvent ae) {
// Reset the reference to the script associations executive in the
// script handler since the handler remains active)
scriptHandler.setScriptDialog(null);
closeFrame();
}
});
// Add buttons to the button panel
buttonPnl.add(btnExecute);
buttonPnl.add(btnClose);
}
/**
********************************************************************************
* Script executive dialog creation complete
********************************************************************************
*/
@Override
protected void complete() {
// Display the script execution dialog
createFrame(ccddMain.getMainFrame(), dialogPnl, buttonPnl, btnExecute, "Execute Script(s)", null);
}
});
}
}
Also used :
JPanel(javax.swing.JPanel)
GridBagConstraints(java.awt.GridBagConstraints)
Insets(java.awt.Insets)
GridBagLayout(java.awt.GridBagLayout)
ActionListener(java.awt.event.ActionListener)
ActionEvent(java.awt.event.ActionEvent)
JLabel(javax.swing.JLabel)
BackgroundCommand(CCDD.CcddBackgroundCommand.BackgroundCommand)
Example 25 with BackgroundCommand
use of CCDD.CcddBackgroundCommand.BackgroundCommand in project CCDD by nasa.
the class CcddLinkManagerDialog method initialize.
/**
********************************************************************************************
* Create the variable link 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() {
// Build the variable link 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();
JButton btnClose;
/**
************************************************************************************
* Build the variable link manager dialog
************************************************************************************
*/
@Override
protected void execute() {
// Create a border for the dialog components
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()));
// Set the initial layout manager characteristics
GridBagConstraints gbc = new GridBagConstraints(0, 0, 1, 1, 1.0, 1.0, GridBagConstraints.LINE_START, GridBagConstraints.BOTH, new Insets(0, 0, 0, 0), 0, 0);
// Create a tabbed pane to contain the rate parameters that are stream-specific
tabbedPane = new DnDTabbedPane(SwingConstants.TOP) {
/**
****************************************************************************
* Update the link manager list order following a tab move
****************************************************************************
*/
@Override
protected Object tabMoveCleanup(int oldTabIndex, int newTabIndex, Object tabContents) {
// Adjust the new tab index if moving the tab to a higher index
newTabIndex -= newTabIndex > oldTabIndex ? 1 : 0;
// Re-order the rate information based on the new tab order
RateInformation[] rateInfoArray = rateHandler.getRateInformation().toArray(new RateInformation[0]);
rateInfoArray = (RateInformation[]) CcddUtilities.moveArrayMember(rateInfoArray, oldTabIndex, newTabIndex);
List<RateInformation> rateInfoList = new ArrayList<RateInformation>(rateInfoArray.length);
rateInfoList.addAll(Arrays.asList(rateInfoArray));
rateHandler.setRateInformation(rateInfoList);
// Get the reference to the moved tab's original location in the list
CcddLinkManagerHandler editor = linkMgrs.get(oldTabIndex);
// Remove the tab
linkMgrs.remove(oldTabIndex);
// Add the tab at its new location
linkMgrs.add(newTabIndex, editor);
// Update the active tab pointer to the moved tab
activeHandler = linkMgrs.get(tabbedPane.getSelectedIndex());
return editor;
}
};
tabbedPane.setFont(ModifiableFontInfo.LABEL_BOLD.getFont());
// Listen for tab selection changes
tabbedPane.addChangeListener(new ChangeListener() {
/**
****************************************************************************
* Update the handler to the one associated with the selected tab
****************************************************************************
*/
@Override
public void stateChanged(ChangeEvent ce) {
// Set the active handler to the one indicated by the currently selected
// tab
activeHandler = linkMgrs.get(tabbedPane.getSelectedIndex());
// Get the number of selected links
int numSelectedLinks = activeHandler.getLinkTree().getSelectionCount();
// Update the manager controls state
setLinkButtonsEnabled(numSelectedLinks == 1, numSelectedLinks != 0);
// Set the modal undo manager reference in the keyboard handler while the
// link manager is active
ccddMain.getKeyboardHandler().setModalDialogReference(activeHandler.getUndoManager(), null);
}
});
gbc.gridwidth = 2;
gbc.gridx = 0;
gbc.gridy++;
dialogPnl.add(tabbedPane, gbc);
// Define the buttons for the lower panel: New link button
JButton btnNewLink = CcddButtonPanelHandler.createButton("New", INSERT_ICON, KeyEvent.VK_N, "Create a new link");
// Add a listener for the New button
btnNewLink.addActionListener(new ActionListener() {
/**
****************************************************************************
* Add a new link
****************************************************************************
*/
@Override
public void actionPerformed(ActionEvent ae) {
createLink();
}
});
// Delete link button
JButton btnDeleteLink = CcddButtonPanelHandler.createButton("Delete", DELETE_ICON, KeyEvent.VK_D, "Delete an existing link");
// Add a listener for the Delete button
btnDeleteLink.addActionListener(new ActionListener() {
/**
****************************************************************************
* Delete the selected link(s)
****************************************************************************
*/
@Override
public void actionPerformed(ActionEvent ae) {
deleteLink();
}
});
// Rename link button
btnRenameLink = CcddButtonPanelHandler.createButton("Rename", RENAME_ICON, KeyEvent.VK_D, "Rename an existing link");
// Add a listener for the Rename button
btnRenameLink.addActionListener(new ActionListener() {
/**
****************************************************************************
* Rename the selected link
****************************************************************************
*/
@Override
public void actionPerformed(ActionEvent ae) {
renameLink();
}
});
// Copy link button
btnCopyLink = CcddButtonPanelHandler.createButton("Copy", COPY_ICON, KeyEvent.VK_P, "Copy an existing link");
// Add a listener for the Copy button
btnCopyLink.addActionListener(new ActionListener() {
/**
****************************************************************************
* Copy the selected link
****************************************************************************
*/
@Override
public void actionPerformed(ActionEvent ae) {
copyLink();
}
});
// Undo button
JButton btnUndo = CcddButtonPanelHandler.createButton("Undo", UNDO_ICON, KeyEvent.VK_Z, "Undo the last edit action");
// Create a listener for the Undo command
ActionListener undoAction = new ActionListener() {
/**
****************************************************************************
* Undo the last edit
****************************************************************************
*/
@Override
public void actionPerformed(ActionEvent ae) {
activeHandler.getUndoManager().undo();
// Update the link selection following an undo
activeHandler.getUndoHandler().setAllowUndo(false);
activeHandler.getLinkTree().updateTableSelection();
activeHandler.getUndoHandler().setAllowUndo(true);
// Update the link definitions, selected link, link fields, and link tree
// node names
activeHandler.cleanUpLinks();
}
};
// Add the undo listener to the Undo button and menu command
btnUndo.addActionListener(undoAction);
// 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
ActionListener redoAction = new ActionListener() {
/**
****************************************************************************
* Redo the last edit that was undone
****************************************************************************
*/
@Override
public void actionPerformed(ActionEvent ae) {
activeHandler.getUndoManager().redo();
// Update the link definitions, selected link, link fields, and link tree
// node names
activeHandler.cleanUpLinks();
}
};
// Add the redo listener to the Redo button and menu command
btnRedo.addActionListener(redoAction);
// Store links button
JButton btnStoreLinks = CcddButtonPanelHandler.createButton("Store", STORE_ICON, KeyEvent.VK_S, "Store the link updates in the database");
// Add a listener for the Store button
btnStoreLinks.addActionListener(new ActionListener() {
/**
****************************************************************************
* Store the links in the database
****************************************************************************
*/
@Override
public void actionPerformed(ActionEvent ae) {
// the user confirms storing the links
if (isLinksChanged() && new CcddDialogHandler().showMessageDialog(CcddLinkManagerDialog.this, "<html><b>Store links?", "Store Links", JOptionPane.QUESTION_MESSAGE, DialogOption.OK_CANCEL_OPTION) == OK_BUTTON) {
// Store the links in the project database
storeLinks();
}
}
});
// Close button
btnClose = CcddButtonPanelHandler.createButton("Close", CLOSE_ICON, KeyEvent.VK_C, "Close the link manager");
// Add a listener for the Close button
btnClose.addActionListener(new ActionListener() {
/**
****************************************************************************
* Close the link selection dialog
****************************************************************************
*/
@Override
public void actionPerformed(ActionEvent ae) {
// discard the changes
if (!isLinksChanged() || new CcddDialogHandler().showMessageDialog(CcddLinkManagerDialog.this, "<html><b>Discard changes?", "Discard Changes", JOptionPane.QUESTION_MESSAGE, DialogOption.OK_CANCEL_OPTION) == OK_BUTTON) {
// Close the dialog
closeDialog();
// Clear the modal dialog references in the keyboard handler
ccddMain.getKeyboardHandler().setModalDialogReference(null, null);
}
}
});
// Add buttons in the order in which they'll appear (left to right, top to bottom)
buttonPnl.add(btnNewLink);
buttonPnl.add(btnRenameLink);
buttonPnl.add(btnUndo);
buttonPnl.add(btnStoreLinks);
buttonPnl.add(btnDeleteLink);
buttonPnl.add(btnCopyLink);
buttonPnl.add(btnRedo);
buttonPnl.add(btnClose);
// Distribute the buttons across two rows
setButtonRows(2);
// Add the data stream link handlers
addLinkHandlerPanes();
}
/**
************************************************************************************
* Variable link manager dialog creation complete
************************************************************************************
*/
@Override
protected void complete() {
// Display the link management dialog
showOptionsDialog(ccddMain.getMainFrame(), dialogPnl, buttonPnl, btnClose, "Manage Links", true);
}
});
}
Also used :
JPanel(javax.swing.JPanel)
GridBagConstraints(java.awt.GridBagConstraints)
Insets(java.awt.Insets)
GridBagLayout(java.awt.GridBagLayout)
ActionEvent(java.awt.event.ActionEvent)
JButton(javax.swing.JButton)
ArrayList(java.util.ArrayList)
RateInformation(CCDD.CcddClassesDataTable.RateInformation)
DnDTabbedPane(CCDD.CcddClassesComponent.DnDTabbedPane)
ChangeEvent(javax.swing.event.ChangeEvent)
ActionListener(java.awt.event.ActionListener)
ChangeListener(javax.swing.event.ChangeListener)
BackgroundCommand(CCDD.CcddBackgroundCommand.BackgroundCommand)
Aggregations
BackgroundCommand (CCDD.CcddBackgroundCommand.BackgroundCommand)26
JPanel (javax.swing.JPanel)16
GridBagConstraints (java.awt.GridBagConstraints)14
GridBagLayout (java.awt.GridBagLayout)14
Insets (java.awt.Insets)14
ActionEvent (java.awt.event.ActionEvent)13
ArrayList (java.util.ArrayList)11
ActionListener (java.awt.event.ActionListener)10
SQLException (java.sql.SQLException)10
JButton (javax.swing.JButton)9
JLabel (javax.swing.JLabel)8
ValidateCellActionListener (CCDD.CcddClassesComponent.ValidateCellActionListener)7
TypeDefinition (CCDD.CcddTableTypeHandler.TypeDefinition)4
List (java.util.List)4
BoxLayout (javax.swing.BoxLayout)4
JCheckBox (javax.swing.JCheckBox)4
DnDTabbedPane (CCDD.CcddClassesComponent.DnDTabbedPane)3
Border (javax.swing.border.Border)3
CustomSplitPane (CCDD.CcddClassesComponent.CustomSplitPane)2
CCDDException (CCDD.CcddClassesDataTable.CCDDException)2
