Tools/Java/Source/FrameworkWizard/src/org/tianocore/frameworkwizard/packaging/ui/SpdPcdDefs.java

   1 /** @file
   2   Java class SpdPcdDefs is GUI for create PCD definition elements of spd file.
   3
   4 Copyright (c) 2006, Intel Corporation
   5 All rights reserved. This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12 **/
  13 package org.tianocore.frameworkwizard.packaging.ui;
  14
  15 import java.awt.Dimension;
  16 import java.awt.FontMetrics;
  17 import java.awt.event.ActionEvent;
  18 import java.awt.event.ComponentEvent;
  19
  20 import javax.swing.DefaultCellEditor;
  21 import javax.swing.JFrame;
  22 import javax.swing.JOptionPane;
  23 import javax.swing.JPanel;
  24 import javax.swing.JLabel;
  25 import javax.swing.JTextField;
  26 import javax.swing.JComboBox;
  27 import javax.swing.JButton;
  28 import javax.swing.ListSelectionModel;
  29
  30 import javax.swing.event.InternalFrameAdapter;
  31 import javax.swing.event.InternalFrameEvent;
  32 import javax.swing.event.ListSelectionEvent;
  33 import javax.swing.event.ListSelectionListener;
  34 import javax.swing.event.TableModelEvent;
  35 import javax.swing.event.TableModelListener;
  36 import javax.swing.table.DefaultTableModel;
  37 import javax.swing.table.TableColumn;
  38 import javax.swing.table.TableModel;
  39
  40 import org.tianocore.PackageSurfaceAreaDocument;
  41
  42 import org.tianocore.frameworkwizard.common.DataValidation;
  43 import org.tianocore.frameworkwizard.common.Tools;
  44 import org.tianocore.frameworkwizard.common.Identifications.OpeningPackageType;
  45 import org.tianocore.frameworkwizard.common.ui.IInternalFrame;
  46 import org.tianocore.frameworkwizard.common.ui.StarLabel;
  47 import javax.swing.JScrollPane;
  48 import javax.swing.JTable;
  49 import javax.swing.JCheckBox;
  50 import org.tianocore.frameworkwizard.common.ui.iCheckBoxList.ICheckBoxList;
  51 import org.tianocore.frameworkwizard.platform.ui.ListEditor;
  52 import org.tianocore.frameworkwizard.platform.ui.LongTextEditor;
  53
  54 import java.awt.Rectangle;
  55 import java.util.Vector;
  56
  57 /**
  58  GUI for create PCD definition elements of spd file
  59
  60  @since PackageEditor 1.0
  61 **/
  62 public class SpdPcdDefs extends IInternalFrame implements TableModelListener{
  63
  64     /**
  65      *
  66      */
  67     private static final long serialVersionUID = 1L;
  68
  69     static JFrame frame;
  70
  71     private JPanel jContentPane = null;
  72
  73     private JLabel jLabelItemType = null;
  74
  75     private JLabel jLabelC_Name = null;
  76
  77     private JTextField jTextFieldC_Name = null;
  78
  79     private JLabel jLabelToken = null;
  80
  81     private JTextField jTextFieldToken = null;
  82
  83     private JLabel jLabelDataType = null;
  84
  85     private JButton jButtonOk = null;
  86
  87     private JButton jButtonCancel = null;
  88
  89     private JComboBox jComboBoxDataType = null;
  90
  91     private SpdFileContents sfc = null;
  92
  93     private OpeningPackageType docConsole = null;
  94
  95     private StarLabel jStarLabel2 = null;
  96
  97     private StarLabel jStarLabel3 = null;
  98
  99     private StarLabel jStarLabel4 = null;
 100
 101     private StarLabel jStarLabel = null;
 102
 103     private StarLabel jStarLabel1 = null;
 104
 105     private JLabel jLabelTokenSpace = null;
 106
 107     private JComboBox jComboBoxTsGuid = null;
 108
 109     private JLabel jLabelVarVal = null;
 110
 111     private JTextField jTextFieldHelp = null;
 112
 113     private JLabel jLabelDefVal = null;
 114
 115     private JTextField jTextFieldDefaultValue = null;
 116
 117     private JButton jButtonAdd = null;
 118
 119     private CheckboxTableModel model = null;
 120
 121     private JButton jButtonRemove = null;
 122
 123     private JButton jButtonClearAll = null;
 124
 125     private JScrollPane jScrollPane = null;
 126
 127     private JTable jTable = null;
 128
 129     private JScrollPane topScrollPane = null;  //  @jve:decl-index=0:visual-constraint="390,10"
 130
 131     private int selectedRow = -1;
 132
 133     private StarLabel starLabel = null;
 134
 135     private JCheckBox jCheckBoxFeatureFlag = null;
 136
 137     private JCheckBox jCheckBoxFixedAtBuild = null;
 138
 139     private JCheckBox jCheckBoxPatchInMod = null;
 140
 141     private JCheckBox jCheckBoxDyn = null;
 142
 143     private JCheckBox jCheckBoxDynEx = null;
 144
 145     private JScrollPane jScrollPaneArch = null;
 146
 147     private ICheckBoxList iCheckBoxListArch = null;
 148
 149     private JScrollPane jScrollPaneMod = null;
 150
 151     private ICheckBoxList iCheckBoxListMod = null;
 152
 153     private JLabel jLabelSupMod = null;
 154
 155     private JLabel jLabelSupArch = null;
 156
 157     private final int pcdCNameMinWidth = 200;
 158     private final int pcdTokenMinWidth = 100;
 159     private final int pcdTokenSpaceMinWidth = 200;
 160     private final int datumTypeMinWidth = 80;
 161     private final int defaultValueMinWidth = 100;
 162     private final int helpTextMinWidth = 200;
 163     private final int usageMinWidth = 60;
 164     private final int supArchMinWidth = 200;
 165     private final int supModMinWidth = 200;
 166
 167     /**
 168      This method initializes this
 169
 170      **/
 171     private void initialize() {
 172         this.setTitle("PCD Declarations");
 173         this.setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_CLOSE);
 174
 175         int xPos = jCheckBoxPatchInMod.getX() + jCheckBoxPatchInMod.getWidth();
 176         jCheckBoxFixedAtBuild.setLocation(xPos,133);
 177
 178         xPos = jCheckBoxFeatureFlag.getX() + jCheckBoxFeatureFlag.getWidth();
 179         jCheckBoxDyn.setLocation(xPos,161);
 180
 181         xPos = jCheckBoxDyn.getX() + jCheckBoxDyn.getWidth();
 182         jCheckBoxDynEx.setLocation(xPos,161);
 183
 184     }
 185
 186     /**
 187      This method initializes jTextFieldC_Name
 188
 189      @return javax.swing.JTextField
 190      **/
 191     private JTextField getJTextFieldC_Name() {
 192         if (jTextFieldC_Name == null) {
 193             jTextFieldC_Name = new JTextField();
 194             jTextFieldC_Name.setBounds(new java.awt.Rectangle(156,9,317,20));
 195             jTextFieldC_Name.setPreferredSize(new java.awt.Dimension(315,20));
 196         }
 197         return jTextFieldC_Name;
 198     }
 199
 200     /**
 201      This method initializes jTextFieldToken
 202
 203      @return javax.swing.JTextField
 204      **/
 205     private JTextField getJTextFieldToken() {
 206         if (jTextFieldToken == null) {
 207             jTextFieldToken = new JTextField();
 208             jTextFieldToken.setBounds(new java.awt.Rectangle(156,33,317,20));
 209             jTextFieldToken.setPreferredSize(new java.awt.Dimension(315,20));
 210         }
 211         return jTextFieldToken;
 212     }
 213
 214     /**
 215      This method initializes jButtonOk
 216
 217      @return javax.swing.JButton
 218      **/
 219     private JButton getJButtonOk() {
 220         if (jButtonOk == null) {
 221             jButtonOk = new JButton();
 222             jButtonOk.setText("OK");
 223             jButtonOk.setBounds(new java.awt.Rectangle(279,276,90,20));
 224             jButtonOk.setVisible(false);
 225             jButtonOk.addActionListener(this);
 226         }
 227         return jButtonOk;
 228     }
 229
 230     /**
 231      This method initializes jButtonCancel
 232
 233      @return javax.swing.JButton
 234      **/
 235     private JButton getJButtonCancel() {
 236         if (jButtonCancel == null) {
 237             jButtonCancel = new JButton();
 238             jButtonCancel.setText("Cancel");
 239             jButtonCancel.setBounds(new java.awt.Rectangle(389,276,82,20));
 240             jButtonCancel.setVisible(false);
 241             jButtonCancel.addActionListener(this);
 242         }
 243         return jButtonCancel;
 244     }
 245
 246     /**
 247      This method initializes jComboBoxDataType
 248
 249      @return javax.swing.JComboBox
 250      **/
 251     private JComboBox getJComboBoxDataType() {
 252         if (jComboBoxDataType == null) {
 253             jComboBoxDataType = new JComboBox();
 254             jComboBoxDataType.setBounds(new java.awt.Rectangle(156,84,110,20));
 255         }
 256         return jComboBoxDataType;
 257     }
 258
 259     /**
 260      This is the default constructor
 261      **/
 262     public SpdPcdDefs() {
 263         super();
 264         init();
 265         initialize();
 266
 267     }
 268
 269     public SpdPcdDefs(PackageSurfaceAreaDocument.PackageSurfaceArea inPsa) {
 270         this();
 271         sfc = new SpdFileContents(inPsa);
 272         init(sfc);
 273     }
 274
 275     public SpdPcdDefs(OpeningPackageType opt) {
 276         this(opt.getXmlSpd());
 277         docConsole = opt;
 278     }
 279     /**
 280      This method initializes this
 281
 282      @return void
 283      **/
 284     private void init() {
 285         this.setSize(500, 650);
 286         this.setContentPane(getJContentPane());
 287         this.addInternalFrameListener(new InternalFrameAdapter(){
 288             public void internalFrameDeactivated(InternalFrameEvent e){
 289                 if (jTable.isEditing()) {
 290                     jTable.getCellEditor().stopCellEditing();
 291                 }
 292             }
 293         });
 294
 295         this.setVisible(true);
 296     }
 297
 298     private void init(SpdFileContents sfc){
 299         initFrame(sfc);
 300         if (sfc.getSpdPcdDefinitionCount() == 0) {
 301             return ;
 302         }
 303         String[][] saa = new String[sfc.getSpdPcdDefinitionCount()][8];
 304         String[][] usage = new String[sfc.getSpdPcdDefinitionCount()][5];
 305         Object[] rowData = new Object[13];
 306         sfc.getSpdPcdDefinitions(saa, usage);
 307         int i = 0;
 308         while (i < saa.length) {
 309
 310             for (int k = 0; k < 6; ++k) {
 311                 rowData[k] = saa[i][k];
 312             }
 313             for (int m = 6; m < 11; ++m) {
 314                 rowData[m] = new Boolean("false");
 315             }
 316             int j = 0;
 317             while (j < 5) {
 318                 if (usage[i][j] == null || usage[i][j].length()==0){
 319                     ++j;
 320                     continue;
 321                 }
 322                 if (usage[i][j].equals("FEATURE_FLAG")){
 323                     rowData[6] = new Boolean("true");
 324                 }
 325                 if (usage[i][j].equals("FIXED_AT_BUILD")){
 326                     rowData[7] = new Boolean("true");
 327                 }
 328                 if (usage[i][j].equals("PATCHABLE_IN_MODULE")){
 329                     rowData[8] = new Boolean("true");
 330                 }
 331                 if (usage[i][j].equals("DYNAMIC")){
 332                     rowData[9] = new Boolean("true");
 333                 }
 334                 if (usage[i][j].equals("DYNAMIC_EX")){
 335                     rowData[10] = new Boolean("true");
 336                 }
 337
 338                 ++j;
 339             }
 340
 341             rowData[11] = saa[i][6];
 342             rowData[12] = saa[i][7];
 343
 344             model.addRow(rowData);
 345
 346             i++;
 347         }
 348
 349
 350
 351     }
 352
 353     private JScrollPane getJContentPane(){
 354         if (topScrollPane == null){
 355             topScrollPane = new JScrollPane();
 356             topScrollPane.setSize(new java.awt.Dimension(482,451));
 357             topScrollPane.setViewportView(getJContentPane1());
 358         }
 359         return topScrollPane;
 360     }
 361     private JPanel getJContentPane1() {
 362                 if (jContentPane == null) {
 363
 364             jLabelSupArch = new JLabel();
 365             jLabelSupArch.setBounds(new java.awt.Rectangle(241,192,89,16));
 366             jLabelSupArch.setText("Supported Architectures");
 367             jLabelSupArch.setEnabled(true);
 368             FontMetrics fm = jLabelSupArch.getFontMetrics(jLabelSupArch.getFont());
 369             jLabelSupArch.setSize(fm.stringWidth(jLabelSupArch.getText()) + 10, 20);
 370             jLabelSupMod = new JLabel();
 371             jLabelSupMod.setBounds(new java.awt.Rectangle(15,193,103,16));
 372             jLabelSupMod.setText("Supported Module types");
 373             jLabelSupMod.setEnabled(true);
 374             fm = jLabelSupMod.getFontMetrics(jLabelSupMod.getFont());
 375             jLabelSupMod.setSize(fm.stringWidth(jLabelSupMod.getText()) + 10, 20);
 376             starLabel = new StarLabel();
 377             starLabel.setBounds(new java.awt.Rectangle(2,134,10,20));
 378             jLabelDefVal = new JLabel();
 379             jLabelDefVal.setBounds(new java.awt.Rectangle(277,84,80,20));
 380             jLabelDefVal.setText("Default Value");
 381             fm = jLabelDefVal.getFontMetrics(jLabelDefVal.getFont());
 382             jLabelDefVal.setSize(fm.stringWidth(jLabelDefVal.getText()) + 10, 20);
 383             jLabelVarVal = new JLabel();
 384             jLabelVarVal.setBounds(new java.awt.Rectangle(11,133,100,20));
 385             jLabelVarVal.setText("Valid Usage");
 386             jLabelC_Name = new JLabel();
 387             jLabelC_Name.setText("C Name");
 388             jLabelC_Name.setBounds(new java.awt.Rectangle(11,9,140,20));
 389             jLabelTokenSpace = new JLabel();
 390             jLabelTokenSpace.setBounds(new java.awt.Rectangle(11,58,140,20));
 391             jLabelTokenSpace.setText("Token Space");
 392             jLabelDataType = new JLabel();
 393             jLabelDataType.setText("Data Type");
 394             jLabelDataType.setBounds(new java.awt.Rectangle(11,83,140,20));
 395             jLabelToken = new JLabel();
 396             jLabelToken.setText("Token Number");
 397             jLabelToken.setBounds(new java.awt.Rectangle(11,33,140,20));
 398             jLabelItemType = new JLabel();
 399             jLabelItemType.setText("Help Text");
 400             jLabelItemType.setBounds(new java.awt.Rectangle(11,108,140,20));
 401
 402
 403             jContentPane = new JPanel();
 404             jContentPane.setLayout(null);
 405             jContentPane.setPreferredSize(new java.awt.Dimension(479,375));
 406
 407             jContentPane.add(jLabelItemType, null);
 408             jContentPane.add(jLabelC_Name, null);
 409             jContentPane.add(jLabelTokenSpace, null);
 410             jContentPane.add(getJComboBoxTsGuid(), null);
 411             jContentPane.add(jLabelVarVal, null);
 412             jContentPane.add(getJTextFieldC_Name(), null);
 413             jContentPane.add(jLabelToken, null);
 414             jContentPane.add(getJTextFieldToken(), null);
 415             jContentPane.add(jLabelDataType, null);
 416             jContentPane.add(getJButtonOk(), null);
 417             jContentPane.add(getJButtonCancel(), null);
 418             jContentPane.add(getJComboBoxDataType(), null);
 419
 420             jStarLabel = new StarLabel();
 421             jStarLabel1 = new StarLabel();
 422             jStarLabel1.setBounds(new java.awt.Rectangle(2,8,10,20));
 423             jStarLabel2 = new StarLabel();
 424             jStarLabel3 = new StarLabel();
 425             jStarLabel4 = new StarLabel();
 426             jStarLabel.setLocation(new java.awt.Point(2,84));
 427             jStarLabel4.setLocation(new java.awt.Point(2, 109));
 428             jStarLabel2.setLocation(new java.awt.Point(2,33));
 429             jStarLabel3.setLocation(new java.awt.Point(2, 58));
 430             jStarLabel3.setSize(new java.awt.Dimension(8,20));
 431             jContentPane.add(jStarLabel2, null);
 432             jContentPane.add(jStarLabel3, null);
 433             jContentPane.add(jStarLabel, null);
 434             jContentPane.add(jStarLabel1, null);
 435             jContentPane.add(jStarLabel4, null);
 436             jContentPane.add(getJTextFieldHelp(), null);
 437             jContentPane.add(jLabelDefVal, null);
 438             jContentPane.add(getJTextFieldDefaultValue(), null);
 439             jContentPane.add(getJButtonAdd(), null);
 440             jContentPane.add(getJButtonRemove(), null);
 441             jContentPane.add(getJButtonClearAll(), null);
 442             jContentPane.add(getJScrollPane(), null);
 443             jContentPane.add(starLabel, null);
 444             jContentPane.add(getJCheckBoxFeatureFlag(), null);
 445             jContentPane.add(getJCheckBoxFixedAtBuild(), null);
 446             jContentPane.add(getJCheckBoxPatchInMod(), null);
 447             jContentPane.add(getJCheckBoxDyn(), null);
 448             jContentPane.add(getJCheckBoxDynEx(), null);
 449             jContentPane.add(getJScrollPaneArch(), null);
 450             jContentPane.add(getJScrollPaneMod(), null);
 451             jContentPane.add(jLabelSupMod, null);
 452             jContentPane.add(jLabelSupArch, null);
 453         }
 454         return jContentPane;
 455     }
 456
 457     /**
 458      This method initializes comboboxes
 459                         jContentPane.add(jLabelTokenSpace, null);
 460
 461      **/
 462     private void initFrame(SpdFileContents sfc) {
 463
 464         jComboBoxDataType.addItem("UINT8");
 465         jComboBoxDataType.addItem("UINT16");
 466         jComboBoxDataType.addItem("UINT32");
 467         jComboBoxDataType.addItem("UINT64");
 468         jComboBoxDataType.addItem("VOID*");
 469         jComboBoxDataType.addItem("BOOLEAN");
 470         jComboBoxDataType.setSelectedIndex(0);
 471
 472         Vector<String> vGuidCName = new Vector<String>();
 473         sfc.getSpdGuidDeclWithType(vGuidCName, "TOKEN_SPACE_GUID");
 474         for (int i = 0; i < vGuidCName.size(); ++i) {
 475             jComboBoxTsGuid.addItem(vGuidCName.get(i));
 476         }
 477     }
 478
 479     public void actionPerformed(ActionEvent arg0) {
 480
 481
 482             if (arg0.getSource() == jButtonOk) {
 483                 this.save();
 484                 this.dispose();
 485             }
 486             if (arg0.getSource() == jButtonCancel) {
 487                 this.dispose();
 488             }
 489
 490             if (arg0.getSource() == jButtonAdd) {
 491                 //ToDo: check before add
 492
 493                 boolean[] b = {jCheckBoxFeatureFlag.isSelected(), jCheckBoxFixedAtBuild.isSelected(), jCheckBoxPatchInMod.isSelected(), jCheckBoxDyn.isSelected(), jCheckBoxDynEx.isSelected()};
 494                 if (!checkValidUsage(b)) {
 495                     return;
 496                 }
 497                 String archList = vectorToString(iCheckBoxListArch.getAllCheckedItemsString());
 498                 if (archList.length() == 0) {
 499                     archList = null;
 500                 }
 501                 String modTypeList = vectorToString(iCheckBoxListMod.getAllCheckedItemsString());
 502                 if (modTypeList.length() == 0) {
 503                     modTypeList = null;
 504                 }
 505                 Object[] row = {jTextFieldC_Name.getText(), jTextFieldToken.getText(),
 506                                 jComboBoxTsGuid.getSelectedItem(), jComboBoxDataType.getSelectedItem(),
 507                                 jTextFieldDefaultValue.getText(), jTextFieldHelp.getText(),
 508                                 jCheckBoxFeatureFlag.isSelected(), jCheckBoxFixedAtBuild.isSelected(),
 509                                 jCheckBoxPatchInMod.isSelected(), jCheckBoxDyn.isSelected(), jCheckBoxDynEx.isSelected(),
 510                                 archList, modTypeList};
 511                 if (!dataValidation(row)) {
 512                     return;
 513                 }
 514
 515                 if (tokenCNameExisted(jTextFieldToken.getText(), jTextFieldC_Name.getText())) {
 516                     return;
 517                 }
 518
 519                 model.addRow(row);
 520                 jTable.changeSelection(model.getRowCount()-1, 0, false, false);
 521                 String usage = getValidUsage(jCheckBoxFeatureFlag.isSelected(), jCheckBoxFixedAtBuild.isSelected(), jCheckBoxPatchInMod.isSelected(), jCheckBoxDyn.isSelected(), jCheckBoxDynEx.isSelected());
 522                 if (usage.length() == 0) {
 523                     usage = null;
 524                 }
 525                 sfc.genSpdPcdDefinitions(row[0]+"", row[1]+"", row[3]+"", usage, row[2]+"", row[4]+"", row[5]+"", archList, modTypeList);
 526                 docConsole.setSaved(false);
 527             }
 528             //
 529             // remove selected line
 530             //
 531             if (arg0.getSource() == jButtonRemove) {
 532                 if (jTable.isEditing()){
 533                     jTable.getCellEditor().stopCellEditing();
 534                 }
 535                 int rowSelected = selectedRow;
 536                 if (rowSelected >= 0) {
 537                     model.removeRow(rowSelected);
 538                     sfc.removeSpdPcdDefinition(rowSelected);
 539                     docConsole.setSaved(false);
 540                 }
 541             }
 542
 543             if (arg0.getSource() == jButtonClearAll) {
 544                 if (model.getRowCount() == 0) {
 545                     return;
 546                 }
 547                 model.setRowCount(0);
 548                 sfc.removeSpdPcdDefinition();
 549                 docConsole.setSaved(false);
 550             }
 551
 552     }
 553
 554     protected void save() {
 555
 556     }
 557
 558     /**
 559      * This method initializes jComboBoxTsGuid
 560      *
 561      * @return javax.swing.JComboBox
 562      */
 563     private JComboBox getJComboBoxTsGuid() {
 564         if (jComboBoxTsGuid == null) {
 565             jComboBoxTsGuid = new JComboBox();
 566             jComboBoxTsGuid.setBounds(new java.awt.Rectangle(156,58,315,20));
 567
 568         }
 569         return jComboBoxTsGuid;
 570     }
 571
 572     /**
 573      * This method initializes jTextField
 574      *
 575      * @return javax.swing.JTextField
 576      */
 577     private JTextField getJTextFieldHelp() {
 578         if (jTextFieldHelp == null) {
 579             jTextFieldHelp = new JTextField();
 580             jTextFieldHelp.setBounds(new java.awt.Rectangle(156,108,317,20));
 581             jTextFieldHelp.setPreferredSize(new java.awt.Dimension(315,20));
 582         }
 583         return jTextFieldHelp;
 584     }
 585
 586     /**
 587      * This method initializes jTextFieldDefaultValue
 588      *
 589      * @return javax.swing.JTextField
 590      */
 591     private JTextField getJTextFieldDefaultValue() {
 592         if (jTextFieldDefaultValue == null) {
 593             jTextFieldDefaultValue = new JTextField();
 594             int xPos = jLabelDefVal.getX() + jLabelDefVal.getWidth();
 595             jTextFieldDefaultValue.setBounds(new java.awt.Rectangle(xPos,84,105,20));
 596             jTextFieldDefaultValue.setPreferredSize(new java.awt.Dimension(104,20));
 597         }
 598         return jTextFieldDefaultValue;
 599     }
 600
 601     /**
 602      * This method initializes jButtonAdd
 603      *
 604      * @return javax.swing.JButton
 605      */
 606     private JButton getJButtonAdd() {
 607         if (jButtonAdd == null) {
 608             jButtonAdd = new JButton();
 609             jButtonAdd.setBounds(new java.awt.Rectangle(195,277,71,20));
 610             jButtonAdd.setPreferredSize(new java.awt.Dimension(70,20));
 611             jButtonAdd.setText("Add");
 612             jButtonAdd.addActionListener(this);
 613         }
 614         return jButtonAdd;
 615
 616     }
 617
 618     /**
 619      * This method initializes jButtonRemove
 620      *
 621      * @return javax.swing.JButton
 622      */
 623     private JButton getJButtonRemove() {
 624         if (jButtonRemove == null) {
 625             jButtonRemove = new JButton();
 626             jButtonRemove.setBounds(new java.awt.Rectangle(278,277,81,20));
 627             jButtonRemove.setPreferredSize(new java.awt.Dimension(70,20));
 628             jButtonRemove.setText("Delete");
 629             jButtonRemove.addActionListener(this);
 630         }
 631         return jButtonRemove;
 632     }
 633
 634     /**
 635      * This method initializes jButtonClearAll
 636      *
 637      * @return javax.swing.JButton
 638      */
 639     private JButton getJButtonClearAll() {
 640         if (jButtonClearAll == null) {
 641             jButtonClearAll = new JButton();
 642             jButtonClearAll.setBounds(new java.awt.Rectangle(382,277,90,20));
 643             jButtonClearAll.setPreferredSize(new java.awt.Dimension(81,20));
 644             jButtonClearAll.setText("Clear All");
 645             jButtonClearAll.addActionListener(this);
 646         }
 647         return jButtonClearAll;
 648     }
 649
 650     public void componentResized(ComponentEvent arg0) {
 651         int intPreferredWidth = 500;
 652
 653         Tools.resizeComponentWidth(this.jTextFieldC_Name, this.getWidth(), intPreferredWidth);
 654         Tools.resizeComponentWidth(this.jTextFieldToken, this.getWidth(), intPreferredWidth);
 655         Tools.resizeComponentWidth(this.jComboBoxTsGuid, this.getWidth(), intPreferredWidth);
 656         Tools.resizeComponentWidth(this.jTextFieldDefaultValue, this.getWidth(), intPreferredWidth);
 657         Tools.resizeComponentWidth(this.jTextFieldHelp, this.getWidth(), intPreferredWidth);
 658         Tools.resizeComponentWidth(this.jScrollPane, this.getWidth(), intPreferredWidth);
 659
 660         Tools.resizeComponentWidth(this.jTextFieldDefaultValue, this.getWidth(), intPreferredWidth);
 661 //        relocateComponentX(this.jButtonClearAll, this.getWidth(), DataType.SPACE_TO_RIGHT_FOR_GENERATE_BUTTON);
 662 //        relocateComponentX(this.jButtonRemove, this.getWidth(), DataType.SPACE_TO_RIGHT_FOR_GENERATE_BUTTON);
 663 //        relocateComponentX(this.jButtonAdd, this.getWidth(), DataType.SPACE_TO_RIGHT_FOR_GENERATE_BUTTON);
 664     }
 665
 666     /**
 667      * This method initializes jScrollPane
 668      *
 669      * @return javax.swing.JScrollPane
 670      */
 671     private JScrollPane getJScrollPane() {
 672         if (jScrollPane == null) {
 673             jScrollPane = new JScrollPane();
 674             jScrollPane.setBounds(new java.awt.Rectangle(5,301,1473,259));
 675             jScrollPane.setViewportView(getJTable());
 676         }
 677         return jScrollPane;
 678     }
 679
 680     /**
 681      * This method initializes jTable
 682      *
 683      * @return javax.swing.JTable
 684      */
 685     private JTable getJTable() {
 686         if (jTable == null) {
 687             model = new CheckboxTableModel();
 688             jTable = new JTable(model);
 689             jTable.setRowHeight(20);
 690             jTable.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
 691             jTable.setSize(new Dimension(1000, 300));
 692
 693             model.addColumn("C_Name");
 694             model.addColumn("Token");
 695             model.addColumn("TokenSpace");
 696             model.addColumn("DatumType");
 697             model.addColumn("DefaultValue");
 698             model.addColumn("HelpText");
 699
 700             model.addColumn("FeatureFlag");
 701             model.addColumn("FixedAtBuild");
 702             model.addColumn("PatchableInModule");
 703             model.addColumn("Dynamic");
 704             model.addColumn("DynamicEx");
 705             model.addColumn("SupportedArch");
 706             model.addColumn("SupportedModule");
 707
 708             TableColumn column = jTable.getColumnModel().getColumn(0);
 709             column.setMinWidth(this.pcdCNameMinWidth);
 710             column = jTable.getColumnModel().getColumn(1);
 711             column.setMinWidth(this.pcdTokenMinWidth);
 712             column = jTable.getColumnModel().getColumn(2);
 713             column.setMinWidth(this.pcdTokenSpaceMinWidth);
 714             column = jTable.getColumnModel().getColumn(3);
 715             column.setMinWidth(this.datumTypeMinWidth);
 716             column = jTable.getColumnModel().getColumn(4);
 717             column.setMinWidth(this.defaultValueMinWidth);
 718             column = jTable.getColumnModel().getColumn(5);
 719             column.setMinWidth(this.helpTextMinWidth);
 720             column = jTable.getColumnModel().getColumn(6);
 721             column.setMinWidth(this.usageMinWidth);
 722             column = jTable.getColumnModel().getColumn(7);
 723             column.setMinWidth(this.usageMinWidth);
 724             column = jTable.getColumnModel().getColumn(8);
 725             column.setMinWidth(this.usageMinWidth);
 726             column = jTable.getColumnModel().getColumn(9);
 727             column.setMinWidth(this.usageMinWidth);
 728             column = jTable.getColumnModel().getColumn(10);
 729             column.setMinWidth(this.usageMinWidth);
 730             column = jTable.getColumnModel().getColumn(11);
 731             column.setMinWidth(this.supArchMinWidth);
 732             column = jTable.getColumnModel().getColumn(12);
 733             column.setMinWidth(this.supModMinWidth);
 734
 735             //ToDo: add a valid usage editor
 736
 737             JComboBox jComboBoxDataType = new JComboBox();
 738             jComboBoxDataType.addItem("UINT8");
 739             jComboBoxDataType.addItem("UINT16");
 740             jComboBoxDataType.addItem("UINT32");
 741             jComboBoxDataType.addItem("UINT64");
 742             jComboBoxDataType.addItem("VOID*");
 743             jComboBoxDataType.addItem("BOOLEAN");
 744             TableColumn dataTypeColumn = jTable.getColumnModel().getColumn(3);
 745             dataTypeColumn.setCellEditor(new DefaultCellEditor(jComboBoxDataType));
 746
 747             jTable.getColumnModel().getColumn(5).setCellEditor(new LongTextEditor());
 748
 749             Vector<String> vArch = new Vector<String>();
 750             vArch.add("IA32");
 751             vArch.add("X64");
 752             vArch.add("IPF");
 753             vArch.add("EBC");
 754             vArch.add("ARM");
 755             vArch.add("PPC");
 756             jTable.getColumnModel().getColumn(11).setCellEditor(new ListEditor(vArch));
 757
 758             Vector<String> vModule = new Vector<String>();
 759             vModule.add("BASE");
 760             vModule.add("SEC");
 761             vModule.add("PEI_CORE");
 762             vModule.add("PEIM");
 763             vModule.add("DXE_CORE");
 764             vModule.add("DXE_DRIVER");
 765             vModule.add("DXE_RUNTIME_DRIVER");
 766             vModule.add("DXE_SAL_DRIVER");
 767             vModule.add("DXE_SMM_DRIVER");
 768             vModule.add("UEFI_DRIVER");
 769             vModule.add("UEFI_APPLICATION");
 770             vModule.add("USER_DEFINED");
 771             jTable.getColumnModel().getColumn(12).setCellEditor(new ListEditor(vModule));
 772
 773             jTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
 774             jTable.getSelectionModel().addListSelectionListener(new ListSelectionListener(){
 775                 public void valueChanged(ListSelectionEvent e) {
 776                     if (e.getValueIsAdjusting()){
 777                         return;
 778                     }
 779                     ListSelectionModel lsm = (ListSelectionModel)e.getSource();
 780                     if (lsm.isSelectionEmpty()) {
 781                         return;
 782                     }
 783                     else{
 784                         selectedRow = lsm.getMinSelectionIndex();
 785                     }
 786                 }
 787             });
 788
 789             jTable.getModel().addTableModelListener(this);
 790         }
 791         return jTable;
 792     }
 793
 794     public void tableChanged(TableModelEvent arg0) {
 795         // TODO Auto-generated method stub
 796         int row = arg0.getFirstRow();
 797         int column = arg0.getColumn();
 798         TableModel m = (TableModel)arg0.getSource();
 799         if (arg0.getType() == TableModelEvent.UPDATE){
 800             String[] sa = new String[9];
 801             sfc.getSpdPcdDeclaration(sa, row);
 802             Object cellData = m.getValueAt(row, column);
 803             if (column < 6) {
 804
 805                 if (cellData == null) {
 806                     cellData = "";
 807                 }
 808                 if (cellData.equals(sa[column])) {
 809                     return;
 810                 }
 811                 if (cellData.toString().length() == 0 && sa[column] == null) {
 812                     return;
 813                 }
 814             }
 815
 816             String usage = getValidUsage(new Boolean(m.getValueAt(row, 6)+""), new Boolean(m.getValueAt(row, 7)+""), new Boolean(m.getValueAt(row, 8)+""), new Boolean(m.getValueAt(row, 9)+""), new Boolean(m.getValueAt(row, 10)+""));
 817             if (usage.length() == 0) {
 818                 JOptionPane.showMessageDialog(frame, "You must choose at least one usage for PCD entry.");
 819                 return;
 820             }
 821             if (column <= 10 && column >= 6) {
 822                 Vector<String> v = stringToVector(usage);
 823                 if (compareTwoVectors(v, stringToVector(sa[6]))) {
 824                     return;
 825                 }
 826                 if (v.contains("FEATURE_FLAG") && v.size() > 1) {
 827                     JOptionPane.showMessageDialog(frame, "Usage Feature Flag can NOT co-exist with others.");
 828                     return;
 829                 }
 830             }
 831
 832             if (column == 11) {
 833                 if (cellData == null) {
 834                     cellData = "";
 835                 }
 836                 if (cellData.equals(sa[7])) {
 837                     return;
 838                 }
 839                 if (cellData.toString().length() == 0 && sa[7] == null) {
 840                     return;
 841                 }
 842             }
 843
 844             if (column == 12) {
 845                 if (cellData == null) {
 846                     cellData = "";
 847                 }
 848                 if (cellData.equals(sa[8])) {
 849                     return;
 850                 }
 851                 if (cellData.toString().length() == 0 && sa[8] == null) {
 852                     return;
 853                 }
 854             }
 855             String cName = m.getValueAt(row, 0) + "";
 856             String token = m.getValueAt(row, 1) + "";
 857             String ts = m.getValueAt(row, 2) + "";
 858             String dataType = m.getValueAt(row, 3) + "";
 859             String defaultVal = m.getValueAt(row, 4) + "";
 860             String help = m.getValueAt(row, 5) + "";
 861
 862
 863             String archList = null;
 864             if (m.getValueAt(row, 11) != null){
 865                 archList = m.getValueAt(row, 11).toString();
 866             }
 867             String modTypeList = null;
 868             if (m.getValueAt(row, 12) != null) {
 869                 modTypeList = m.getValueAt(row, 12).toString();
 870             }
 871
 872             Object[] o = {cName, token, ts, dataType, defaultVal, help};
 873             if (!dataValidation(o)){
 874                 return;
 875             }
 876             docConsole.setSaved(false);
 877             sfc.updateSpdPcdDefinition(row, cName, token, dataType, usage, ts, defaultVal, help, archList, modTypeList);
 878         }
 879     }
 880
 881     /**
 882      * This method initializes jCheckBox
 883      *
 884      * @return javax.swing.JCheckBox
 885      */
 886     private JCheckBox getJCheckBoxFeatureFlag() {
 887         if (jCheckBoxFeatureFlag == null) {
 888             jCheckBoxFeatureFlag = new JCheckBox();
 889             jCheckBoxFeatureFlag.setBounds(new java.awt.Rectangle(156,161,100,21));
 890             jCheckBoxFeatureFlag.setText("Feature Flag");
 891             FontMetrics fm = jCheckBoxFeatureFlag.getFontMetrics(jCheckBoxFeatureFlag.getFont());
 892             jCheckBoxFeatureFlag.setSize(fm.stringWidth(jCheckBoxFeatureFlag.getText()) + 30, 20);
 893             jCheckBoxFeatureFlag.addItemListener(new java.awt.event.ItemListener() {
 894                 public void itemStateChanged(java.awt.event.ItemEvent e) {
 895                     if (jCheckBoxFeatureFlag.isSelected()) {
 896                         jCheckBoxPatchInMod.setSelected(false);
 897                         jCheckBoxFixedAtBuild.setSelected(false);
 898                         jCheckBoxDyn.setSelected(false);
 899                         jCheckBoxDynEx.setSelected(false);
 900                     }
 901                 }
 902             });
 903         }
 904         return jCheckBoxFeatureFlag;
 905     }
 906
 907     /**
 908      * This method initializes jCheckBox1
 909      *
 910      * @return javax.swing.JCheckBox
 911      */
 912     private JCheckBox getJCheckBoxFixedAtBuild() {
 913         if (jCheckBoxFixedAtBuild == null) {
 914             jCheckBoxFixedAtBuild = new JCheckBox();
 915
 916             jCheckBoxFixedAtBuild.setText("Fixed at Build");
 917             FontMetrics fm = jCheckBoxFixedAtBuild.getFontMetrics(jCheckBoxFixedAtBuild.getFont());
 918             jCheckBoxFixedAtBuild.setSize(fm.stringWidth(jCheckBoxFixedAtBuild.getText()) + 30, 20);
 919             jCheckBoxFixedAtBuild.addItemListener(new java.awt.event.ItemListener() {
 920                 public void itemStateChanged(java.awt.event.ItemEvent e) {
 921                     if (jCheckBoxFixedAtBuild.isSelected()) {
 922                         jCheckBoxFeatureFlag.setSelected(false);
 923                     }
 924                 }
 925             });
 926         }
 927         return jCheckBoxFixedAtBuild;
 928     }
 929
 930     /**
 931      * This method initializes jCheckBox2
 932      *
 933      * @return javax.swing.JCheckBox
 934      */
 935     private JCheckBox getJCheckBoxPatchInMod() {
 936         if (jCheckBoxPatchInMod == null) {
 937             jCheckBoxPatchInMod = new JCheckBox();
 938
 939             jCheckBoxPatchInMod.setBounds(new java.awt.Rectangle(156,133,154,20));
 940             jCheckBoxPatchInMod.setText("Patchable in Module");
 941             FontMetrics fm = jCheckBoxPatchInMod.getFontMetrics(jCheckBoxPatchInMod.getFont());
 942             jCheckBoxPatchInMod.setSize(fm.stringWidth(jCheckBoxPatchInMod.getText()) + 30, 20);
 943             jCheckBoxPatchInMod.addItemListener(new java.awt.event.ItemListener() {
 944                 public void itemStateChanged(java.awt.event.ItemEvent e) {
 945                     if (jCheckBoxPatchInMod.isSelected()) {
 946                         jCheckBoxFeatureFlag.setSelected(false);
 947                     }
 948                 }
 949             });
 950         }
 951         return jCheckBoxPatchInMod;
 952     }
 953
 954     /**
 955      * This method initializes jCheckBox3
 956      *
 957      * @return javax.swing.JCheckBox
 958      */
 959     private JCheckBox getJCheckBoxDyn() {
 960         if (jCheckBoxDyn == null) {
 961             jCheckBoxDyn = new JCheckBox();
 962
 963             jCheckBoxDyn.setText("Dynamic");
 964             FontMetrics fm = jCheckBoxDyn.getFontMetrics(jCheckBoxDyn.getFont());
 965             jCheckBoxDyn.setSize(fm.stringWidth(jCheckBoxDyn.getText()) + 30, 20);
 966             jCheckBoxDyn.addItemListener(new java.awt.event.ItemListener() {
 967                 public void itemStateChanged(java.awt.event.ItemEvent e) {
 968                     if (jCheckBoxDyn.isSelected()) {
 969                         jCheckBoxFeatureFlag.setSelected(false);
 970                     }
 971                 }
 972             });
 973         }
 974         return jCheckBoxDyn;
 975     }
 976
 977     /**
 978      * This method initializes jCheckBox4
 979      *
 980      * @return javax.swing.JCheckBox
 981      */
 982     private JCheckBox getJCheckBoxDynEx() {
 983         if (jCheckBoxDynEx == null) {
 984             jCheckBoxDynEx = new JCheckBox();
 985
 986             jCheckBoxDynEx.setText("DynamicEx");
 987             FontMetrics fm = jCheckBoxDynEx.getFontMetrics(jCheckBoxDynEx.getFont());
 988             jCheckBoxDynEx.setSize(fm.stringWidth(jCheckBoxDynEx.getText()) + 30, 20);
 989             jCheckBoxDynEx.addItemListener(new java.awt.event.ItemListener() {
 990                 public void itemStateChanged(java.awt.event.ItemEvent e) {
 991                     if (jCheckBoxDynEx.isSelected()) {
 992                         jCheckBoxFeatureFlag.setSelected(false);
 993                     }
 994                 }
 995             });
 996         }
 997         return jCheckBoxDynEx;
 998     }
 999
1000     private String getValidUsage(boolean ff, boolean fab, boolean pim, boolean d, boolean de) {
1001         String usage = "";
1002         if (ff){
1003             usage += "FEATURE_FLAG ";
1004         }
1005         if (fab){
1006             usage += "FIXED_AT_BUILD ";
1007         }
1008         if (pim){
1009             usage += "PATCHABLE_IN_MODULE ";
1010         }
1011         if (d){
1012             usage += "DYNAMIC ";
1013         }
1014         if (de){
1015             usage += "DYNAMIC_EX ";
1016         }
1017
1018         return usage.trim();
1019     }
1020
1021     private boolean tokenCNameExisted(String token, String cName) {
1022         Integer inputToken = Integer.decode(token);
1023
1024         for (int i = 0; i < jTable.getRowCount(); ++i) {
1025             if (jTable.getValueAt(i, 0).equals(cName)) {
1026                 JOptionPane.showMessageDialog(frame, "C_Name already existed in table.");
1027                 return true;
1028             }
1029             if (jTable.getValueAt(i, 1).equals(token)) {
1030                 JOptionPane.showMessageDialog(frame, "Token already existed in table.");
1031                 return true;
1032             }
1033             Integer tokenValue = Integer.decode(jTable.getValueAt(i, 1)+"");
1034             if (tokenValue.equals(inputToken)) {
1035                 JOptionPane.showMessageDialog(frame, "Same token value already existed in table.");
1036                 return true;
1037             }
1038
1039         }
1040         return false;
1041     }
1042
1043     private boolean checkValidUsage(boolean[] b) {
1044         if (!(b[0] || b[1] || b[2] || b[3] || b[4])){
1045             JOptionPane.showMessageDialog(frame, "You must specify at least one usage.");
1046             return false;
1047         }
1048         return true;
1049     }
1050     private boolean dataValidation(Object[] row) {
1051
1052         if (!DataValidation.isC_NameType(row[0].toString())) {
1053             JOptionPane.showMessageDialog(frame, "C_Name is NOT C_NameType.");
1054             return false;
1055         }
1056         if (!DataValidation.isHexDoubleWordDataType(row[1].toString()) &&
1057                         !DataValidation.isInt(row[1].toString(), Integer.MIN_VALUE, Integer.MAX_VALUE)) {
1058             JOptionPane.showMessageDialog(frame, "Token is NOT correct.");
1059             return false;
1060         }
1061         if (!DataValidation.isC_NameType(row[2].toString())) {
1062             JOptionPane.showMessageDialog(frame, "Token Space is NOT C_NameType");
1063             return false;
1064         }
1065         if (row[5].toString().length() == 0) {
1066             JOptionPane.showMessageDialog(frame, "HelpText could NOT be empty.");
1067             return false;
1068         }
1069         return true;
1070     }
1071
1072     /**
1073      * This method initializes jScrollPane1
1074      *
1075      * @return javax.swing.JScrollPane
1076      */
1077     private JScrollPane getJScrollPaneArch() {
1078         if (jScrollPaneArch == null) {
1079             jScrollPaneArch = new JScrollPane();
1080             jScrollPaneArch.setBounds(new java.awt.Rectangle(242,213,188,54));
1081             jScrollPaneArch.setViewportView(getICheckBoxListArch());
1082             jScrollPaneArch.setPreferredSize(new Dimension(188, 74));
1083         }
1084         return jScrollPaneArch;
1085     }
1086
1087     /**
1088      * This method initializes iCheckBoxList
1089      *
1090      * @return org.tianocore.frameworkwizard.common.ui.iCheckBoxList.ICheckBoxList
1091      */
1092     private ICheckBoxList getICheckBoxListArch() {
1093         if (iCheckBoxListArch == null) {
1094             iCheckBoxListArch = new ICheckBoxList();
1095             iCheckBoxListArch.setBounds(new Rectangle(197, 142, 188, 74));
1096             Vector<String> v = new Vector<String>();
1097             v.add("IA32");
1098             v.add("X64");
1099             v.add("IPF");
1100             v.add("EBC");
1101             v.add("ARM");
1102             v.add("PPC");
1103             iCheckBoxListArch.setAllItems(v);
1104         }
1105         return iCheckBoxListArch;
1106     }
1107
1108     /**
1109      * This method initializes jScrollPane2
1110      *
1111      * @return javax.swing.JScrollPane
1112      */
1113     private JScrollPane getJScrollPaneMod() {
1114         if (jScrollPaneMod == null) {
1115             jScrollPaneMod = new JScrollPane();
1116             jScrollPaneMod.setBounds(new java.awt.Rectangle(15,213,199,55));
1117             jScrollPaneMod.setViewportView(getICheckBoxListMod());
1118             jScrollPaneMod.setPreferredSize(new Dimension(170, 74));
1119         }
1120         return jScrollPaneMod;
1121     }
1122
1123     /**
1124      * This method initializes iCheckBoxList1
1125      *
1126      * @return org.tianocore.frameworkwizard.common.ui.iCheckBoxList.ICheckBoxList
1127      */
1128     private ICheckBoxList getICheckBoxListMod() {
1129         if (iCheckBoxListMod == null) {
1130             iCheckBoxListMod = new ICheckBoxList();
1131             iCheckBoxListMod.setBounds(new Rectangle(14, 142, 170, 74));
1132             Vector<String> v = new Vector<String>();
1133             v.add("BASE");
1134             v.add("SEC");
1135             v.add("PEI_CORE");
1136             v.add("PEIM");
1137             v.add("DXE_CORE");
1138             v.add("DXE_DRIVER");
1139             v.add("DXE_RUNTIME_DRIVER");
1140             v.add("DXE_SAL_DRIVER");
1141             v.add("DXE_SMM_DRIVER");
1142             v.add("UEFI_DRIVER");
1143             v.add("UEFI_APPLICATION");
1144             v.add("USER_DEFINED");
1145             iCheckBoxListMod.setAllItems(v);
1146         }
1147         return iCheckBoxListMod;
1148     }
1149
1150     protected String vectorToString(Vector<String> v) {
1151         if (v == null) {
1152             return null;
1153         }
1154         String s = " ";
1155         for (int i = 0; i < v.size(); ++i) {
1156             s += v.get(i);
1157             s += " ";
1158         }
1159         return s.trim();
1160     }
1161
1162     protected Vector<String> stringToVector(String s){
1163         Vector<String> v = new Vector<String>();
1164         if (s == null) {
1165             return v;
1166         }
1167         String[] sArray = s.split(" ");
1168
1169         for (int i = 0; i < sArray.length; ++i) {
1170             v.add(sArray[i]);
1171         }
1172         return v;
1173     }
1174
1175     private boolean compareTwoVectors(Vector v1, Vector v2) {
1176         if (v1.size() != v2.size()) {
1177             return false;
1178         }
1179         for (int i = 0; i < v1.size(); ++i) {
1180             if (!v2.contains(v1.get(i))) {
1181                 return false;
1182             }
1183         }
1184         return true;
1185     }
1186 } //  @jve:decl-index=0:visual-constraint="22,11"
1187
1188 class CheckboxTableModel extends DefaultTableModel {
1189     /**
1190      *
1191      */
1192     private static final long serialVersionUID = 1L;
1193
1194     public Class<?> getColumnClass (int c) {
1195         if (getValueAt(0, c) != null){
1196             return getValueAt(0, c).getClass();
1197         }
1198         return String.class;
1199     }
1200 }