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
 300         if (sfc.getSpdPkgDefsRdOnly().equals("true")) {
 301             JOptionPane.showMessageDialog(frame, "This is a read-only package. You will not be able to edit contents in table.");
 302         }
 303         initFrame();
 304
 305         if (sfc.getSpdPcdDefinitionCount() == 0) {
 306             return ;
 307         }
 308         String[][] saa = new String[sfc.getSpdPcdDefinitionCount()][8];
 309         String[][] usage = new String[sfc.getSpdPcdDefinitionCount()][5];
 310         Object[] rowData = new Object[13];
 311         sfc.getSpdPcdDefinitions(saa, usage);
 312         int i = 0;
 313         while (i < saa.length) {
 314
 315             for (int k = 0; k < 6; ++k) {
 316                 rowData[k] = saa[i][k];
 317             }
 318             for (int m = 6; m < 11; ++m) {
 319                 rowData[m] = new Boolean("false");
 320             }
 321             int j = 0;
 322             while (j < 5) {
 323                 if (usage[i][j] == null || usage[i][j].length()==0){
 324                     ++j;
 325                     continue;
 326                 }
 327                 if (usage[i][j].equals("FEATURE_FLAG")){
 328                     rowData[6] = new Boolean("true");
 329                 }
 330                 if (usage[i][j].equals("FIXED_AT_BUILD")){
 331                     rowData[7] = new Boolean("true");
 332                 }
 333                 if (usage[i][j].equals("PATCHABLE_IN_MODULE")){
 334                     rowData[8] = new Boolean("true");
 335                 }
 336                 if (usage[i][j].equals("DYNAMIC")){
 337                     rowData[9] = new Boolean("true");
 338                 }
 339                 if (usage[i][j].equals("DYNAMIC_EX")){
 340                     rowData[10] = new Boolean("true");
 341                 }
 342
 343                 ++j;
 344             }
 345
 346             rowData[11] = saa[i][6];
 347             rowData[12] = saa[i][7];
 348
 349             model.addRow(rowData);
 350
 351             i++;
 352         }
 353
 354     }
 355
 356     private JScrollPane getJContentPane(){
 357         if (topScrollPane == null){
 358             topScrollPane = new JScrollPane();
 359             topScrollPane.setSize(new java.awt.Dimension(482,451));
 360             topScrollPane.setViewportView(getJContentPane1());
 361         }
 362         return topScrollPane;
 363     }
 364     private JPanel getJContentPane1() {
 365                 if (jContentPane == null) {
 366
 367             jLabelSupArch = new JLabel();
 368             jLabelSupArch.setBounds(new java.awt.Rectangle(241,192,89,16));
 369             jLabelSupArch.setText("Supported Architectures");
 370             jLabelSupArch.setEnabled(true);
 371             FontMetrics fm = jLabelSupArch.getFontMetrics(jLabelSupArch.getFont());
 372             jLabelSupArch.setSize(fm.stringWidth(jLabelSupArch.getText()) + 10, 20);
 373             jLabelSupMod = new JLabel();
 374             jLabelSupMod.setBounds(new java.awt.Rectangle(15,193,103,16));
 375             jLabelSupMod.setText("Supported Module types");
 376             jLabelSupMod.setEnabled(true);
 377             fm = jLabelSupMod.getFontMetrics(jLabelSupMod.getFont());
 378             jLabelSupMod.setSize(fm.stringWidth(jLabelSupMod.getText()) + 10, 20);
 379             starLabel = new StarLabel();
 380             starLabel.setBounds(new java.awt.Rectangle(2,134,10,20));
 381             jLabelDefVal = new JLabel();
 382             jLabelDefVal.setBounds(new java.awt.Rectangle(277,84,80,20));
 383             jLabelDefVal.setText("Default Value");
 384             fm = jLabelDefVal.getFontMetrics(jLabelDefVal.getFont());
 385             jLabelDefVal.setSize(fm.stringWidth(jLabelDefVal.getText()) + 10, 20);
 386             jLabelVarVal = new JLabel();
 387             jLabelVarVal.setBounds(new java.awt.Rectangle(11,133,100,20));
 388             jLabelVarVal.setText("Valid Usage");
 389             jLabelC_Name = new JLabel();
 390             jLabelC_Name.setText("C Name");
 391             jLabelC_Name.setBounds(new java.awt.Rectangle(11,9,140,20));
 392             jLabelTokenSpace = new JLabel();
 393             jLabelTokenSpace.setBounds(new java.awt.Rectangle(11,58,140,20));
 394             jLabelTokenSpace.setText("Token Space");
 395             jLabelDataType = new JLabel();
 396             jLabelDataType.setText("Data Type");
 397             jLabelDataType.setBounds(new java.awt.Rectangle(11,83,140,20));
 398             jLabelToken = new JLabel();
 399             jLabelToken.setText("Token Number");
 400             jLabelToken.setBounds(new java.awt.Rectangle(11,33,140,20));
 401             jLabelItemType = new JLabel();
 402             jLabelItemType.setText("Help Text");
 403             jLabelItemType.setBounds(new java.awt.Rectangle(11,108,140,20));
 404
 405
 406             jContentPane = new JPanel();
 407             jContentPane.setLayout(null);
 408             jContentPane.setPreferredSize(new java.awt.Dimension(479,375));
 409
 410             jContentPane.add(jLabelItemType, null);
 411             jContentPane.add(jLabelC_Name, null);
 412             jContentPane.add(jLabelTokenSpace, null);
 413             jContentPane.add(getJComboBoxTsGuid(), null);
 414             jContentPane.add(jLabelVarVal, null);
 415             jContentPane.add(getJTextFieldC_Name(), null);
 416             jContentPane.add(jLabelToken, null);
 417             jContentPane.add(getJTextFieldToken(), null);
 418             jContentPane.add(jLabelDataType, null);
 419             jContentPane.add(getJButtonOk(), null);
 420             jContentPane.add(getJButtonCancel(), null);
 421             jContentPane.add(getJComboBoxDataType(), null);
 422
 423             jStarLabel = new StarLabel();
 424             jStarLabel1 = new StarLabel();
 425             jStarLabel1.setBounds(new java.awt.Rectangle(2,8,10,20));
 426             jStarLabel2 = new StarLabel();
 427             jStarLabel3 = new StarLabel();
 428             jStarLabel4 = new StarLabel();
 429             jStarLabel.setLocation(new java.awt.Point(2,84));
 430             jStarLabel4.setLocation(new java.awt.Point(2, 109));
 431             jStarLabel2.setLocation(new java.awt.Point(2,33));
 432             jStarLabel3.setLocation(new java.awt.Point(2, 58));
 433             jStarLabel3.setSize(new java.awt.Dimension(8,20));
 434             jContentPane.add(jStarLabel2, null);
 435             jContentPane.add(jStarLabel3, null);
 436             jContentPane.add(jStarLabel, null);
 437             jContentPane.add(jStarLabel1, null);
 438             jContentPane.add(jStarLabel4, null);
 439             jContentPane.add(getJTextFieldHelp(), null);
 440             jContentPane.add(jLabelDefVal, null);
 441             jContentPane.add(getJTextFieldDefaultValue(), null);
 442             jContentPane.add(getJButtonAdd(), null);
 443             jContentPane.add(getJButtonRemove(), null);
 444             jContentPane.add(getJButtonClearAll(), null);
 445             jContentPane.add(getJScrollPane(), null);
 446             jContentPane.add(starLabel, null);
 447             jContentPane.add(getJCheckBoxFeatureFlag(), null);
 448             jContentPane.add(getJCheckBoxFixedAtBuild(), null);
 449             jContentPane.add(getJCheckBoxPatchInMod(), null);
 450             jContentPane.add(getJCheckBoxDyn(), null);
 451             jContentPane.add(getJCheckBoxDynEx(), null);
 452             jContentPane.add(getJScrollPaneArch(), null);
 453             jContentPane.add(getJScrollPaneMod(), null);
 454             jContentPane.add(jLabelSupMod, null);
 455             jContentPane.add(jLabelSupArch, null);
 456         }
 457         return jContentPane;
 458     }
 459
 460     /**
 461      This method initializes comboboxes
 462                         jContentPane.add(jLabelTokenSpace, null);
 463
 464      **/
 465     private void initFrame() {
 466
 467         jComboBoxDataType.addItem("UINT8");
 468         jComboBoxDataType.addItem("UINT16");
 469         jComboBoxDataType.addItem("UINT32");
 470         jComboBoxDataType.addItem("UINT64");
 471         jComboBoxDataType.addItem("VOID*");
 472         jComboBoxDataType.addItem("BOOLEAN");
 473         jComboBoxDataType.setSelectedIndex(0);
 474
 475         Vector<String> vGuidCName = new Vector<String>();
 476         sfc.getSpdGuidDeclWithType(vGuidCName, "TOKEN_SPACE_GUID");
 477         for (int i = 0; i < vGuidCName.size(); ++i) {
 478             jComboBoxTsGuid.addItem(vGuidCName.get(i));
 479         }
 480
 481         boolean editable = true;
 482         if (sfc.getSpdPkgDefsRdOnly().equals("true")) {
 483             editable = false;
 484         }
 485
 486         jButtonAdd.setEnabled(editable);
 487         jButtonRemove.setEnabled(editable);
 488         jButtonClearAll.setEnabled(editable);
 489         jTable.setEnabled(editable);
 490     }
 491
 492     public void actionPerformed(ActionEvent arg0) {
 493
 494
 495             if (arg0.getSource() == jButtonOk) {
 496                 this.save();
 497                 this.dispose();
 498             }
 499             if (arg0.getSource() == jButtonCancel) {
 500                 this.dispose();
 501             }
 502
 503             if (arg0.getSource() == jButtonAdd) {
 504                 //ToDo: check before add
 505
 506                 boolean[] b = {jCheckBoxFeatureFlag.isSelected(), jCheckBoxFixedAtBuild.isSelected(), jCheckBoxPatchInMod.isSelected(), jCheckBoxDyn.isSelected(), jCheckBoxDynEx.isSelected()};
 507                 if (!checkValidUsage(b)) {
 508                     return;
 509                 }
 510                 String archList = vectorToString(iCheckBoxListArch.getAllCheckedItemsString());
 511                 if (archList.length() == 0) {
 512                     archList = null;
 513                 }
 514                 String modTypeList = vectorToString(iCheckBoxListMod.getAllCheckedItemsString());
 515                 if (modTypeList.length() == 0) {
 516                     modTypeList = null;
 517                 }
 518                 Object[] row = {jTextFieldC_Name.getText(), jTextFieldToken.getText(),
 519                                 jComboBoxTsGuid.getSelectedItem(), jComboBoxDataType.getSelectedItem(),
 520                                 jTextFieldDefaultValue.getText(), jTextFieldHelp.getText(),
 521                                 jCheckBoxFeatureFlag.isSelected(), jCheckBoxFixedAtBuild.isSelected(),
 522                                 jCheckBoxPatchInMod.isSelected(), jCheckBoxDyn.isSelected(), jCheckBoxDynEx.isSelected(),
 523                                 archList, modTypeList};
 524                 if (!dataValidation(row)) {
 525                     return;
 526                 }
 527
 528                 if (tokenCNameExisted(jTextFieldToken.getText(), jTextFieldC_Name.getText())) {
 529                     return;
 530                 }
 531
 532                 model.addRow(row);
 533                 jTable.changeSelection(model.getRowCount()-1, 0, false, false);
 534                 String usage = getValidUsage(jCheckBoxFeatureFlag.isSelected(), jCheckBoxFixedAtBuild.isSelected(), jCheckBoxPatchInMod.isSelected(), jCheckBoxDyn.isSelected(), jCheckBoxDynEx.isSelected());
 535                 if (usage.length() == 0) {
 536                     usage = null;
 537                 }
 538                 sfc.genSpdPcdDefinitions(row[0]+"", row[1]+"", row[3]+"", usage, row[2]+"", row[4]+"", row[5]+"", archList, modTypeList);
 539                 docConsole.setSaved(false);
 540             }
 541             //
 542             // remove selected line
 543             //
 544             if (arg0.getSource() == jButtonRemove) {
 545                 if (jTable.isEditing()){
 546                     jTable.getCellEditor().stopCellEditing();
 547                 }
 548                 int rowSelected = selectedRow;
 549                 if (rowSelected >= 0) {
 550                     model.removeRow(rowSelected);
 551                     sfc.removeSpdPcdDefinition(rowSelected);
 552                     docConsole.setSaved(false);
 553                 }
 554             }
 555
 556             if (arg0.getSource() == jButtonClearAll) {
 557                 if (model.getRowCount() == 0) {
 558                     return;
 559                 }
 560                 model.setRowCount(0);
 561                 sfc.removeSpdPcdDefinition();
 562                 docConsole.setSaved(false);
 563             }
 564
 565     }
 566
 567     protected void save() {
 568
 569     }
 570
 571     /**
 572      * This method initializes jComboBoxTsGuid
 573      *
 574      * @return javax.swing.JComboBox
 575      */
 576     private JComboBox getJComboBoxTsGuid() {
 577         if (jComboBoxTsGuid == null) {
 578             jComboBoxTsGuid = new JComboBox();
 579             jComboBoxTsGuid.setBounds(new java.awt.Rectangle(156,58,315,20));
 580
 581         }
 582         return jComboBoxTsGuid;
 583     }
 584
 585     /**
 586      * This method initializes jTextField
 587      *
 588      * @return javax.swing.JTextField
 589      */
 590     private JTextField getJTextFieldHelp() {
 591         if (jTextFieldHelp == null) {
 592             jTextFieldHelp = new JTextField();
 593             jTextFieldHelp.setBounds(new java.awt.Rectangle(156,108,317,20));
 594             jTextFieldHelp.setPreferredSize(new java.awt.Dimension(315,20));
 595         }
 596         return jTextFieldHelp;
 597     }
 598
 599     /**
 600      * This method initializes jTextFieldDefaultValue
 601      *
 602      * @return javax.swing.JTextField
 603      */
 604     private JTextField getJTextFieldDefaultValue() {
 605         if (jTextFieldDefaultValue == null) {
 606             jTextFieldDefaultValue = new JTextField();
 607             int xPos = jLabelDefVal.getX() + jLabelDefVal.getWidth();
 608             jTextFieldDefaultValue.setBounds(new java.awt.Rectangle(xPos,84,105,20));
 609             jTextFieldDefaultValue.setPreferredSize(new java.awt.Dimension(104,20));
 610         }
 611         return jTextFieldDefaultValue;
 612     }
 613
 614     /**
 615      * This method initializes jButtonAdd
 616      *
 617      * @return javax.swing.JButton
 618      */
 619     private JButton getJButtonAdd() {
 620         if (jButtonAdd == null) {
 621             jButtonAdd = new JButton();
 622             jButtonAdd.setBounds(new java.awt.Rectangle(195,277,71,20));
 623             jButtonAdd.setPreferredSize(new java.awt.Dimension(70,20));
 624             jButtonAdd.setText("Add");
 625             jButtonAdd.addActionListener(this);
 626         }
 627         return jButtonAdd;
 628
 629     }
 630
 631     /**
 632      * This method initializes jButtonRemove
 633      *
 634      * @return javax.swing.JButton
 635      */
 636     private JButton getJButtonRemove() {
 637         if (jButtonRemove == null) {
 638             jButtonRemove = new JButton();
 639             jButtonRemove.setBounds(new java.awt.Rectangle(278,277,81,20));
 640             jButtonRemove.setPreferredSize(new java.awt.Dimension(70,20));
 641             jButtonRemove.setText("Delete");
 642             jButtonRemove.addActionListener(this);
 643         }
 644         return jButtonRemove;
 645     }
 646
 647     /**
 648      * This method initializes jButtonClearAll
 649      *
 650      * @return javax.swing.JButton
 651      */
 652     private JButton getJButtonClearAll() {
 653         if (jButtonClearAll == null) {
 654             jButtonClearAll = new JButton();
 655             jButtonClearAll.setBounds(new java.awt.Rectangle(382,277,90,20));
 656             jButtonClearAll.setPreferredSize(new java.awt.Dimension(81,20));
 657             jButtonClearAll.setText("Clear All");
 658             jButtonClearAll.addActionListener(this);
 659         }
 660         return jButtonClearAll;
 661     }
 662
 663     public void componentResized(ComponentEvent arg0) {
 664         int intPreferredWidth = 500;
 665
 666         Tools.resizeComponentWidth(this.jTextFieldC_Name, this.getWidth(), intPreferredWidth);
 667         Tools.resizeComponentWidth(this.jTextFieldToken, this.getWidth(), intPreferredWidth);
 668         Tools.resizeComponentWidth(this.jComboBoxTsGuid, this.getWidth(), intPreferredWidth);
 669         Tools.resizeComponentWidth(this.jTextFieldDefaultValue, this.getWidth(), intPreferredWidth);
 670         Tools.resizeComponentWidth(this.jTextFieldHelp, this.getWidth(), intPreferredWidth);
 671         Tools.resizeComponentWidth(this.jScrollPane, this.getWidth(), intPreferredWidth);
 672
 673         Tools.resizeComponentWidth(this.jTextFieldDefaultValue, this.getWidth(), intPreferredWidth);
 674 //        relocateComponentX(this.jButtonClearAll, this.getWidth(), DataType.SPACE_TO_RIGHT_FOR_GENERATE_BUTTON);
 675 //        relocateComponentX(this.jButtonRemove, this.getWidth(), DataType.SPACE_TO_RIGHT_FOR_GENERATE_BUTTON);
 676 //        relocateComponentX(this.jButtonAdd, this.getWidth(), DataType.SPACE_TO_RIGHT_FOR_GENERATE_BUTTON);
 677     }
 678
 679     /**
 680      * This method initializes jScrollPane
 681      *
 682      * @return javax.swing.JScrollPane
 683      */
 684     private JScrollPane getJScrollPane() {
 685         if (jScrollPane == null) {
 686             jScrollPane = new JScrollPane();
 687             jScrollPane.setBounds(new java.awt.Rectangle(5,301,1473,259));
 688             jScrollPane.setViewportView(getJTable());
 689         }
 690         return jScrollPane;
 691     }
 692
 693     /**
 694      * This method initializes jTable
 695      *
 696      * @return javax.swing.JTable
 697      */
 698     private JTable getJTable() {
 699         if (jTable == null) {
 700             model = new CheckboxTableModel();
 701             jTable = new JTable(model);
 702             jTable.setRowHeight(20);
 703             jTable.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
 704             jTable.setSize(new Dimension(1000, 300));
 705
 706             model.addColumn("C_Name");
 707             model.addColumn("Token");
 708             model.addColumn("TokenSpace");
 709             model.addColumn("DatumType");
 710             model.addColumn("DefaultValue");
 711             model.addColumn("HelpText");
 712
 713             model.addColumn("FeatureFlag");
 714             model.addColumn("FixedAtBuild");
 715             model.addColumn("PatchableInModule");
 716             model.addColumn("Dynamic");
 717             model.addColumn("DynamicEx");
 718             model.addColumn("SupportedArch");
 719             model.addColumn("SupportedModule");
 720
 721             TableColumn column = jTable.getColumnModel().getColumn(0);
 722             column.setMinWidth(this.pcdCNameMinWidth);
 723             column = jTable.getColumnModel().getColumn(1);
 724             column.setMinWidth(this.pcdTokenMinWidth);
 725             column = jTable.getColumnModel().getColumn(2);
 726             column.setMinWidth(this.pcdTokenSpaceMinWidth);
 727             column = jTable.getColumnModel().getColumn(3);
 728             column.setMinWidth(this.datumTypeMinWidth);
 729             column = jTable.getColumnModel().getColumn(4);
 730             column.setMinWidth(this.defaultValueMinWidth);
 731             column = jTable.getColumnModel().getColumn(5);
 732             column.setMinWidth(this.helpTextMinWidth);
 733             column = jTable.getColumnModel().getColumn(6);
 734             column.setMinWidth(this.usageMinWidth);
 735             column = jTable.getColumnModel().getColumn(7);
 736             column.setMinWidth(this.usageMinWidth);
 737             column = jTable.getColumnModel().getColumn(8);
 738             column.setMinWidth(this.usageMinWidth);
 739             column = jTable.getColumnModel().getColumn(9);
 740             column.setMinWidth(this.usageMinWidth);
 741             column = jTable.getColumnModel().getColumn(10);
 742             column.setMinWidth(this.usageMinWidth);
 743             column = jTable.getColumnModel().getColumn(11);
 744             column.setMinWidth(this.supArchMinWidth);
 745             column = jTable.getColumnModel().getColumn(12);
 746             column.setMinWidth(this.supModMinWidth);
 747
 748             //ToDo: add a valid usage editor
 749
 750             JComboBox jComboBoxDataType = new JComboBox();
 751             jComboBoxDataType.addItem("UINT8");
 752             jComboBoxDataType.addItem("UINT16");
 753             jComboBoxDataType.addItem("UINT32");
 754             jComboBoxDataType.addItem("UINT64");
 755             jComboBoxDataType.addItem("VOID*");
 756             jComboBoxDataType.addItem("BOOLEAN");
 757             TableColumn dataTypeColumn = jTable.getColumnModel().getColumn(3);
 758             dataTypeColumn.setCellEditor(new DefaultCellEditor(jComboBoxDataType));
 759
 760             jTable.getColumnModel().getColumn(5).setCellEditor(new LongTextEditor());
 761
 762             Vector<String> vArch = new Vector<String>();
 763             vArch.add("IA32");
 764             vArch.add("X64");
 765             vArch.add("IPF");
 766             vArch.add("EBC");
 767             vArch.add("ARM");
 768             vArch.add("PPC");
 769             jTable.getColumnModel().getColumn(11).setCellEditor(new ListEditor(vArch));
 770
 771             Vector<String> vModule = new Vector<String>();
 772             vModule.add("BASE");
 773             vModule.add("SEC");
 774             vModule.add("PEI_CORE");
 775             vModule.add("PEIM");
 776             vModule.add("DXE_CORE");
 777             vModule.add("DXE_DRIVER");
 778             vModule.add("DXE_RUNTIME_DRIVER");
 779             vModule.add("DXE_SAL_DRIVER");
 780             vModule.add("DXE_SMM_DRIVER");
 781             vModule.add("UEFI_DRIVER");
 782             vModule.add("UEFI_APPLICATION");
 783             vModule.add("USER_DEFINED");
 784             jTable.getColumnModel().getColumn(12).setCellEditor(new ListEditor(vModule));
 785
 786             jTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
 787             jTable.getSelectionModel().addListSelectionListener(new ListSelectionListener(){
 788                 public void valueChanged(ListSelectionEvent e) {
 789                     if (e.getValueIsAdjusting()){
 790                         return;
 791                     }
 792                     ListSelectionModel lsm = (ListSelectionModel)e.getSource();
 793                     if (lsm.isSelectionEmpty()) {
 794                         return;
 795                     }
 796                     else{
 797                         selectedRow = lsm.getMinSelectionIndex();
 798                     }
 799                 }
 800             });
 801
 802             jTable.getModel().addTableModelListener(this);
 803         }
 804         return jTable;
 805     }
 806
 807     public void tableChanged(TableModelEvent arg0) {
 808         // TODO Auto-generated method stub
 809         int row = arg0.getFirstRow();
 810         int column = arg0.getColumn();
 811         TableModel m = (TableModel)arg0.getSource();
 812         if (arg0.getType() == TableModelEvent.UPDATE){
 813             String[] sa = new String[9];
 814             sfc.getSpdPcdDeclaration(sa, row);
 815             Object cellData = m.getValueAt(row, column);
 816             if (column < 6) {
 817
 818                 if (cellData == null) {
 819                     cellData = "";
 820                 }
 821                 if (cellData.equals(sa[column])) {
 822                     return;
 823                 }
 824                 if (cellData.toString().length() == 0 && sa[column] == null) {
 825                     return;
 826                 }
 827             }
 828
 829             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)+""));
 830             if (usage.length() == 0) {
 831                 JOptionPane.showMessageDialog(frame, "You must choose at least one usage for PCD entry.");
 832                 return;
 833             }
 834             if (column <= 10 && column >= 6) {
 835                 Vector<String> v = stringToVector(usage);
 836                 if (compareTwoVectors(v, stringToVector(sa[6]))) {
 837                     return;
 838                 }
 839                 if (v.contains("FEATURE_FLAG") && v.size() > 1) {
 840                     JOptionPane.showMessageDialog(frame, "Usage Feature Flag can NOT co-exist with others.");
 841                     return;
 842                 }
 843             }
 844
 845             if (column == 11) {
 846                 if (cellData == null) {
 847                     cellData = "";
 848                 }
 849                 if (cellData.equals(sa[7])) {
 850                     return;
 851                 }
 852                 if (cellData.toString().length() == 0 && sa[7] == null) {
 853                     return;
 854                 }
 855             }
 856
 857             if (column == 12) {
 858                 if (cellData == null) {
 859                     cellData = "";
 860                 }
 861                 if (cellData.equals(sa[8])) {
 862                     return;
 863                 }
 864                 if (cellData.toString().length() == 0 && sa[8] == null) {
 865                     return;
 866                 }
 867             }
 868             String cName = m.getValueAt(row, 0) + "";
 869             String token = m.getValueAt(row, 1) + "";
 870             String ts = m.getValueAt(row, 2) + "";
 871             String dataType = m.getValueAt(row, 3) + "";
 872             String defaultVal = m.getValueAt(row, 4) + "";
 873             String help = m.getValueAt(row, 5) + "";
 874
 875
 876             String archList = null;
 877             if (m.getValueAt(row, 11) != null){
 878                 archList = m.getValueAt(row, 11).toString();
 879             }
 880             String modTypeList = null;
 881             if (m.getValueAt(row, 12) != null) {
 882                 modTypeList = m.getValueAt(row, 12).toString();
 883             }
 884
 885             Object[] o = {cName, token, ts, dataType, defaultVal, help};
 886             if (!dataValidation(o)){
 887                 return;
 888             }
 889             docConsole.setSaved(false);
 890             sfc.updateSpdPcdDefinition(row, cName, token, dataType, usage, ts, defaultVal, help, archList, modTypeList);
 891         }
 892     }
 893
 894     /**
 895      * This method initializes jCheckBox
 896      *
 897      * @return javax.swing.JCheckBox
 898      */
 899     private JCheckBox getJCheckBoxFeatureFlag() {
 900         if (jCheckBoxFeatureFlag == null) {
 901             jCheckBoxFeatureFlag = new JCheckBox();
 902             jCheckBoxFeatureFlag.setBounds(new java.awt.Rectangle(156,161,100,21));
 903             jCheckBoxFeatureFlag.setText("Feature Flag");
 904             FontMetrics fm = jCheckBoxFeatureFlag.getFontMetrics(jCheckBoxFeatureFlag.getFont());
 905             jCheckBoxFeatureFlag.setSize(fm.stringWidth(jCheckBoxFeatureFlag.getText()) + 30, 20);
 906             jCheckBoxFeatureFlag.addItemListener(new java.awt.event.ItemListener() {
 907                 public void itemStateChanged(java.awt.event.ItemEvent e) {
 908                     if (jCheckBoxFeatureFlag.isSelected()) {
 909                         jCheckBoxPatchInMod.setSelected(false);
 910                         jCheckBoxFixedAtBuild.setSelected(false);
 911                         jCheckBoxDyn.setSelected(false);
 912                         jCheckBoxDynEx.setSelected(false);
 913                     }
 914                 }
 915             });
 916         }
 917         return jCheckBoxFeatureFlag;
 918     }
 919
 920     /**
 921      * This method initializes jCheckBox1
 922      *
 923      * @return javax.swing.JCheckBox
 924      */
 925     private JCheckBox getJCheckBoxFixedAtBuild() {
 926         if (jCheckBoxFixedAtBuild == null) {
 927             jCheckBoxFixedAtBuild = new JCheckBox();
 928
 929             jCheckBoxFixedAtBuild.setText("Fixed at Build");
 930             FontMetrics fm = jCheckBoxFixedAtBuild.getFontMetrics(jCheckBoxFixedAtBuild.getFont());
 931             jCheckBoxFixedAtBuild.setSize(fm.stringWidth(jCheckBoxFixedAtBuild.getText()) + 30, 20);
 932             jCheckBoxFixedAtBuild.addItemListener(new java.awt.event.ItemListener() {
 933                 public void itemStateChanged(java.awt.event.ItemEvent e) {
 934                     if (jCheckBoxFixedAtBuild.isSelected()) {
 935                         jCheckBoxFeatureFlag.setSelected(false);
 936                     }
 937                 }
 938             });
 939         }
 940         return jCheckBoxFixedAtBuild;
 941     }
 942
 943     /**
 944      * This method initializes jCheckBox2
 945      *
 946      * @return javax.swing.JCheckBox
 947      */
 948     private JCheckBox getJCheckBoxPatchInMod() {
 949         if (jCheckBoxPatchInMod == null) {
 950             jCheckBoxPatchInMod = new JCheckBox();
 951
 952             jCheckBoxPatchInMod.setBounds(new java.awt.Rectangle(156,133,154,20));
 953             jCheckBoxPatchInMod.setText("Patchable in Module");
 954             FontMetrics fm = jCheckBoxPatchInMod.getFontMetrics(jCheckBoxPatchInMod.getFont());
 955             jCheckBoxPatchInMod.setSize(fm.stringWidth(jCheckBoxPatchInMod.getText()) + 30, 20);
 956             jCheckBoxPatchInMod.addItemListener(new java.awt.event.ItemListener() {
 957                 public void itemStateChanged(java.awt.event.ItemEvent e) {
 958                     if (jCheckBoxPatchInMod.isSelected()) {
 959                         jCheckBoxFeatureFlag.setSelected(false);
 960                     }
 961                 }
 962             });
 963         }
 964         return jCheckBoxPatchInMod;
 965     }
 966
 967     /**
 968      * This method initializes jCheckBox3
 969      *
 970      * @return javax.swing.JCheckBox
 971      */
 972     private JCheckBox getJCheckBoxDyn() {
 973         if (jCheckBoxDyn == null) {
 974             jCheckBoxDyn = new JCheckBox();
 975
 976             jCheckBoxDyn.setText("Dynamic");
 977             FontMetrics fm = jCheckBoxDyn.getFontMetrics(jCheckBoxDyn.getFont());
 978             jCheckBoxDyn.setSize(fm.stringWidth(jCheckBoxDyn.getText()) + 30, 20);
 979             jCheckBoxDyn.addItemListener(new java.awt.event.ItemListener() {
 980                 public void itemStateChanged(java.awt.event.ItemEvent e) {
 981                     if (jCheckBoxDyn.isSelected()) {
 982                         jCheckBoxFeatureFlag.setSelected(false);
 983                     }
 984                 }
 985             });
 986         }
 987         return jCheckBoxDyn;
 988     }
 989
 990     /**
 991      * This method initializes jCheckBox4
 992      *
 993      * @return javax.swing.JCheckBox
 994      */
 995     private JCheckBox getJCheckBoxDynEx() {
 996         if (jCheckBoxDynEx == null) {
 997             jCheckBoxDynEx = new JCheckBox();
 998
 999             jCheckBoxDynEx.setText("DynamicEx");
1000             FontMetrics fm = jCheckBoxDynEx.getFontMetrics(jCheckBoxDynEx.getFont());
1001             jCheckBoxDynEx.setSize(fm.stringWidth(jCheckBoxDynEx.getText()) + 30, 20);
1002             jCheckBoxDynEx.addItemListener(new java.awt.event.ItemListener() {
1003                 public void itemStateChanged(java.awt.event.ItemEvent e) {
1004                     if (jCheckBoxDynEx.isSelected()) {
1005                         jCheckBoxFeatureFlag.setSelected(false);
1006                     }
1007                 }
1008             });
1009         }
1010         return jCheckBoxDynEx;
1011     }
1012
1013     private String getValidUsage(boolean ff, boolean fab, boolean pim, boolean d, boolean de) {
1014         String usage = "";
1015         if (ff){
1016             usage += "FEATURE_FLAG ";
1017         }
1018         if (fab){
1019             usage += "FIXED_AT_BUILD ";
1020         }
1021         if (pim){
1022             usage += "PATCHABLE_IN_MODULE ";
1023         }
1024         if (d){
1025             usage += "DYNAMIC ";
1026         }
1027         if (de){
1028             usage += "DYNAMIC_EX ";
1029         }
1030
1031         return usage.trim();
1032     }
1033
1034     private boolean tokenCNameExisted(String token, String cName) {
1035         Integer inputToken = Integer.decode(token);
1036
1037         for (int i = 0; i < jTable.getRowCount(); ++i) {
1038             if (jTable.getValueAt(i, 0).equals(cName)) {
1039                 JOptionPane.showMessageDialog(frame, "C_Name already existed in table.");
1040                 return true;
1041             }
1042             if (jTable.getValueAt(i, 1).equals(token)) {
1043                 JOptionPane.showMessageDialog(frame, "Token already existed in table.");
1044                 return true;
1045             }
1046             Integer tokenValue = Integer.decode(jTable.getValueAt(i, 1)+"");
1047             if (tokenValue.equals(inputToken)) {
1048                 JOptionPane.showMessageDialog(frame, "Same token value already existed in table.");
1049                 return true;
1050             }
1051
1052         }
1053         return false;
1054     }
1055
1056     private boolean checkValidUsage(boolean[] b) {
1057         if (!(b[0] || b[1] || b[2] || b[3] || b[4])){
1058             JOptionPane.showMessageDialog(frame, "You must specify at least one usage.");
1059             return false;
1060         }
1061         return true;
1062     }
1063     private boolean dataValidation(Object[] row) {
1064
1065         if (!DataValidation.isC_NameType(row[0].toString())) {
1066             JOptionPane.showMessageDialog(frame, "C_Name is NOT C_NameType.");
1067             return false;
1068         }
1069         if (!DataValidation.isHexDoubleWordDataType(row[1].toString()) &&
1070                         !DataValidation.isInt(row[1].toString(), Integer.MIN_VALUE, Integer.MAX_VALUE)) {
1071             JOptionPane.showMessageDialog(frame, "Token is NOT correct.");
1072             return false;
1073         }
1074         if (!DataValidation.isC_NameType(row[2].toString())) {
1075             JOptionPane.showMessageDialog(frame, "Token Space is NOT C_NameType");
1076             return false;
1077         }
1078         if (row[5].toString().length() == 0) {
1079             JOptionPane.showMessageDialog(frame, "HelpText could NOT be empty.");
1080             return false;
1081         }
1082         return true;
1083     }
1084
1085     /**
1086      * This method initializes jScrollPane1
1087      *
1088      * @return javax.swing.JScrollPane
1089      */
1090     private JScrollPane getJScrollPaneArch() {
1091         if (jScrollPaneArch == null) {
1092             jScrollPaneArch = new JScrollPane();
1093             jScrollPaneArch.setBounds(new java.awt.Rectangle(242,213,188,54));
1094             jScrollPaneArch.setViewportView(getICheckBoxListArch());
1095             jScrollPaneArch.setPreferredSize(new Dimension(188, 74));
1096         }
1097         return jScrollPaneArch;
1098     }
1099
1100     /**
1101      * This method initializes iCheckBoxList
1102      *
1103      * @return org.tianocore.frameworkwizard.common.ui.iCheckBoxList.ICheckBoxList
1104      */
1105     private ICheckBoxList getICheckBoxListArch() {
1106         if (iCheckBoxListArch == null) {
1107             iCheckBoxListArch = new ICheckBoxList();
1108             iCheckBoxListArch.setBounds(new Rectangle(197, 142, 188, 74));
1109             Vector<String> v = new Vector<String>();
1110             v.add("IA32");
1111             v.add("X64");
1112             v.add("IPF");
1113             v.add("EBC");
1114             v.add("ARM");
1115             v.add("PPC");
1116             iCheckBoxListArch.setAllItems(v);
1117         }
1118         return iCheckBoxListArch;
1119     }
1120
1121     /**
1122      * This method initializes jScrollPane2
1123      *
1124      * @return javax.swing.JScrollPane
1125      */
1126     private JScrollPane getJScrollPaneMod() {
1127         if (jScrollPaneMod == null) {
1128             jScrollPaneMod = new JScrollPane();
1129             jScrollPaneMod.setBounds(new java.awt.Rectangle(15,213,199,55));
1130             jScrollPaneMod.setViewportView(getICheckBoxListMod());
1131             jScrollPaneMod.setPreferredSize(new Dimension(170, 74));
1132         }
1133         return jScrollPaneMod;
1134     }
1135
1136     /**
1137      * This method initializes iCheckBoxList1
1138      *
1139      * @return org.tianocore.frameworkwizard.common.ui.iCheckBoxList.ICheckBoxList
1140      */
1141     private ICheckBoxList getICheckBoxListMod() {
1142         if (iCheckBoxListMod == null) {
1143             iCheckBoxListMod = new ICheckBoxList();
1144             iCheckBoxListMod.setBounds(new Rectangle(14, 142, 170, 74));
1145             Vector<String> v = new Vector<String>();
1146             v.add("BASE");
1147             v.add("SEC");
1148             v.add("PEI_CORE");
1149             v.add("PEIM");
1150             v.add("DXE_CORE");
1151             v.add("DXE_DRIVER");
1152             v.add("DXE_RUNTIME_DRIVER");
1153             v.add("DXE_SAL_DRIVER");
1154             v.add("DXE_SMM_DRIVER");
1155             v.add("UEFI_DRIVER");
1156             v.add("UEFI_APPLICATION");
1157             v.add("USER_DEFINED");
1158             iCheckBoxListMod.setAllItems(v);
1159         }
1160         return iCheckBoxListMod;
1161     }
1162
1163     protected String vectorToString(Vector<String> v) {
1164         if (v == null) {
1165             return null;
1166         }
1167         String s = " ";
1168         for (int i = 0; i < v.size(); ++i) {
1169             s += v.get(i);
1170             s += " ";
1171         }
1172         return s.trim();
1173     }
1174
1175     protected Vector<String> stringToVector(String s){
1176         Vector<String> v = new Vector<String>();
1177         if (s == null) {
1178             return v;
1179         }
1180         String[] sArray = s.split(" ");
1181
1182         for (int i = 0; i < sArray.length; ++i) {
1183             v.add(sArray[i]);
1184         }
1185         return v;
1186     }
1187
1188     private boolean compareTwoVectors(Vector v1, Vector v2) {
1189         if (v1.size() != v2.size()) {
1190             return false;
1191         }
1192         for (int i = 0; i < v1.size(); ++i) {
1193             if (!v2.contains(v1.get(i))) {
1194                 return false;
1195             }
1196         }
1197         return true;
1198     }
1199 } //  @jve:decl-index=0:visual-constraint="22,11"
1200
1201 class CheckboxTableModel extends DefaultTableModel {
1202     /**
1203      *
1204      */
1205     private static final long serialVersionUID = 1L;
1206
1207     public Class<?> getColumnClass (int c) {
1208         if (getValueAt(0, c) != null){
1209             return getValueAt(0, c).getClass();
1210         }
1211         return String.class;
1212     }
1213 }