/** @file | |
The file is used to create, update BuildOptions of Fpd file | |
Copyright (c) 2006, Intel Corporation | |
All rights reserved. This program and the accompanying materials | |
are licensed and made available under the terms and conditions of the BSD License | |
which accompanies this distribution. The full text of the license may be found at | |
http://opensource.org/licenses/bsd-license.php | |
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, | |
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. | |
**/ | |
package org.tianocore.frameworkwizard.platform.ui; | |
import java.awt.BorderLayout; | |
import javax.swing.JPanel; | |
import javax.swing.JTabbedPane; | |
import javax.swing.JCheckBox; | |
import javax.swing.JLabel; | |
import java.awt.FlowLayout; | |
import javax.swing.AbstractAction; | |
import java.awt.event.ActionEvent; | |
import java.awt.event.ActionListener; | |
import java.awt.event.ComponentEvent; | |
import javax.swing.DefaultCellEditor; | |
import javax.swing.JFileChooser; | |
import javax.swing.JOptionPane; | |
import javax.swing.JTextField; | |
import javax.swing.JButton; | |
import javax.swing.JScrollPane; | |
import javax.swing.JTable; | |
import javax.swing.JComboBox; | |
import javax.swing.ListSelectionModel; | |
import javax.swing.event.DocumentEvent; | |
import javax.swing.event.DocumentListener; | |
import javax.swing.event.InternalFrameAdapter; | |
import javax.swing.event.InternalFrameEvent; | |
import javax.swing.event.ListSelectionEvent; | |
import javax.swing.event.ListSelectionListener; | |
import javax.swing.event.TableModelEvent; | |
import javax.swing.event.TableModelListener; | |
import javax.swing.table.DefaultTableModel; | |
import javax.swing.table.TableModel; | |
import org.tianocore.PlatformSurfaceAreaDocument; | |
import org.tianocore.frameworkwizard.FrameworkWizardUI; | |
import org.tianocore.frameworkwizard.common.DataValidation; | |
import org.tianocore.frameworkwizard.common.Tools; | |
import org.tianocore.frameworkwizard.common.Identifications.OpeningPlatformType; | |
import org.tianocore.frameworkwizard.common.ui.IInternalFrame; | |
import org.tianocore.frameworkwizard.workspace.Workspace; | |
import java.io.File; | |
import java.util.ArrayList; | |
import java.util.Iterator; | |
import java.util.LinkedHashMap; | |
import java.util.Set; | |
import java.util.Vector; | |
import java.awt.Dimension; | |
import javax.swing.JSplitPane; | |
import java.awt.GridLayout; | |
public class FpdBuildOptions extends IInternalFrame { | |
private final int oneRowHeight = 20; | |
private final int twoRowHeight = 40; | |
private final int sepHeight = 6; | |
private final int sepWidth = 10; | |
private final int buttonWidth = 90; | |
private final int rowOne = 12; | |
private final int dialogWidth = 600; | |
private final int rowTwo = rowOne + oneRowHeight + sepHeight; | |
private final int rowThree = rowTwo + oneRowHeight + sepHeight; | |
private final int rowFour = rowThree + oneRowHeight + sepHeight; | |
private final int rowFive = rowFour + oneRowHeight + sepHeight; | |
private final int rowSix = rowFive + oneRowHeight + sepHeight; | |
private final int rowSeven = rowSix + oneRowHeight + sepHeight; | |
private final int buttonRow = rowSeven + oneRowHeight + sepHeight + sepHeight; | |
private final int dialogHeight = buttonRow + twoRowHeight + twoRowHeight; | |
private final int lastButtonXLoc = dialogWidth - buttonWidth - sepWidth; | |
private final int next2LastButtonLoc = lastButtonXLoc - buttonWidth - sepWidth; | |
private final int firstButtonLoc = next2LastButtonLoc - buttonWidth - sepWidth; | |
private final int labelColumn = 12; | |
private final int fieldColumn = 168; | |
private final int labelWidth = 155; | |
private final int fieldWidth = 320; | |
private static final long serialVersionUID = 1L; | |
private JPanel jContentPane = null; | |
// private JPanel jPanelContentSouth = null; | |
// private JPanel jPanelContentNorth = null; | |
// private JPanel jPanelContentWest = null; | |
// private JPanel jPanelContentEast = null; | |
private JTabbedPane jTabbedPane = null; | |
private JPanel jPanelUserDef = null; | |
private JPanel jPanelUserDefNorth = null; | |
private JPanel jPanelUserDefCenter = null; | |
private JTextField jTextFieldAntTaskFile = null; | |
private JLabel jLabelAntTaskId = null; | |
private JTextField jTextFieldAntTaskId = null; | |
private JButton jButtonAntTaskAdd = null; | |
private JButton jButtonAntTaskDel = null; | |
private JTextField jTextFieldAntCmdOpts = null; | |
private JScrollPane jScrollPaneAntTasks = null; | |
private JTable jTableAntTasks = null; | |
private DefaultTableModel ffsTableModel = null; | |
private DefaultTableModel sectionsTableModel = null; | |
private DefaultTableModel sectionTableModel = null; | |
private DefaultTableModel subsectionsTableModel = null; | |
private DefaultTableModel antTaskTableModel = null; | |
private DefaultTableModel ffsAttributesTableModel = null; | |
private DefaultTableModel optionsTableModel = null; | |
private JPanel jPanelFfsTab = null; | |
private JPanel jPanelFfsTabCenter = null; | |
private JPanel jPanelFfsTabCenterN = null; | |
private JPanel jPanelFfsTabCenterS = null; | |
private JButton jButtonFfsAdd = null; | |
private JButton jButtonFfsDel = null; | |
private JScrollPane jScrollPaneFfsAttribs = null; | |
private JTable jTableFfsAttribs = null; | |
private JPanel jPanelOptionsTab = null; | |
private JLabel jLabelOptionContents = null; | |
private JTextField jTextFieldOptionContents = null; | |
private JLabel jLabelToolChainFamily = null; | |
private JLabel jLabelSupArch = null; | |
private JLabel jLabelToolCmd = null; | |
private JTextField jTextFieldToolCmd = null; | |
private JScrollPane jScrollPaneOptions = null; | |
private JTable jTableOptions = null; | |
private JButton jButtonOptionsAdd = null; | |
private JButton jButtonOptionsDel = null; | |
private JButton jButtonFfsAttribNew = null; | |
private JButton jButtonFfsAttribRemove = null; | |
private FpdFileContents ffc = null; | |
private OpeningPlatformType docConsole = null; | |
private JPanel jArchitectureSelections = null; | |
private JCheckBox jCheckBoxIA32 = null; | |
private JCheckBox jCheckBoxIpf = null; | |
private JCheckBox jCheckBoxX64 = null; | |
private JCheckBox jCheckBoxEBC = null; | |
private JCheckBox jCheckBoxARM = null; | |
private JCheckBox jCheckBoxPPC = null; | |
private JLabel jLabelBuildTargets = null; | |
private JTextField jTextFieldBuildTargets = null; | |
private JTextField jTextFieldTagName = null; | |
private JLabel jLabelTagName = null; | |
private int selectedRow = -1; | |
private JLabel jLabelAntTaskFile = null; | |
private JLabel jLabelAntCmdOpts = null; | |
private JScrollPane jScrollPaneFfs = null; | |
private JTable jTableFfs = null; | |
private JLabel jLabelFfsSection = null; | |
private JScrollPane jScrollPaneFfsSection = null; | |
private JTable jTableFfsSection = null; | |
private JLabel jLabelFfsSubSections = null; | |
private JScrollPane jScrollPaneFfsSubSection = null; | |
private JTable jTableFfsSubSection = null; | |
private JLabel jLabelEncapType = null; | |
private JTextField jTextFieldEncapType = null; | |
private JPanel jPanelFfsAttribButtonGroup = null; | |
private JLabel jLabelFfsAttribs = null; | |
private JButton jButtonFfsSectionNew = null; | |
private JButton jButtonFfsSectionRemove = null; | |
private JButton jButtonFfsSubSectionNew = null; | |
private JButton jButtonFfsSubSectionRemove = null; | |
private JLabel jLabelFfsSections = null; | |
private JButton jButtonFfsSectionsNew = null; | |
private JButton jButtonFfsSectionsRemove = null; | |
private JScrollPane jScrollPaneFfsSections = null; | |
private JTable jTableFfsSections = null; | |
private JButton jButtonAntTaskFileBrowse = null; | |
private JTextField jTextFieldToolChainFamily = null; | |
private JSplitPane jSplitPaneFfsC = null; | |
private JPanel jPanelFfsCTop = null; | |
private JSplitPane jSplitPaneFfsCBottom = null; | |
private JPanel jPanelFfsCBottomTop = null; | |
private JPanel jPanelFfsCBottomBottom = null; | |
private JPanel jPanelSectionN = null; | |
private JPanel jPanelSectionsN = null; | |
private JPanel jPanelSubSectionN = null; | |
private JPanel jPanelOptionsContainer = null; | |
private JPanel jPanelUserDefCenterN = null; | |
private JPanel jPanelTableOptionsContainer = null; | |
private JLabel jLabelTableOptionsTitle = null; | |
private final int buildTargetWidth = 150; | |
private final int toolChainFamilyWidth = 150; | |
private final int supportArchWidth = 150; | |
private final int toolCmdCodeWidth = 200; | |
private final int tagNameWidth = 150; | |
private final int argWidth = 400; | |
private boolean ffsSelection = false; | |
private int selectedFfsTableRow = -1; | |
/** | |
* This method initializes jPanel | |
* | |
* @return javax.swing.JPanel | |
private JPanel getJPanelContentSouth() { | |
if (jPanelContentSouth == null) { | |
jPanelContentSouth = new JPanel(); | |
} | |
return jPanelContentSouth; | |
} | |
*/ | |
/** | |
* This method initializes jPanel1 | |
* | |
* @return javax.swing.JPanel | |
private JPanel getJPanelContentNorth() { | |
if (jPanelContentNorth == null) { | |
jPanelContentNorth = new JPanel(); | |
} | |
return jPanelContentNorth; | |
} | |
*/ | |
/** | |
* This method initializes jPanel2 | |
* | |
* @return javax.swing.JPanel | |
private JPanel getJPanelContentWest() { | |
if (jPanelContentWest == null) { | |
jPanelContentWest = new JPanel(); | |
} | |
return jPanelContentWest; | |
} | |
*/ | |
/** | |
* This method initializes jPanel3 | |
* | |
* @return javax.swing.JPanel | |
private JPanel getJPanelContentEast() { | |
if (jPanelContentEast == null) { | |
jPanelContentEast = new JPanel(); | |
} | |
return jPanelContentEast; | |
} | |
*/ | |
/** | |
* This method initializes jTabbedPane | |
* | |
* @return javax.swing.JTabbedPane | |
*/ | |
private JTabbedPane getJTabbedPane() { | |
if (jTabbedPane == null) { | |
jTabbedPane = new JTabbedPane(); | |
jTabbedPane.addTab("Flash Filesystem Options", null, getJPanelFfsTab(), null); | |
jTabbedPane.addTab("Customize Tool Chain Configurations", null, getJPanelOptionsTab(), null); | |
jTabbedPane.addTab("User Defined ANT Tasks", null, getJPanelUserDef(), null); | |
} | |
return jTabbedPane; | |
} | |
/** | |
* This method initializes this | |
* | |
* @return void | |
*/ | |
private void initialize() { | |
this.setSize(722, 577); | |
this.setTitle("Platform Build Options"); | |
this.setContentPane(getJContentPane()); | |
} | |
/** | |
* This method initializes jContentPane | |
* | |
* @return javax.swing.JPanel | |
*/ | |
private JPanel getJContentPane() { | |
if (jContentPane == null) { | |
jContentPane = new JPanel(); | |
jContentPane.setLayout(new BorderLayout()); | |
// jContentPane.add(getJPanelContentSouth(), java.awt.BorderLayout.SOUTH); | |
// jContentPane.add(getJPanelContentNorth(), java.awt.BorderLayout.NORTH); | |
// jContentPane.add(getJPanelContentWest(), java.awt.BorderLayout.WEST); | |
// jContentPane.add(getJPanelContentEast(), java.awt.BorderLayout.EAST); | |
jContentPane.add(getJTabbedPane(), java.awt.BorderLayout.CENTER); | |
} | |
return jContentPane; | |
} | |
/** | |
* This method initializes jPanelTableOptionsContainer | |
* | |
* @return javax.swing.JPanel | |
*/ | |
private JPanel getJPanelTableOptionsContainer() { | |
if (jPanelTableOptionsContainer == null) { | |
jLabelTableOptionsTitle = new JLabel(); | |
jLabelTableOptionsTitle.setText(" Current Argument Lines"); | |
jPanelTableOptionsContainer = new JPanel(); | |
jPanelTableOptionsContainer.setLayout(new BorderLayout()); | |
jPanelTableOptionsContainer.add(jLabelTableOptionsTitle, java.awt.BorderLayout.NORTH); | |
jPanelTableOptionsContainer.add(getJScrollPaneOptions(), java.awt.BorderLayout.CENTER); | |
} | |
return jPanelTableOptionsContainer; | |
} | |
/** | |
* @param args | |
*/ | |
public static void main(String[] args) { | |
// TODO Auto-generated method stub | |
new FpdBuildOptions().setVisible(true); | |
} | |
/** | |
* This is the default constructor | |
*/ | |
public FpdBuildOptions() { | |
super(); | |
initialize(); | |
this.setVisible(true); | |
} | |
public FpdBuildOptions(PlatformSurfaceAreaDocument.PlatformSurfaceArea fpd) { | |
this(); | |
ffc = new FpdFileContents(fpd); | |
init(ffc); | |
} | |
public FpdBuildOptions(OpeningPlatformType opt) { | |
this(opt.getXmlFpd()); | |
docConsole = opt; | |
} | |
private void init(FpdFileContents ffc) { | |
initOptionTable(); | |
initAntTaskTable(); | |
initFfsTable(); | |
this.addInternalFrameListener(new InternalFrameAdapter() { | |
public void internalFrameDeactivated(InternalFrameEvent e) { | |
if (jTableAntTasks.isEditing()) { | |
jTableAntTasks.getCellEditor().stopCellEditing(); | |
} | |
if (jTableOptions.isEditing()) { | |
jTableOptions.getCellEditor().stopCellEditing(); | |
} | |
stopEditingInTables (); | |
} | |
}); | |
} | |
private void stopEditingInTables () { | |
if (jTableFfs.isEditing()) { | |
jTableFfs.getCellEditor().stopCellEditing(); | |
} | |
if (jTableFfsSection.isEditing()) { | |
jTableFfsSection.getCellEditor().stopCellEditing(); | |
} | |
if (jTableFfsSections.isEditing()) { | |
jTableFfsSections.getCellEditor().stopCellEditing(); | |
} | |
if (jTableFfsSubSection.isEditing()) { | |
jTableFfsSubSection.getCellEditor().stopCellEditing(); | |
} | |
if (jTableFfsAttribs.isEditing()) { | |
jTableFfsAttribs.getCellEditor().stopCellEditing(); | |
} | |
} | |
/** | |
* This method initializes jPanel13 | |
* | |
* @return javax.swing.JPanel | |
*/ | |
private JPanel getJPanelFfsTab() { | |
if (jPanelFfsTab == null) { | |
jPanelFfsTab = new JPanel(); | |
jPanelFfsTab.setLayout(new BorderLayout()); | |
jPanelFfsTab.add(getJPanelFfsTabCenter(), java.awt.BorderLayout.CENTER); | |
jPanelFfsTab.add(getJScrollPaneFfs(), java.awt.BorderLayout.WEST); | |
} | |
return jPanelFfsTab; | |
} | |
/** | |
* This method initializes jPanel18 | |
* | |
* @return javax.swing.JPanel | |
*/ | |
private JPanel getJPanelFfsTabCenter() { | |
if (jPanelFfsTabCenter == null) { | |
jPanelFfsTabCenter = new JPanel(); | |
jPanelFfsTabCenter.setLayout(new BorderLayout()); | |
jPanelFfsTabCenter.add(getJPanelFfsTabCenterN(), java.awt.BorderLayout.NORTH); | |
jPanelFfsTabCenter.add(getJPanelFfsTabCenterS(), java.awt.BorderLayout.SOUTH); | |
jPanelFfsTabCenter.add(getJSplitPaneFfsC(), java.awt.BorderLayout.CENTER); | |
} | |
return jPanelFfsTabCenter; | |
} | |
/** | |
* This method initializes jPanel15 | |
* | |
* @return javax.swing.JPanel | |
*/ | |
private JPanel getJPanelFfsTabCenterN() { | |
if (jPanelFfsTabCenterN == null) { | |
jLabelEncapType = new JLabel(); | |
jLabelEncapType.setText("Encapsulation Type"); | |
FlowLayout flowLayout5 = new FlowLayout(); | |
flowLayout5.setAlignment(java.awt.FlowLayout.RIGHT); | |
jPanelFfsTabCenterN = new JPanel(); | |
jPanelFfsTabCenterN.setLayout(flowLayout5); | |
jPanelFfsTabCenterN.add(jLabelEncapType, null); | |
jPanelFfsTabCenterN.add(getJTextFieldEncapType(), null); | |
jPanelFfsTabCenterN.add(getJButtonFfsAdd(), null); | |
jPanelFfsTabCenterN.add(getJButtonFfsDel(), null); | |
} | |
return jPanelFfsTabCenterN; | |
} | |
/** | |
* This method initializes jPanel16 | |
* | |
* @return javax.swing.JPanel | |
*/ | |
private JPanel getJPanelFfsTabCenterS() { | |
if (jPanelFfsTabCenterS == null) { | |
jLabelFfsAttribs = new JLabel(); | |
jLabelFfsAttribs.setText("Attributes"); | |
jPanelFfsTabCenterS = new JPanel(); | |
jPanelFfsTabCenterS.setPreferredSize(new java.awt.Dimension(491, 130)); | |
jPanelFfsTabCenterS.setLayout(new BorderLayout()); | |
jPanelFfsTabCenterS.add(jLabelFfsAttribs, java.awt.BorderLayout.WEST); | |
jPanelFfsTabCenterS.add(getJScrollPaneFfsAttribs(), java.awt.BorderLayout.CENTER); | |
jPanelFfsTabCenterS.add(getJPanelFfsAttribButtonGroup(), java.awt.BorderLayout.EAST); | |
} | |
return jPanelFfsTabCenterS; | |
} | |
/** | |
* This method initializes jTextField6 | |
* | |
* @return javax.swing.JTextField | |
*/ | |
/** | |
* This method initializes jButton8 | |
* | |
* @return javax.swing.JButton | |
*/ | |
private JButton getJButtonFfsAdd() { | |
if (jButtonFfsAdd == null) { | |
jButtonFfsAdd = new JButton(); | |
jButtonFfsAdd.setPreferredSize(new java.awt.Dimension(70, 20)); | |
jButtonFfsAdd.setText("New"); | |
jButtonFfsAdd.addActionListener(new AbstractAction() { | |
/** | |
* | |
*/ | |
private static final long serialVersionUID = -2923720717273384221L; | |
public void actionPerformed(java.awt.event.ActionEvent e) { | |
String[] row = { "" }; | |
ffsTableModel.addRow(row); | |
docConsole.setSaved(false); | |
ffc.genBuildOptionsFfs("", ""); | |
jTableFfs.changeSelection(ffsTableModel.getRowCount()-1, 0, false, false); | |
} | |
}); | |
} | |
return jButtonFfsAdd; | |
} | |
/** | |
* This method initializes jButton9 | |
* | |
* @return javax.swing.JButton | |
*/ | |
private JButton getJButtonFfsDel() { | |
if (jButtonFfsDel == null) { | |
jButtonFfsDel = new JButton(); | |
jButtonFfsDel.setPreferredSize(new java.awt.Dimension(70, 20)); | |
jButtonFfsDel.setText("Delete"); | |
jButtonFfsDel.addActionListener(new AbstractAction() { | |
/** | |
* | |
*/ | |
private static final long serialVersionUID = -4002678939178194476L; | |
public void actionPerformed(ActionEvent arg0) { | |
if (jTableFfs.getSelectedRow() < 0) { | |
return; | |
} | |
stopEditingInTables(); | |
docConsole.setSaved(false); | |
ffc.removeBuildOptionsFfs(jTableFfs.getSelectedRow()); | |
ffsTableModel.removeRow(jTableFfs.getSelectedRow()); | |
sectionTableModel.setRowCount(0); | |
sectionsTableModel.setRowCount(0); | |
subsectionsTableModel.setRowCount(0); | |
ffsAttributesTableModel.setRowCount(0); | |
} | |
}); | |
} | |
return jButtonFfsDel; | |
} | |
/** | |
* This method initializes jScrollPane5 | |
* | |
* @return javax.swing.JScrollPane | |
*/ | |
private JScrollPane getJScrollPaneFfsAttribs() { | |
if (jScrollPaneFfsAttribs == null) { | |
jScrollPaneFfsAttribs = new JScrollPane(); | |
// jScrollPaneFfsAttribs.setPreferredSize(new java.awt.Dimension(350, 100)); | |
jScrollPaneFfsAttribs.setViewportView(getJTableFfsAttribs()); | |
} | |
return jScrollPaneFfsAttribs; | |
} | |
/** | |
* This method initializes jTable4 | |
* | |
* @return javax.swing.JTable | |
*/ | |
private JTable getJTableFfsAttribs() { | |
if (jTableFfsAttribs == null) { | |
ffsAttributesTableModel = new DefaultTableModel(); | |
jTableFfsAttribs = new JTable(ffsAttributesTableModel); | |
// jTableFfsAttribs.setPreferredSize(new java.awt.Dimension(400, 80)); | |
jTableFfsAttribs.setRowHeight(20); | |
ffsAttributesTableModel.addColumn("Name"); | |
ffsAttributesTableModel.addColumn("Value"); | |
jTableFfsAttribs.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); | |
jTableFfsAttribs.getModel().addTableModelListener(new TableModelListener() { | |
public void tableChanged(TableModelEvent arg0) { | |
// TODO Auto-generated method stub | |
int row = arg0.getFirstRow(); | |
TableModel m = (TableModel) arg0.getSource(); | |
if (arg0.getType() == TableModelEvent.UPDATE) { | |
//ToDo Data Validition check. | |
String name = m.getValueAt(row, 0) + ""; | |
String value = m.getValueAt(row, 1) + ""; | |
if (name.length() == 0) { | |
return; | |
} | |
if (value.length() == 0) { | |
return; | |
} | |
docConsole.setSaved(false); | |
ffc.updateBuildOptionsFfsAttribute(jTableFfs.getSelectedRow(), row, name, value); | |
} | |
} | |
}); | |
} | |
return jTableFfsAttribs; | |
} | |
private void initFfsTable() { | |
int ffsCount = ffc.getBuildOptionsFfsCount(); | |
if (ffsCount < 0) { | |
return; | |
} | |
String[][] saa = new String[ffsCount][1]; | |
ffc.getBuildOptionsFfsKey(saa); | |
for (int i = 0; i < saa.length; ++i) { | |
ffsTableModel.addRow(saa[i]); | |
} | |
jTableFfs.changeSelection(0, 0, false, false); | |
} | |
/** | |
* This method initializes jButton17 | |
* | |
* @return javax.swing.JButton | |
*/ | |
private JButton getJButtonFfsAttribNew() { | |
if (jButtonFfsAttribNew == null) { | |
jButtonFfsAttribNew = new JButton(); | |
jButtonFfsAttribNew.setPreferredSize(new java.awt.Dimension(80, 20)); | |
jButtonFfsAttribNew.setText("New"); | |
jButtonFfsAttribNew.addActionListener(new AbstractAction() { | |
/** | |
* | |
*/ | |
private static final long serialVersionUID = 1L; | |
public void actionPerformed(ActionEvent arg0) { | |
if (jTableFfs.getSelectedRow() < 0) { | |
return; | |
} | |
Object[] o = { "", "" }; | |
ffsAttributesTableModel.addRow(o); | |
docConsole.setSaved(false); | |
ffc.genBuildOptionsFfsAttribute(jTableFfs.getSelectedRow(), "", ""); | |
} | |
}); | |
} | |
return jButtonFfsAttribNew; | |
} | |
/** | |
* This method initializes jButton18 | |
* | |
* @return javax.swing.JButton | |
*/ | |
private JButton getJButtonFfsAttribRemove() { | |
if (jButtonFfsAttribRemove == null) { | |
jButtonFfsAttribRemove = new JButton(); | |
jButtonFfsAttribRemove.setPreferredSize(new java.awt.Dimension(80, 20)); | |
jButtonFfsAttribRemove.setText("Remove"); | |
jButtonFfsAttribRemove.addActionListener(new AbstractAction() { | |
/** | |
* | |
*/ | |
private static final long serialVersionUID = 1L; | |
public void actionPerformed(ActionEvent arg0) { | |
if (jTableFfs.getSelectedRow() < 0) { | |
return; | |
} | |
stopEditingInTables(); | |
if (jTableFfsAttribs.getSelectedRow() >= 0) { | |
docConsole.setSaved(false); | |
ffsAttributesTableModel.removeRow(jTableFfsAttribs.getSelectedRow()); | |
ffc.removeBuildOptionsFfsAttribute(jTableFfs.getSelectedRow(), | |
jTableFfsAttribs.getSelectedRow()); | |
} | |
} | |
}); | |
} | |
return jButtonFfsAttribRemove; | |
} | |
/** | |
* This method initializes jScrollPane | |
* | |
* @return javax.swing.JScrollPane | |
*/ | |
private JScrollPane getJScrollPaneFfs() { | |
if (jScrollPaneFfs == null) { | |
jScrollPaneFfs = new JScrollPane(); | |
jScrollPaneFfs.setPreferredSize(new java.awt.Dimension(200,419)); | |
jScrollPaneFfs.setViewportView(getJTableFfs()); | |
} | |
return jScrollPaneFfs; | |
} | |
/** | |
* This method initializes jTable | |
* | |
* @return javax.swing.JTable | |
*/ | |
private JTable getJTableFfs() { | |
if (jTableFfs == null) { | |
ffsTableModel = new DefaultTableModel(); | |
ffsTableModel.addColumn("FFS Type"); | |
jTableFfs = new JTable(ffsTableModel); | |
jTableFfs.setShowGrid(false); | |
jTableFfs.setRowHeight(20); | |
jTableFfs.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); | |
jTableFfs.getSelectionModel().addListSelectionListener(new ListSelectionListener() { | |
public void valueChanged(ListSelectionEvent e) { | |
if (e.getValueIsAdjusting()) { | |
return; | |
} | |
ListSelectionModel lsm = (ListSelectionModel) e.getSource(); | |
if (lsm.isSelectionEmpty()) { | |
return; | |
} else { | |
int row = lsm.getMinSelectionIndex(); | |
sectionTableModel.setRowCount(0); | |
sectionsTableModel.setRowCount(0); | |
subsectionsTableModel.setRowCount(0); | |
ffsAttributesTableModel.setRowCount(0); | |
String[] sArray = { "", "" }; | |
LinkedHashMap<String, String> lhm = new LinkedHashMap<String, String>(); | |
ArrayList<String> alSections = new ArrayList<String>(); | |
ArrayList<String> alSection = new ArrayList<String>(); | |
ffc.getBuildOptionsFfs(row, sArray, lhm, alSections, alSection); | |
ffsSelection = true; | |
jTextFieldEncapType.setText(sArray[1]); | |
ffsSelection = false; | |
for (int i = 0; i < alSection.size(); ++i) { | |
String[] sectionRow = { alSection.get(i) }; | |
sectionTableModel.addRow(sectionRow); | |
} | |
for (int j = 0; j < alSections.size(); ++j) { | |
String[] sectionsRow = { alSections.get(j) }; | |
sectionsTableModel.addRow(sectionsRow); | |
} | |
if (lhm.size() <= 0) { | |
return; | |
} | |
Set<String> keySet = lhm.keySet(); | |
Iterator<String> is = keySet.iterator(); | |
while (is.hasNext()) { | |
String key = is.next(); | |
String[] attribRow = { key, lhm.get(key) }; | |
ffsAttributesTableModel.addRow(attribRow); | |
} | |
selectedFfsTableRow = row; | |
} | |
} | |
}); | |
jTableFfs.getModel().addTableModelListener(new TableModelListener() { | |
public void tableChanged(TableModelEvent arg0) { | |
// TODO Auto-generated method stub | |
int row = arg0.getFirstRow(); | |
TableModel m = (TableModel) arg0.getSource(); | |
if (arg0.getType() == TableModelEvent.UPDATE) { | |
//ToDo Data Validition check. | |
String id = m.getValueAt(row, 0) + ""; | |
if (id.length() == 0) { | |
return; | |
} | |
docConsole.setSaved(false); | |
ffc.updateBuildOptionsFfsKey(row, id); | |
} | |
} | |
}); | |
} | |
return jTableFfs; | |
} | |
/** | |
* This method initializes jScrollPane1 | |
* | |
* @return javax.swing.JScrollPane | |
*/ | |
private JScrollPane getJScrollPaneFfsSection() { | |
if (jScrollPaneFfsSection == null) { | |
jScrollPaneFfsSection = new JScrollPane(); | |
// jScrollPaneFfsSection.setPreferredSize(new java.awt.Dimension(500, 80)); | |
jScrollPaneFfsSection.setViewportView(getJTableFfsSection()); | |
} | |
return jScrollPaneFfsSection; | |
} | |
/** | |
* This method initializes jTable1 | |
* | |
* @return javax.swing.JTable | |
*/ | |
private JTable getJTableFfsSection() { | |
if (jTableFfsSection == null) { | |
sectionTableModel = new DefaultTableModel(); | |
sectionTableModel.addColumn("SectionType"); | |
jTableFfsSection = new JTable(sectionTableModel); | |
jTableFfsSection.setRowHeight(20); | |
JComboBox cb = new JComboBox(); | |
cb.addItem("EFI_SECTION_FREEFORM_SUBTYPE_GUID"); | |
cb.addItem("EFI_SECTION_VERSION"); | |
cb.addItem("EFI_SECTION_USER_INTERFACE"); | |
cb.addItem("EFI_SECTION_DXE_DEPEX"); | |
cb.addItem("EFI_SECTION_PEI_DEPEX"); | |
cb.addItem("EFI_SECTION_PE32"); | |
cb.addItem("EFI_SECTION_PIC"); | |
cb.addItem("EFI_SECTION_TE"); | |
cb.addItem("EFI_SECTION_RAW"); | |
cb.addItem("EFI_SECTION_COMPRESSION"); | |
cb.addItem("EFI_SECTION_GUID_DEFINED"); | |
cb.addItem("EFI_SECTION_COMPATIBILITY16"); | |
cb.addItem("EFI_SECTION_FIRMWARE_VOLUME_IMAGE"); | |
jTableFfsSection.getColumnModel().getColumn(0).setCellEditor(new DefaultCellEditor(cb)); | |
jTableFfsSection.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); | |
jTableFfsSection.getModel().addTableModelListener(new TableModelListener() { | |
public void tableChanged(TableModelEvent arg0) { | |
// TODO Auto-generated method stub | |
if (jTableFfs.getSelectedRow() < 0) { | |
return; | |
} | |
int row = arg0.getFirstRow(); | |
TableModel m = (TableModel) arg0.getSource(); | |
if (arg0.getType() == TableModelEvent.UPDATE) { | |
//ToDo Data Validition check. | |
String type = m.getValueAt(row, 0) + ""; | |
docConsole.setSaved(false); | |
ffc.updateBuildOptionsFfsSectionsSection(jTableFfs.getSelectedRow(), row, type); | |
} | |
} | |
}); | |
} | |
return jTableFfsSection; | |
} | |
/** | |
* This method initializes jScrollPane3 | |
* | |
* @return javax.swing.JScrollPane | |
*/ | |
private JScrollPane getJScrollPaneFfsSubSection() { | |
if (jScrollPaneFfsSubSection == null) { | |
jScrollPaneFfsSubSection = new JScrollPane(); | |
// jScrollPaneFfsSubSection.setPreferredSize(new java.awt.Dimension(500, 90)); | |
jScrollPaneFfsSubSection.setViewportView(getJTableFfsSubSection()); | |
} | |
return jScrollPaneFfsSubSection; | |
} | |
/** | |
* This method initializes jTable3 | |
* | |
* @return javax.swing.JTable | |
*/ | |
private JTable getJTableFfsSubSection() { | |
if (jTableFfsSubSection == null) { | |
subsectionsTableModel = new DefaultTableModel(); | |
subsectionsTableModel.addColumn("SectionType"); | |
jTableFfsSubSection = new JTable(subsectionsTableModel); | |
jTableFfsSubSection.setRowHeight(20); | |
JComboBox cb = new JComboBox(); | |
cb.addItem("EFI_SECTION_FREEFORM_SUBTYPE_GUID"); | |
cb.addItem("EFI_SECTION_VERSION"); | |
cb.addItem("EFI_SECTION_USER_INTERFACE"); | |
cb.addItem("EFI_SECTION_DXE_DEPEX"); | |
cb.addItem("EFI_SECTION_PEI_DEPEX"); | |
cb.addItem("EFI_SECTION_PE32"); | |
cb.addItem("EFI_SECTION_PIC"); | |
cb.addItem("EFI_SECTION_TE"); | |
cb.addItem("EFI_SECTION_RAW"); | |
cb.addItem("EFI_SECTION_COMPRESSION"); | |
cb.addItem("EFI_SECTION_GUID_DEFINED"); | |
cb.addItem("EFI_SECTION_COMPATIBILITY16"); | |
cb.addItem("EFI_SECTION_FIRMWARE_VOLUME_IMAGE"); | |
jTableFfsSubSection.getColumnModel().getColumn(0).setCellEditor(new DefaultCellEditor(cb)); | |
jTableFfsSubSection.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); | |
jTableFfsSubSection.getModel().addTableModelListener(new TableModelListener() { | |
public void tableChanged(TableModelEvent arg0) { | |
// TODO Auto-generated method stub | |
if (jTableFfs.getSelectedRow() < 0 || jTableFfsSections.getSelectedRow() < 0) { | |
return; | |
} | |
int row = arg0.getFirstRow(); | |
TableModel m = (TableModel) arg0.getSource(); | |
if (arg0.getType() == TableModelEvent.UPDATE) { | |
//ToDo Data Validition check. | |
String type = m.getValueAt(row, 0) + ""; | |
docConsole.setSaved(false); | |
ffc.updateBuildOptionsFfsSectionsSectionsSection(jTableFfs.getSelectedRow(), | |
jTableFfsSections.getSelectedRow(), row, type); | |
} | |
} | |
}); | |
} | |
return jTableFfsSubSection; | |
} | |
/** | |
* This method initializes jTextField | |
* | |
* @return javax.swing.JTextField | |
*/ | |
private JTextField getJTextFieldEncapType() { | |
if (jTextFieldEncapType == null) { | |
jTextFieldEncapType = new JTextField(); | |
jTextFieldEncapType.setPreferredSize(new java.awt.Dimension(200,20)); | |
jTextFieldEncapType.getDocument().addDocumentListener(new DocumentListener() { | |
public void insertUpdate(DocumentEvent arg0) { | |
if (ffsSelection) { | |
// ffsSelection = false; | |
return; | |
} | |
if (docConsole != null) { | |
docConsole.setSaved(false); | |
} | |
} | |
public void removeUpdate(DocumentEvent arg0) { | |
if (ffsSelection) { | |
// ffsSelection = false; | |
return; | |
} | |
if (docConsole != null) { | |
docConsole.setSaved(false); | |
} | |
} | |
public void changedUpdate(DocumentEvent arg0) { | |
// TODO Auto-generated method stub | |
} | |
}); | |
jTextFieldEncapType.addFocusListener(new java.awt.event.FocusAdapter() { | |
public void focusLost(java.awt.event.FocusEvent e) { | |
if (selectedFfsTableRow < 0) { | |
return; | |
} | |
ffc.updateBuildOptionsFfsSectionsType(selectedFfsTableRow, jTextFieldEncapType.getText()); | |
} | |
}); | |
} | |
return jTextFieldEncapType; | |
} | |
/** | |
* This method initializes jPanel4 | |
* | |
* @return javax.swing.JPanel | |
*/ | |
private JPanel getJPanelFfsAttribButtonGroup() { | |
if (jPanelFfsAttribButtonGroup == null) { | |
jPanelFfsAttribButtonGroup = new JPanel(); | |
jPanelFfsAttribButtonGroup.setPreferredSize(new java.awt.Dimension(100, 100)); | |
jPanelFfsAttribButtonGroup.add(getJButtonFfsAttribNew(), null); | |
jPanelFfsAttribButtonGroup.add(getJButtonFfsAttribRemove(), null); | |
} | |
return jPanelFfsAttribButtonGroup; | |
} | |
/** | |
* This method initializes jButton | |
* | |
* @return javax.swing.JButton | |
*/ | |
private JButton getJButtonFfsSectionNew() { | |
if (jButtonFfsSectionNew == null) { | |
jButtonFfsSectionNew = new JButton(); | |
jButtonFfsSectionNew.setPreferredSize(new java.awt.Dimension(80, 20)); | |
jButtonFfsSectionNew.setText("New"); | |
jButtonFfsSectionNew.addActionListener(new java.awt.event.ActionListener() { | |
public void actionPerformed(java.awt.event.ActionEvent e) { | |
if (jTableFfs.getSelectedRow() < 0) { | |
return; | |
} | |
docConsole.setSaved(false); | |
String[] row = { "EFI_SECTION_RAW" }; | |
sectionTableModel.addRow(row); | |
ffc.genBuildOptionsFfsSectionsSection(jTableFfs.getSelectedRow(), row[0]); | |
} | |
}); | |
} | |
return jButtonFfsSectionNew; | |
} | |
/** | |
* This method initializes jButton1 | |
* | |
* @return javax.swing.JButton | |
*/ | |
private JButton getJButtonFfsSectionRemove() { | |
if (jButtonFfsSectionRemove == null) { | |
jButtonFfsSectionRemove = new JButton(); | |
jButtonFfsSectionRemove.setPreferredSize(new java.awt.Dimension(80, 20)); | |
jButtonFfsSectionRemove.setText("Remove"); | |
jButtonFfsSectionRemove.addActionListener(new java.awt.event.ActionListener() { | |
public void actionPerformed(java.awt.event.ActionEvent e) { | |
if (jTableFfs.getSelectedRow() < 0 || jTableFfsSection.getSelectedRow() < 0) { | |
return; | |
} | |
stopEditingInTables(); | |
docConsole.setSaved(false); | |
sectionTableModel.removeRow(jTableFfsSection.getSelectedRow()); | |
ffc.removeBuildOptionsFfsSectionsSection(jTableFfs.getSelectedRow(), | |
jTableFfsSection.getSelectedRow()); | |
} | |
}); | |
} | |
return jButtonFfsSectionRemove; | |
} | |
/** | |
* This method initializes jButton2 | |
* | |
* @return javax.swing.JButton | |
*/ | |
private JButton getJButtonFfsSubSectionNew() { | |
if (jButtonFfsSubSectionNew == null) { | |
jButtonFfsSubSectionNew = new JButton(); | |
jButtonFfsSubSectionNew.setPreferredSize(new java.awt.Dimension(80, 20)); | |
jButtonFfsSubSectionNew.setText("New"); | |
jButtonFfsSubSectionNew.addActionListener(new java.awt.event.ActionListener() { | |
public void actionPerformed(java.awt.event.ActionEvent e) { | |
if (jTableFfs.getSelectedRow() < 0 || jTableFfsSections.getSelectedRow() < 0) { | |
return; | |
} | |
docConsole.setSaved(false); | |
String[] row = { "EFI_SECTION_RAW" }; | |
subsectionsTableModel.addRow(row); | |
ffc.genBuildOptionsFfsSectionsSectionsSection(jTableFfs.getSelectedRow(), | |
jTableFfsSections.getSelectedRow(), row[0]); | |
} | |
}); | |
} | |
return jButtonFfsSubSectionNew; | |
} | |
/** | |
* This method initializes jButton3 | |
* | |
* @return javax.swing.JButton | |
*/ | |
private JButton getJButtonFfsSubSectionRemove() { | |
if (jButtonFfsSubSectionRemove == null) { | |
jButtonFfsSubSectionRemove = new JButton(); | |
jButtonFfsSubSectionRemove.setPreferredSize(new java.awt.Dimension(80, 20)); | |
jButtonFfsSubSectionRemove.setText("Remove"); | |
jButtonFfsSubSectionRemove.addActionListener(new java.awt.event.ActionListener() { | |
public void actionPerformed(java.awt.event.ActionEvent e) { | |
int selectedFfsRow = jTableFfs.getSelectedRow(); | |
int selectedSectionsRow = jTableFfsSections.getSelectedRow(); | |
int selectedSubSectionRow = jTableFfsSubSection.getSelectedRow(); | |
if (selectedFfsRow < 0 || selectedSectionsRow < 0 | |
|| selectedSubSectionRow < 0) { | |
return; | |
} | |
stopEditingInTables(); | |
docConsole.setSaved(false); | |
subsectionsTableModel.removeRow(selectedSubSectionRow); | |
ffc.removeBuildOptionsFfsSectionsSectionsSection(selectedFfsRow, | |
selectedSectionsRow, | |
selectedSubSectionRow); | |
if (subsectionsTableModel.getRowCount() == 0) { | |
sectionsTableModel.removeRow(selectedSectionsRow); | |
} | |
} | |
}); | |
} | |
return jButtonFfsSubSectionRemove; | |
} | |
/** | |
* This method initializes jButton6 | |
* | |
* @return javax.swing.JButton | |
*/ | |
private JButton getJButtonFfsSectionsNew() { | |
if (jButtonFfsSectionsNew == null) { | |
jButtonFfsSectionsNew = new JButton(); | |
jButtonFfsSectionsNew.setPreferredSize(new java.awt.Dimension(80, 20)); | |
jButtonFfsSectionsNew.setText("New"); | |
jButtonFfsSectionsNew.addActionListener(new java.awt.event.ActionListener() { | |
public void actionPerformed(java.awt.event.ActionEvent e) { | |
if (jTableFfs.getSelectedRow() < 0) { | |
return; | |
} | |
docConsole.setSaved(false); | |
String[] row = { "Compress" }; | |
sectionsTableModel.addRow(row); | |
ffc.genBuildOptionsFfsSectionsSections(jTableFfs.getSelectedRow(), ""); | |
JOptionPane.showMessageDialog(FpdBuildOptions.this, "Add Default Section Type EFI_SECTION_PE32 into the New Sections Entry."); | |
jTableFfsSections.changeSelection(sectionsTableModel.getRowCount()-1, 0, false, false); | |
} | |
}); | |
} | |
return jButtonFfsSectionsNew; | |
} | |
/** | |
* This method initializes jButton7 | |
* | |
* @return javax.swing.JButton | |
*/ | |
private JButton getJButtonFfsSectionsRemove() { | |
if (jButtonFfsSectionsRemove == null) { | |
jButtonFfsSectionsRemove = new JButton(); | |
jButtonFfsSectionsRemove.setPreferredSize(new java.awt.Dimension(80, 20)); | |
jButtonFfsSectionsRemove.setText("Remove"); | |
jButtonFfsSectionsRemove.addActionListener(new java.awt.event.ActionListener() { | |
public void actionPerformed(java.awt.event.ActionEvent e) { | |
if (jTableFfs.getSelectedRow() < 0 || jTableFfsSections.getSelectedRow() < 0) { | |
return; | |
} | |
stopEditingInTables(); | |
docConsole.setSaved(false); | |
sectionsTableModel.removeRow(jTableFfsSections.getSelectedRow()); | |
ffc.removeBuildOptionsFfsSectionsSections(jTableFfs.getSelectedRow(), | |
jTableFfsSections.getSelectedRow()); | |
subsectionsTableModel.setRowCount(0); | |
} | |
}); | |
} | |
return jButtonFfsSectionsRemove; | |
} | |
private JScrollPane getJScrollPaneFfsSections() { | |
if (jScrollPaneFfsSections == null) { | |
jScrollPaneFfsSections = new JScrollPane(); | |
// jScrollPaneFfsSections.setPreferredSize(new java.awt.Dimension(500, 80)); | |
jScrollPaneFfsSections.setViewportView(getJTableFfsSections()); | |
} | |
return jScrollPaneFfsSections; | |
} | |
/** | |
* This method initializes jTable6 | |
* | |
* @return javax.swing.JTable | |
*/ | |
private JTable getJTableFfsSections() { | |
if (jTableFfsSections == null) { | |
sectionsTableModel = new DefaultTableModel(); | |
sectionsTableModel.addColumn("EncapsulationType"); | |
jTableFfsSections = new JTable(sectionsTableModel); | |
jTableFfsSections.setRowHeight(20); | |
jTableFfsSections.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); | |
jTableFfsSections.getSelectionModel().addListSelectionListener(new ListSelectionListener() { | |
public void valueChanged(ListSelectionEvent e) { | |
if (e.getValueIsAdjusting()) { | |
return; | |
} | |
ListSelectionModel lsm = (ListSelectionModel) e.getSource(); | |
if (lsm.isSelectionEmpty()) { | |
return; | |
} else { | |
int sectionsRow = lsm.getMinSelectionIndex(); | |
if (jTableFfs.getSelectedRow() < 0) { | |
return; | |
} | |
subsectionsTableModel.setRowCount(0); | |
ArrayList<String> al = new ArrayList<String>(); | |
ffc.getBuildOptionsFfsSectionsSectionsSection(jTableFfs.getSelectedRow(), sectionsRow, al); | |
for (int i = 0; i < al.size(); ++i) { | |
String[] subsectionRow = { al.get(i) }; | |
subsectionsTableModel.addRow(subsectionRow); | |
} | |
} | |
} | |
}); | |
jTableFfsSections.getModel().addTableModelListener(new TableModelListener() { | |
public void tableChanged(TableModelEvent arg0) { | |
// TODO Auto-generated method stub | |
int row = arg0.getFirstRow(); | |
TableModel m = (TableModel) arg0.getSource(); | |
if (arg0.getType() == TableModelEvent.UPDATE) { | |
//ToDo Data Validition check. | |
String encapType = m.getValueAt(row, 0) + ""; | |
docConsole.setSaved(false); | |
ffc.updateBuildOptionsFfsSectionsSections(jTableFfs.getSelectedRow(), row, encapType); | |
} | |
} | |
}); | |
} | |
return jTableFfsSections; | |
} | |
/** | |
* This method initializes jSplitPaneFfsC | |
* | |
* @return javax.swing.JSplitPane | |
*/ | |
private JSplitPane getJSplitPaneFfsC() { | |
if (jSplitPaneFfsC == null) { | |
jSplitPaneFfsC = new JSplitPane(); | |
jSplitPaneFfsC.setOrientation(javax.swing.JSplitPane.VERTICAL_SPLIT); | |
jSplitPaneFfsC.setDividerLocation(130); | |
jSplitPaneFfsC.setTopComponent(getJPanelFfsCTop()); | |
jSplitPaneFfsC.setBottomComponent(getJSplitPaneFfsCBottom()); | |
jSplitPaneFfsC.setDividerSize(5); | |
} | |
return jSplitPaneFfsC; | |
} | |
/** | |
* This method initializes jPanelFfsCTop | |
* | |
* @return javax.swing.JPanel | |
*/ | |
private JPanel getJPanelFfsCTop() { | |
if (jPanelFfsCTop == null) { | |
jPanelFfsCTop = new JPanel(); | |
jPanelFfsCTop.setLayout(new BorderLayout()); | |
jPanelFfsCTop.add(getJPanelSectionN(), java.awt.BorderLayout.NORTH); | |
jPanelFfsCTop.add(getJScrollPaneFfsSection(), java.awt.BorderLayout.CENTER); | |
} | |
return jPanelFfsCTop; | |
} | |
/** | |
* This method initializes jSplitPaneFfsCBottom | |
* | |
* @return javax.swing.JSplitPane | |
*/ | |
private JSplitPane getJSplitPaneFfsCBottom() { | |
if (jSplitPaneFfsCBottom == null) { | |
jSplitPaneFfsCBottom = new JSplitPane(); | |
jSplitPaneFfsCBottom.setDividerSize(5); | |
jSplitPaneFfsCBottom.setDividerLocation(130); | |
jSplitPaneFfsCBottom.setTopComponent(getJPanelFfsCBottomTop()); | |
jSplitPaneFfsCBottom.setBottomComponent(getJPanelFfsCBottomBottom()); | |
jSplitPaneFfsCBottom.setOrientation(javax.swing.JSplitPane.VERTICAL_SPLIT); | |
} | |
return jSplitPaneFfsCBottom; | |
} | |
/** | |
* This method initializes jPanelFfsCBottomTop | |
* | |
* @return javax.swing.JPanel | |
*/ | |
private JPanel getJPanelFfsCBottomTop() { | |
if (jPanelFfsCBottomTop == null) { | |
jPanelFfsCBottomTop = new JPanel(); | |
jPanelFfsCBottomTop.setLayout(new BorderLayout()); | |
jPanelFfsCBottomTop.add(getJPanelSectionsN(), java.awt.BorderLayout.NORTH); | |
jPanelFfsCBottomTop.add(getJScrollPaneFfsSections(), java.awt.BorderLayout.CENTER); | |
} | |
return jPanelFfsCBottomTop; | |
} | |
/** | |
* This method initializes jPanelFfsCBottomBottom | |
* | |
* @return javax.swing.JPanel | |
*/ | |
private JPanel getJPanelFfsCBottomBottom() { | |
if (jPanelFfsCBottomBottom == null) { | |
jPanelFfsCBottomBottom = new JPanel(); | |
jPanelFfsCBottomBottom.setLayout(new BorderLayout()); | |
jPanelFfsCBottomBottom.add(getJPanelSubSectionN(), java.awt.BorderLayout.NORTH); | |
jPanelFfsCBottomBottom.add(getJScrollPaneFfsSubSection(), java.awt.BorderLayout.CENTER); | |
} | |
return jPanelFfsCBottomBottom; | |
} | |
/** | |
* This method initializes jPanelSectionN | |
* | |
* @return javax.swing.JPanel | |
*/ | |
private JPanel getJPanelSectionN() { | |
if (jPanelSectionN == null) { | |
jPanelSectionN = new JPanel(); | |
jLabelFfsSection = new JLabel(); | |
jLabelFfsSection.setText("Section"); | |
jPanelSectionN.add(jLabelFfsSection, null); | |
jPanelSectionN.add(getJButtonFfsSectionNew(), null); | |
jPanelSectionN.add(getJButtonFfsSectionRemove(), null); | |
} | |
return jPanelSectionN; | |
} | |
/** | |
* This method initializes jPanelSectionsN | |
* | |
* @return javax.swing.JPanel | |
*/ | |
private JPanel getJPanelSectionsN() { | |
if (jPanelSectionsN == null) { | |
jPanelSectionsN = new JPanel(); | |
jLabelFfsSections = new JLabel(); | |
jLabelFfsSections.setText("Sections"); | |
jPanelSectionsN.add(jLabelFfsSections, null); | |
jPanelSectionsN.add(getJButtonFfsSectionsNew(), null); | |
jPanelSectionsN.add(getJButtonFfsSectionsRemove(), null); | |
} | |
return jPanelSectionsN; | |
} | |
/** | |
* This method initializes jPanelSubSectionN | |
* | |
* @return javax.swing.JPanel | |
*/ | |
private JPanel getJPanelSubSectionN() { | |
if (jPanelSubSectionN == null) { | |
jPanelSubSectionN = new JPanel(); | |
jLabelFfsSubSections = new JLabel(); | |
jLabelFfsSubSections.setText("Sub-Sections"); | |
jPanelSubSectionN.add(jLabelFfsSubSections, null); | |
jPanelSubSectionN.add(getJButtonFfsSubSectionNew(), null); | |
jPanelSubSectionN.add(getJButtonFfsSubSectionRemove(), null); | |
} | |
return jPanelSubSectionN; | |
} | |
/** | |
* The following section contains all Build Options content | |
*/ | |
/** | |
* This method initializes jPanelOptionsTab | |
* | |
* This is the main Options screen | |
* | |
* @return javax.swing.JPanel jPanelOptionsTab | |
*/ | |
private JPanel getJPanelOptionsTab() { | |
if (jPanelOptionsTab == null) { | |
// This container holds the Options Tab content | |
// FlowLayout flowLayout9 = new FlowLayout(); | |
// flowLayout9.setAlignment(java.awt.FlowLayout.LEFT); | |
GridLayout gridLayout = new GridLayout(); | |
gridLayout.setRows(2); | |
jPanelOptionsTab = new JPanel(); | |
jPanelOptionsTab.setLayout(gridLayout); | |
jPanelOptionsTab.setBounds(new java.awt.Rectangle(0, 0, dialogWidth * 2, dialogHeight * 3)); | |
jPanelOptionsTab.setPreferredSize(new java.awt.Dimension(dialogWidth + 10, (dialogHeight * 3) + 10)); | |
jPanelOptionsTab.setAutoscrolls(true); | |
jPanelOptionsTab.setLocation(0, 0); | |
jPanelOptionsTab.add(getJPanelOptionsContainer(), null); | |
// jPanelOptionsTab.add(getJScrollPaneOptions(), null); | |
jPanelOptionsTab.add(getJPanelTableOptionsContainer(), null); | |
} | |
return jPanelOptionsTab; | |
} | |
/** | |
* This method initializes jPanelOptionsContainer | |
* | |
* @return javax.swing.JPanel | |
*/ | |
private JPanel getJPanelOptionsContainer() { | |
if (jPanelOptionsContainer == null) { | |
jLabelTagName = new JLabel(); | |
jLabelTagName.setBounds(new java.awt.Rectangle(labelColumn, rowOne, labelWidth, oneRowHeight)); | |
jLabelTagName.setLocation(new java.awt.Point(labelColumn, rowOne)); | |
jLabelTagName.setText("Tag Name"); | |
jLabelBuildTargets = new JLabel(); | |
jLabelBuildTargets.setBounds(new java.awt.Rectangle(labelColumn, rowTwo, labelWidth, oneRowHeight)); | |
jLabelBuildTargets.setLocation(new java.awt.Point(labelColumn, rowTwo)); | |
jLabelBuildTargets.setText("Build Targets"); | |
jLabelToolCmd = new JLabel(); | |
jLabelToolCmd.setBounds(new java.awt.Rectangle(labelColumn, rowThree, labelWidth, oneRowHeight)); | |
jLabelToolCmd.setLocation(new java.awt.Point(labelColumn, rowThree)); | |
jLabelToolCmd.setText("Tool Command"); | |
jLabelSupArch = new JLabel(); | |
jLabelSupArch.setBounds(new java.awt.Rectangle(labelColumn, rowFour, labelWidth, oneRowHeight)); | |
jLabelSupArch.setLocation(new java.awt.Point(labelColumn, rowFour)); | |
jLabelSupArch.setText("Supported Architectures"); | |
jLabelToolChainFamily = new JLabel(); | |
jLabelToolChainFamily.setBounds(new java.awt.Rectangle(labelColumn, rowFive, labelWidth, oneRowHeight)); | |
jLabelToolChainFamily.setLocation(new java.awt.Point(labelColumn, rowFive)); | |
jLabelToolChainFamily.setText("Tool Chain Family"); | |
jLabelOptionContents = new JLabel(); | |
jLabelOptionContents.setBounds(new java.awt.Rectangle(labelColumn, rowSix, labelWidth, oneRowHeight)); | |
jLabelOptionContents.setLocation(new java.awt.Point(labelColumn, rowSix)); | |
jLabelOptionContents.setText("Argument Strings"); | |
jPanelOptionsContainer = new JPanel(); | |
jPanelOptionsContainer.setLayout(null); | |
jPanelOptionsContainer.setPreferredSize(new java.awt.Dimension(dialogWidth, dialogHeight)); | |
/* | |
jPanelOptionsContainer | |
.setBorder(javax.swing.BorderFactory | |
.createEtchedBorder(javax.swing.border.EtchedBorder.RAISED)); | |
*/ | |
jPanelOptionsContainer.add(jLabelTagName, null); | |
jPanelOptionsContainer.add(getJTextFieldTagName(), null); | |
jPanelOptionsContainer.add(jLabelBuildTargets, null); | |
jPanelOptionsContainer.add(getJTextFieldBuildTargets(), null); | |
jPanelOptionsContainer.add(jLabelToolChainFamily, null); | |
jPanelOptionsContainer.add(getJTextFieldToolChainFamily(), null); | |
jPanelOptionsContainer.add(jLabelToolCmd, null); | |
jPanelOptionsContainer.add(getJTextFieldToolCmd(), null); | |
jPanelOptionsContainer.add(jLabelSupArch, null); | |
jPanelOptionsContainer.add(getArchitectureSelections(), null); | |
jPanelOptionsContainer.add(jLabelOptionContents, null); | |
jPanelOptionsContainer.add(getJTextFieldOptionContents(), null); | |
jPanelOptionsContainer.add(getJButtonOptionsAdd(), null); | |
jPanelOptionsContainer.add(getJButtonOptionsDel(), null); | |
} | |
return jPanelOptionsContainer; | |
} | |
/** | |
* This method initializes jTextFieldOptionTagName Row 1 | |
* | |
* @return javax.swing.JTextField | |
*/ | |
private JTextField getJTextFieldTagName() { | |
if (jTextFieldTagName == null) { | |
jTextFieldTagName = new JTextField(); | |
jTextFieldTagName.setBounds(new java.awt.Rectangle(fieldColumn, rowOne, fieldWidth, oneRowHeight)); | |
jTextFieldTagName.setPreferredSize(new java.awt.Dimension(fieldWidth, oneRowHeight)); | |
jTextFieldTagName.setLocation(new java.awt.Point(fieldColumn, rowOne)); | |
} | |
return jTextFieldTagName; | |
} | |
/** | |
* This method initializes jTextFieldBuildTargets Row 2 | |
* | |
* @return javax.swing.JTextField jTextFieldBuildTargets | |
*/ | |
private JTextField getJTextFieldBuildTargets() { | |
if (jTextFieldBuildTargets == null) { | |
jTextFieldBuildTargets = new JTextField(); | |
jTextFieldBuildTargets.setBounds(new java.awt.Rectangle(fieldColumn, rowTwo, fieldWidth, oneRowHeight)); | |
jTextFieldBuildTargets.setPreferredSize(new java.awt.Dimension(fieldWidth, oneRowHeight)); | |
jTextFieldBuildTargets.setLocation(new java.awt.Point(fieldColumn, rowTwo)); | |
} | |
return jTextFieldBuildTargets; | |
} | |
/** | |
* This method initializes jTextFieldToolCmd Row 3 | |
* | |
* This should be a dropdown box of command codes from tools_def.txt | |
* | |
* @return javax.swing.JTextField jTextFieldToolCmd | |
*/ | |
private JTextField getJTextFieldToolCmd() { | |
if (jTextFieldToolCmd == null) { | |
jTextFieldToolCmd = new JTextField(); | |
jTextFieldToolCmd.setBounds(new java.awt.Rectangle(fieldColumn, rowThree, fieldWidth, oneRowHeight)); | |
jTextFieldToolCmd.setPreferredSize(new java.awt.Dimension(fieldWidth, oneRowHeight)); | |
jTextFieldToolCmd.setLocation(new java.awt.Point(fieldColumn, rowThree)); | |
} | |
return jTextFieldToolCmd; | |
} | |
/** | |
* This method initializes jArchitectureSelections Row 4 | |
* | |
* @return jArchitectureSelections | |
*/ | |
private JPanel getArchitectureSelections() { | |
if (jArchitectureSelections == null) { | |
jArchitectureSelections = new JPanel(); | |
jArchitectureSelections.setLayout(null); | |
jArchitectureSelections.add(getJCheckBoxIA32(), null); | |
jArchitectureSelections.add(getJCheckBoxX64(), null); | |
jArchitectureSelections.add(getJCheckBoxIpf(), null); | |
jArchitectureSelections.add(getJCheckBoxEBC(), null); | |
jArchitectureSelections.add(getJCheckBoxARM(), null); | |
jArchitectureSelections.add(getJCheckBoxPPC(), null); | |
jArchitectureSelections.setBounds(new java.awt.Rectangle(fieldColumn, rowFour, fieldWidth, oneRowHeight)); | |
jArchitectureSelections.setPreferredSize(new java.awt.Dimension(fieldWidth, oneRowHeight)); | |
jArchitectureSelections.setLocation(new java.awt.Point(fieldColumn, rowFour)); | |
} | |
return jArchitectureSelections; | |
} | |
/** | |
* This method initializes jCheckBoxIA32 | |
* | |
* @return javax.swing.JCheckBox jCheckBoxIA32 | |
*/ | |
private JCheckBox getJCheckBoxIA32() { | |
if (jCheckBoxIA32 == null) { | |
jCheckBoxIA32 = new JCheckBox(); | |
jCheckBoxIA32.setBounds(new java.awt.Rectangle(0, 0, 55, 20)); | |
jCheckBoxIA32.setText("IA32"); | |
} | |
return jCheckBoxIA32; | |
} | |
/** | |
* This method initializes jCheckBoxX64 | |
* | |
* @return javax.swing.JCheckBox jCheckBoxX64 | |
*/ | |
private JCheckBox getJCheckBoxX64() { | |
if (jCheckBoxX64 == null) { | |
jCheckBoxX64 = new JCheckBox(); | |
jCheckBoxX64.setText("X64"); | |
jCheckBoxX64.setBounds(new java.awt.Rectangle(55, 0, 53, 20)); | |
} | |
return jCheckBoxX64; | |
} | |
/** | |
* This method initializes jCheckBoxIpf | |
* | |
* @return javax.swing.JCheckBox jCheckBoxIpf | |
*/ | |
private JCheckBox getJCheckBoxIpf() { | |
if (jCheckBoxIpf == null) { | |
jCheckBoxIpf = new JCheckBox(); | |
jCheckBoxIpf.setBounds(new java.awt.Rectangle(108, 0, 52, 20)); | |
jCheckBoxIpf.setText("IPF"); | |
} | |
return jCheckBoxIpf; | |
} | |
/** | |
* This method initializes jCheckBoxEBC | |
* | |
* @return javax.swing.JCheckBox jCheckBoxEBC | |
*/ | |
private JCheckBox getJCheckBoxEBC() { | |
if (jCheckBoxEBC == null) { | |
jCheckBoxEBC = new JCheckBox(); | |
jCheckBoxEBC.setBounds(new java.awt.Rectangle(160, 0, 53, 20)); | |
jCheckBoxEBC.setText("EBC"); | |
} | |
return jCheckBoxEBC; | |
} | |
/** | |
* This method initializes jCheckBoxARM | |
* | |
* @return javax.swing.JCheckBox jCheckBoxARM | |
*/ | |
private JCheckBox getJCheckBoxARM() { | |
if (jCheckBoxARM == null) { | |
jCheckBoxARM = new JCheckBox(); | |
jCheckBoxARM.setBounds(new java.awt.Rectangle(213, 0, 54, 20)); | |
jCheckBoxARM.setText("ARM"); | |
} | |
return jCheckBoxARM; | |
} | |
/** | |
* This method initializes jCheckBoxPPC | |
* | |
* @return javax.swing.JCheckBox jCheckBoxPPC | |
*/ | |
private JCheckBox getJCheckBoxPPC() { | |
if (jCheckBoxPPC == null) { | |
jCheckBoxPPC = new JCheckBox(); | |
jCheckBoxPPC.setBounds(new java.awt.Rectangle(267, 0, 53, 20)); | |
jCheckBoxPPC.setText("PPC"); | |
} | |
return jCheckBoxPPC; | |
} | |
/** | |
* This method initializes jTextFieldToolChainFamily Row 5 | |
* | |
* This should be a drop down for MSFT, INTEL, GCC or USER_DEFINED | |
* | |
* @return javax.swing.JTextField | |
*/ | |
private JTextField getJTextFieldToolChainFamily() { | |
if (jTextFieldToolChainFamily == null) { | |
jTextFieldToolChainFamily = new JTextField(); | |
jTextFieldToolChainFamily.setBounds(new java.awt.Rectangle(fieldColumn, rowFive, fieldWidth, oneRowHeight)); | |
jTextFieldToolChainFamily.setPreferredSize(new java.awt.Dimension(fieldWidth, oneRowHeight)); | |
jTextFieldToolChainFamily.setLocation(new java.awt.Point(fieldColumn, rowFive)); | |
} | |
return jTextFieldToolChainFamily; | |
} | |
/** | |
* This method initializes jTextFieldOptionContents Row 6 | |
* | |
* This is where we should put the checkbox & entry data for the command arguments | |
* | |
* @return javax.swing.JTextField | |
*/ | |
private JTextField getJTextFieldOptionContents() { | |
if (jTextFieldOptionContents == null) { | |
jTextFieldOptionContents = new JTextField(); | |
jTextFieldOptionContents.setPreferredSize(new java.awt.Dimension(fieldWidth, oneRowHeight)); | |
jTextFieldOptionContents.setBounds(fieldColumn, rowSix, fieldWidth, oneRowHeight); | |
jTextFieldOptionContents.setLocation(new java.awt.Point(fieldColumn, rowSix)); | |
} | |
return jTextFieldOptionContents; | |
} | |
/** | |
* This method initializes jButtonOptionsAdd | |
* | |
* Add entry from the top screen to the table | |
* | |
* @return javax.swing.JButton jButtonOptionsAdd | |
*/ | |
private JButton getJButtonOptionsAdd() { | |
if (jButtonOptionsAdd == null) { | |
jButtonOptionsAdd = new JButton(); | |
jButtonOptionsAdd.setText("Add"); | |
jButtonOptionsAdd.setPreferredSize(new java.awt.Dimension(buttonWidth, oneRowHeight)); | |
jButtonOptionsAdd.setBounds(new java.awt.Rectangle(firstButtonLoc, buttonRow, buttonWidth, oneRowHeight)); | |
jButtonOptionsAdd.setLocation(new java.awt.Point(firstButtonLoc, buttonRow)); | |
jButtonOptionsAdd.addActionListener(new AbstractAction() { | |
/** | |
* | |
*/ | |
private static final long serialVersionUID = 1L; | |
public void actionPerformed(java.awt.event.ActionEvent e) { | |
boolean[] boolArray = { jCheckBoxIA32.isSelected(), jCheckBoxIpf.isSelected(), | |
jCheckBoxX64.isSelected(), jCheckBoxEBC.isSelected(), | |
jCheckBoxARM.isSelected(), jCheckBoxPPC.isSelected() }; | |
String s = boolToList(boolArray); | |
Object[] o = { jTextFieldBuildTargets.getText(), jTextFieldToolChainFamily.getText(), s, | |
jTextFieldToolCmd.getText(), jTextFieldTagName.getText(), | |
jTextFieldOptionContents.getText() }; | |
optionsTableModel.addRow(o); | |
docConsole.setSaved(false); | |
ffc.genBuildOptionsOpt(stringToVector(jTextFieldBuildTargets.getText().trim()), | |
jTextFieldToolChainFamily.getText(), jTextFieldTagName.getText(), | |
jTextFieldToolCmd.getText(), stringToVector(s.trim()), | |
jTextFieldOptionContents.getText()); | |
} | |
}); | |
} | |
return jButtonOptionsAdd; | |
} | |
/** | |
* This method initializes jButtonOptionsDel | |
* | |
* Remove a line from the table below | |
* | |
* @return javax.swing.JButton jButtonOptionsDel | |
*/ | |
private JButton getJButtonOptionsDel() { | |
if (jButtonOptionsDel == null) { | |
jButtonOptionsDel = new JButton(); | |
jButtonOptionsDel.setText("Delete"); | |
jButtonOptionsDel.setPreferredSize(new java.awt.Dimension(buttonWidth, oneRowHeight)); | |
jButtonOptionsDel.setBounds(new java.awt.Rectangle(next2LastButtonLoc, buttonRow, buttonWidth, oneRowHeight)); | |
jButtonOptionsDel.setLocation(new java.awt.Point(next2LastButtonLoc, buttonRow)); | |
jButtonOptionsDel.addActionListener(new AbstractAction() { | |
/** | |
* | |
*/ | |
private static final long serialVersionUID = 1L; | |
public void actionPerformed(java.awt.event.ActionEvent e) { | |
if (selectedRow >= 0) { | |
optionsTableModel.removeRow(selectedRow); | |
docConsole.setSaved(false); | |
ffc.removeBuildOptionsOpt(selectedRow); | |
} | |
} | |
}); | |
} | |
return jButtonOptionsDel; | |
} | |
public void componentResized(ComponentEvent arg0) { | |
int intPreferredWidth = 500; | |
Tools.resizeComponentWidth(this.jScrollPaneOptions, this.getWidth(), intPreferredWidth); | |
} | |
/** | |
* This method initializes jScrollPaneOptions | |
* Contains the Table and is located below the data entry section | |
* @return javax.swing.JScrollPane jScrollPaneOptoins | |
*/ | |
private JScrollPane getJScrollPaneOptions() { | |
if (jScrollPaneOptions == null) { | |
jScrollPaneOptions = new JScrollPane(); | |
jScrollPaneOptions.setViewportView(getJTableOptions()); | |
} | |
return jScrollPaneOptions; | |
} | |
/** | |
* This method initializes jTableOptions | |
* | |
* @return javax.swing.JTable jTableOptions | |
*/ | |
private JTable getJTableOptions() { | |
if (jTableOptions == null) { | |
optionsTableModel = new DefaultTableModel(); | |
jTableOptions = new JTable(optionsTableModel); | |
jTableOptions.setRowHeight(20); | |
optionsTableModel.addColumn("Build Targets"); | |
optionsTableModel.addColumn("Tool Chain Family"); | |
optionsTableModel.addColumn("Supported Architectures"); | |
optionsTableModel.addColumn("Tool Command Code"); | |
optionsTableModel.addColumn("TagName"); | |
optionsTableModel.addColumn("Arguments"); | |
jTableOptions.getColumnModel().getColumn(0).setMinWidth(buildTargetWidth); | |
jTableOptions.getColumnModel().getColumn(1).setMinWidth(toolChainFamilyWidth); | |
jTableOptions.getColumnModel().getColumn(2).setMinWidth(supportArchWidth); | |
jTableOptions.getColumnModel().getColumn(3).setMinWidth(toolCmdCodeWidth); | |
jTableOptions.getColumnModel().getColumn(4).setMinWidth(tagNameWidth); | |
jTableOptions.getColumnModel().getColumn(5).setMinWidth(argWidth); | |
// javax.swing.table.TableColumn toolFamilyCol = jTableOptions.getColumnModel().getColumn(1); | |
// JComboBox cb = new JComboBox(); | |
// cb.addItem("MSFT"); | |
// cb.addItem("GCC"); | |
// cb.addItem("CYGWIN"); | |
// cb.addItem("INTEL"); | |
// cb.addItem("USER_DEFINED"); | |
// toolFamilyCol.setCellEditor(new DefaultCellEditor(cb)); | |
Vector<String> vArch = new Vector<String>(); | |
vArch.add("IA32"); | |
vArch.add("X64"); | |
vArch.add("IPF"); | |
vArch.add("EBC"); | |
vArch.add("ARM"); | |
vArch.add("PPC"); | |
jTableOptions.getColumnModel().getColumn(2).setCellEditor(new ListEditor(vArch, FrameworkWizardUI.getInstance())); | |
jTableOptions.getColumnModel().getColumn(5).setCellEditor(new LongTextEditor(FrameworkWizardUI.getInstance())); | |
jTableOptions.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); | |
jTableOptions.setAutoResizeMode(javax.swing.JTable.AUTO_RESIZE_OFF); | |
jTableOptions.getSelectionModel().addListSelectionListener(new ListSelectionListener() { | |
public void valueChanged(ListSelectionEvent e) { | |
selectedRow = -1; | |
if (e.getValueIsAdjusting()) { | |
return; | |
} | |
ListSelectionModel lsm = (ListSelectionModel) e.getSource(); | |
if (lsm.isSelectionEmpty()) { | |
return; | |
} else { | |
selectedRow = lsm.getMinSelectionIndex(); | |
} | |
} | |
}); | |
jTableOptions.getModel().addTableModelListener(new TableModelListener() { | |
public void tableChanged(TableModelEvent arg0) { | |
// TODO Auto-generated method stub | |
int row = arg0.getFirstRow(); | |
TableModel m = (TableModel) arg0.getSource(); | |
if (arg0.getType() == TableModelEvent.UPDATE) { | |
//ToDo Data Validition check. | |
String targets = m.getValueAt(row, 0) + ""; | |
Vector<Object> targetName = new Vector<Object>(); | |
String[] sArray = targets.split("( )+"); | |
for (int i = 0; i < sArray.length; ++i) { | |
targetName.add(sArray[i]); | |
} | |
String toolChain = m.getValueAt(row, 1) + ""; | |
String archs = m.getValueAt(row, 2) + ""; | |
Vector<Object> supArch = null; | |
if (archs.length() > 0) { | |
supArch = new Vector<Object>(); | |
String[] sArray1 = archs.split("( )+"); | |
for (int i = 0; i < sArray1.length; ++i) { | |
supArch.add(sArray1[i]); | |
} | |
} | |
String toolCmd = m.getValueAt(row, 3) + ""; | |
String tagName = m.getValueAt(row, 4) + ""; | |
String contents = m.getValueAt(row, 5) + ""; | |
docConsole.setSaved(false); | |
ffc.updateBuildOptionsOpt(row, targetName, toolChain, tagName, toolCmd, supArch, contents); | |
} | |
} | |
}); | |
} | |
return jTableOptions; | |
} | |
private Vector<Object> stringToVector(String s) { | |
String[] sArray = s.split(" "); | |
Vector<Object> v = null; | |
if (s.length() > 0 && !s.trim().equalsIgnoreCase("")) { | |
v = new Vector<Object>(); | |
for (int i = 0; i < sArray.length; ++i) { | |
v.add(sArray[i]); | |
} | |
} | |
return v; | |
} | |
private String boolToList(boolean[] bool) { | |
String s = " "; | |
if (bool[0]) { | |
s += "IA32 "; | |
} | |
if (bool[1]) { | |
s += "IPF "; | |
} | |
if (bool[2]) { | |
s += "X64 "; | |
} | |
if (bool[3]) { | |
s += "EBC "; | |
} | |
if (bool[4]) { | |
s += "ARM "; | |
} | |
if (bool[5]) { | |
s += "PPC "; | |
} | |
return s.trim(); | |
} | |
private void initOptionTable() { | |
if (ffc.getBuildOptionsOptCount() == 0) { | |
//ToDo get default options from *.txt file | |
return; | |
} | |
String[][] saa = new String[ffc.getBuildOptionsOptCount()][6]; | |
ffc.getBuildOptionsOpts(saa); | |
for (int i = 0; i < saa.length; ++i) { | |
optionsTableModel.addRow(saa[i]); | |
} | |
} | |
/** | |
* Everything below should pertain to the ANT Task Tab | |
*/ | |
/** | |
* This method initializes jButton12 | |
* | |
* @return javax.swing.JButton | |
*/ | |
private JButton getJButtonAntTaskFileBrowse() { | |
if (jButtonAntTaskFileBrowse == null) { | |
jButtonAntTaskFileBrowse = new JButton(); | |
jButtonAntTaskFileBrowse.setPreferredSize(new Dimension(buttonWidth, oneRowHeight)); | |
jButtonAntTaskFileBrowse.setText("Browse"); | |
jButtonAntTaskFileBrowse.addActionListener(new AbstractAction() { | |
private static final long serialVersionUID = 1L; | |
public void actionPerformed(ActionEvent arg0) { | |
// | |
// Select files from current workspace | |
// | |
String dirPrefix = Workspace.getCurrentWorkspace(); | |
JFileChooser chooser = new JFileChooser(dirPrefix); | |
File theFile = null; | |
String headerDest = null; | |
chooser.setMultiSelectionEnabled(false); | |
chooser.setFileSelectionMode(JFileChooser.FILES_ONLY); | |
int retval = chooser.showOpenDialog(FpdBuildOptions.this); | |
if (retval == JFileChooser.APPROVE_OPTION) { | |
theFile = chooser.getSelectedFile(); | |
String file = theFile.getPath(); | |
if (!file.startsWith(dirPrefix)) { | |
JOptionPane.showMessageDialog(FpdBuildOptions.this, "You can only select files in current package!"); | |
return; | |
} | |
} else { | |
return; | |
} | |
headerDest = theFile.getPath(); | |
jTextFieldAntTaskFile.setText(headerDest.substring(dirPrefix.length()).replace('\\', '/')); | |
} | |
}); | |
} | |
return jButtonAntTaskFileBrowse; | |
} | |
/** | |
* This method initializes jPanelUserDefCenterN | |
* | |
* @return javax.swing.JPanel | |
*/ | |
private JPanel getJPanelUserDefCenterN() { | |
if (jPanelUserDefCenterN == null) { | |
jPanelUserDefCenterN = new JPanel(); | |
jPanelUserDefCenterN.add(jLabelAntCmdOpts, null); | |
jPanelUserDefCenterN.add(getJTextFieldAntCmdOpts(), null); | |
jPanelUserDefCenterN.add(getJButtonAntTaskAdd(), null); | |
jPanelUserDefCenterN.add(getJButtonAntTaskDel(), null); | |
} | |
return jPanelUserDefCenterN; | |
} | |
/** | |
* This method initializes jPanel8 | |
* | |
* @return javax.swing.JPanel | |
*/ | |
private JPanel getJPanelUserDef() { | |
if (jPanelUserDef == null) { | |
jPanelUserDef = new JPanel(); | |
jPanelUserDef.setLayout(new BorderLayout()); | |
jPanelUserDef.add(getJPanelUserDefNorth(), java.awt.BorderLayout.NORTH); | |
jPanelUserDef.add(getJPanelUserDefCenter(), java.awt.BorderLayout.CENTER); | |
} | |
return jPanelUserDef; | |
} | |
/** | |
* This method initializes jPanel9 | |
* | |
* @return javax.swing.JPanel | |
*/ | |
private JPanel getJPanelUserDefNorth() { | |
if (jPanelUserDefNorth == null) { | |
jLabelAntTaskFile = new JLabel(); | |
jLabelAntTaskFile.setText("ANT Task File"); | |
jLabelAntTaskFile.setPreferredSize(new java.awt.Dimension(80, 20)); | |
FlowLayout flowLayout8 = new FlowLayout(); | |
flowLayout8.setAlignment(java.awt.FlowLayout.CENTER); | |
jLabelAntTaskId = new JLabel(); | |
jLabelAntTaskId.setText("ID"); | |
jPanelUserDefNorth = new JPanel(); | |
jPanelUserDefNorth.setLayout(flowLayout8); | |
jPanelUserDefNorth.add(jLabelAntTaskFile, null); | |
jPanelUserDefNorth.add(getJTextFieldAntTaskFile(), null); | |
jPanelUserDefNorth.add(getJButtonAntTaskFileBrowse(), null); | |
jPanelUserDefNorth.add(jLabelAntTaskId, null); | |
jPanelUserDefNorth.add(getJTextFieldAntTaskId(), null); | |
} | |
return jPanelUserDefNorth; | |
} | |
/** | |
* This method initializes jPanel11 | |
* | |
* @return javax.swing.JPanel | |
*/ | |
private JPanel getJPanelUserDefCenter() { | |
if (jPanelUserDefCenter == null) { | |
jLabelAntCmdOpts = new JLabel(); | |
jLabelAntCmdOpts.setText("ANT Command Options"); | |
jLabelAntCmdOpts.setPreferredSize(new java.awt.Dimension(131, 20)); | |
jPanelUserDefCenter = new JPanel(); | |
jPanelUserDefCenter.setLayout(new BorderLayout()); | |
jPanelUserDefCenter.add(getJPanelUserDefCenterN(), java.awt.BorderLayout.NORTH); | |
jPanelUserDefCenter.add(getJScrollPaneAntTasks(), java.awt.BorderLayout.CENTER); | |
} | |
return jPanelUserDefCenter; | |
} | |
/** | |
* This method initializes jTextField2 | |
* | |
* @return javax.swing.JTextField | |
*/ | |
private JTextField getJTextFieldAntTaskFile() { | |
if (jTextFieldAntTaskFile == null) { | |
jTextFieldAntTaskFile = new JTextField(); | |
jTextFieldAntTaskFile.setPreferredSize(new java.awt.Dimension(200, 20)); | |
} | |
return jTextFieldAntTaskFile; | |
} | |
/** | |
* This method initializes jTextField3 | |
* | |
* @return javax.swing.JTextField | |
*/ | |
private JTextField getJTextFieldAntTaskId() { | |
if (jTextFieldAntTaskId == null) { | |
jTextFieldAntTaskId = new JTextField(); | |
jTextFieldAntTaskId.setPreferredSize(new java.awt.Dimension(100, 20)); | |
} | |
return jTextFieldAntTaskId; | |
} | |
/** | |
* This method initializes jButton4 | |
* | |
* @return javax.swing.JButton | |
*/ | |
private JButton getJButtonAntTaskAdd() { | |
if (jButtonAntTaskAdd == null) { | |
jButtonAntTaskAdd = new JButton(); | |
jButtonAntTaskAdd.setPreferredSize(new java.awt.Dimension(90, 20)); | |
jButtonAntTaskAdd.setText("Add"); | |
jButtonAntTaskAdd.addActionListener(new ActionListener() { | |
public void actionPerformed(ActionEvent e) { | |
if (!DataValidation.isInt(jTextFieldAntTaskId.getText()) | |
|| jTextFieldAntTaskId.getText().length() != 8) { | |
JOptionPane.showMessageDialog(FpdBuildOptions.this, "ID must be an 8-digit integer."); | |
return; | |
} | |
Object[] o = { jTextFieldAntTaskId.getText(), null, null }; | |
o[1] = jTextFieldAntTaskFile.getText(); | |
o[2] = jTextFieldAntCmdOpts.getText(); | |
ffc.genBuildOptionsUserDefAntTask(o[0] + "", o[1] + "", o[2] + ""); | |
antTaskTableModel.addRow(o); | |
docConsole.setSaved(false); | |
} | |
}); | |
} | |
return jButtonAntTaskAdd; | |
} | |
/** | |
* This method initializes jButton5 | |
* | |
* @return javax.swing.JButton | |
*/ | |
private JButton getJButtonAntTaskDel() { | |
if (jButtonAntTaskDel == null) { | |
jButtonAntTaskDel = new JButton(); | |
jButtonAntTaskDel.setPreferredSize(new java.awt.Dimension(90, 20)); | |
jButtonAntTaskDel.setText("Delete"); | |
jButtonAntTaskDel.addActionListener(new ActionListener() { | |
public void actionPerformed(ActionEvent e) { | |
if (selectedRow >= 0) { | |
docConsole.setSaved(false); | |
antTaskTableModel.removeRow(selectedRow); | |
ffc.removeBuildOptionsUserDefAntTask(selectedRow); | |
} | |
} | |
}); | |
} | |
return jButtonAntTaskDel; | |
} | |
/** | |
* This method initializes jTextField4 | |
* | |
* @return javax.swing.JTextField | |
*/ | |
private JTextField getJTextFieldAntCmdOpts() { | |
if (jTextFieldAntCmdOpts == null) { | |
jTextFieldAntCmdOpts = new JTextField(); | |
jTextFieldAntCmdOpts.setPreferredSize(new java.awt.Dimension(270, 20)); | |
jTextFieldAntCmdOpts.setEnabled(true); | |
} | |
return jTextFieldAntCmdOpts; | |
} | |
/** | |
* This method initializes jScrollPane2 | |
* | |
* @return javax.swing.JScrollPane | |
*/ | |
private JScrollPane getJScrollPaneAntTasks() { | |
if (jScrollPaneAntTasks == null) { | |
jScrollPaneAntTasks = new JScrollPane(); | |
jScrollPaneAntTasks.setPreferredSize(new java.awt.Dimension(600, 400)); | |
jScrollPaneAntTasks.setViewportView(getJTableAntTasks()); | |
} | |
return jScrollPaneAntTasks; | |
} | |
/** | |
* This method initializes jTable2 | |
* | |
* @return javax.swing.JTable | |
*/ | |
private JTable getJTableAntTasks() { | |
if (jTableAntTasks == null) { | |
antTaskTableModel = new DefaultTableModel(); | |
jTableAntTasks = new JTable(antTaskTableModel); | |
jTableAntTasks.setRowHeight(20); | |
antTaskTableModel.addColumn("ID"); | |
antTaskTableModel.addColumn("Filename"); | |
antTaskTableModel.addColumn("ANT Command Options"); | |
jTableAntTasks.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); | |
jTableAntTasks.getSelectionModel().addListSelectionListener(new ListSelectionListener() { | |
public void valueChanged(ListSelectionEvent e) { | |
selectedRow = -1; | |
if (e.getValueIsAdjusting()) { | |
return; | |
} | |
ListSelectionModel lsm = (ListSelectionModel) e.getSource(); | |
if (lsm.isSelectionEmpty()) { | |
return; | |
} else { | |
selectedRow = lsm.getMinSelectionIndex(); | |
} | |
} | |
}); | |
jTableAntTasks.getModel().addTableModelListener(new TableModelListener() { | |
public void tableChanged(TableModelEvent arg0) { | |
// TODO Auto-generated method stub | |
int row = arg0.getFirstRow(); | |
TableModel m = (TableModel) arg0.getSource(); | |
if (arg0.getType() == TableModelEvent.UPDATE) { | |
//ToDo Data Validition check. | |
String id = m.getValueAt(row, 0) + ""; | |
String file = m.getValueAt(row, 1) + ""; | |
String execOrder = m.getValueAt(row, 2) + ""; | |
if (id.length() == 0) { | |
return; | |
} | |
if (file.length() == 0 && execOrder.length() == 0) { | |
return; | |
} | |
if (file.length() == 0) { | |
file = null; | |
} | |
if (execOrder.length() == 0) { | |
execOrder = null; | |
} | |
ffc.updateBuildOptionsUserDefAntTask(row, id, file, execOrder); | |
} | |
} | |
}); | |
} | |
return jTableAntTasks; | |
} | |
private void initAntTaskTable() { | |
if (ffc.getBuildOptionsUserDefAntTaskCount() == 0) { | |
return; | |
} | |
String[][] saa = new String[ffc.getBuildOptionsUserDefAntTaskCount()][3]; | |
ffc.getBuildOptionsUserDefAntTasks(saa); | |
for (int i = 0; i < saa.length; ++i) { | |
antTaskTableModel.addRow(saa[i]); | |
} | |
} | |
} // @jve:decl-index=0:visual-constraint="10,10" |