Tools/Source/FrameworkWizard/src/org/tianocore/frameworkwizard/platform/ui/FpdPlatformDefs.java

   1 /** @file
   2  Java class FpdPlatformDefs is GUI for Flash element operation in 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.platform.ui;
  14
  15 import java.awt.BorderLayout;
  16 import javax.swing.JPanel;
  17
  18 import javax.swing.JFrame;
  19 import javax.swing.JTabbedPane;
  20 import javax.swing.JButton;
  21 import javax.swing.ListSelectionModel;
  22
  23 import org.tianocore.PlatformSurfaceAreaDocument;
  24 import org.tianocore.frameworkwizard.common.Identifications.OpeningPlatformType;
  25 import org.tianocore.frameworkwizard.common.ui.IInternalFrame;
  26
  27 import javax.swing.JCheckBox;
  28 import javax.swing.JOptionPane;
  29 import javax.swing.JTextField;
  30 import javax.swing.JLabel;
  31 import javax.swing.JScrollPane;
  32 import javax.swing.JTable;
  33 import javax.swing.event.InternalFrameAdapter;
  34 import javax.swing.event.InternalFrameEvent;
  35 //import javax.swing.event.ListSelectionEvent;
  36 //import javax.swing.event.ListSelectionListener;
  37 import javax.swing.event.TableModelEvent;
  38 import javax.swing.event.TableModelListener;
  39 import javax.swing.table.DefaultTableModel;
  40 import javax.swing.table.TableModel;
  41 import javax.swing.JComboBox;
  42 import java.awt.Dimension;
  43 import java.util.Vector;
  44
  45 public class FpdPlatformDefs extends IInternalFrame {
  46
  47     private final int dialogWidth = 600;
  48
  49     private final int oneRowHeight = 20;
  50
  51     private final int twoRowHeight = 40;
  52
  53 //    private final int threeRowHeight = 60;
  54
  55     private final int fourRowHeight = 80;
  56
  57     private final int sepHeight = 6;
  58
  59 //    private final int sepWidth = 10;
  60
  61     private final int buttonWidth = 90;
  62
  63     private final int rowOne = 12;
  64
  65     private final int rowTwo = rowOne + oneRowHeight + sepHeight;
  66
  67     private final int rowThree = rowTwo + oneRowHeight + sepHeight;
  68
  69     private final int rowFour = rowThree + oneRowHeight + sepHeight;
  70
  71     private final int rowFive = rowFour + fourRowHeight + sepHeight;
  72
  73     private final int rowSix = rowFive + oneRowHeight + sepHeight;
  74
  75     private final int rowSeven = rowSix + oneRowHeight + sepHeight;
  76
  77     private final int rowEight = rowSeven + oneRowHeight + sepHeight;
  78
  79     private final int rowNine = rowEight + oneRowHeight + sepHeight;
  80
  81     private final int rowTen = rowNine + fourRowHeight + sepHeight + sepHeight;
  82
  83     private final int rowEleven = rowTen + oneRowHeight + sepHeight;
  84
  85     private final int rowTwelve = rowEleven + oneRowHeight + sepHeight;
  86
  87     private final int dialogHeight = rowTwelve + twoRowHeight;
  88
  89     private final int labelColumn = 12;
  90
  91     private final int valueColumn = 168;
  92
  93     private final int labelWidth = 155;
  94
  95     private final int valueWidth = 320;
  96
  97     private final int valueCenter = valueColumn + (valueWidth / 2);
  98
  99     private final int tableHeight = fourRowHeight;
 100
 101     private final int tableWidth = valueWidth;
 102
 103     /**
 104      *
 105      */
 106     private static final long serialVersionUID = 1L;
 107
 108     static JFrame frame;
 109
 110     private JPanel jContentPane = null;
 111
 112     private JTabbedPane jTabbedPane = null;
 113
 114     private TargetTableModel buildTargetTableModel = null;
 115
 116     private SkuInfoTableModel skuInfoTableModel = null;
 117
 118     private OpeningPlatformType docConsole = null;
 119
 120     private FpdFileContents ffc = null;
 121
 122     private JPanel jPanelGeneralTab = null;
 123
 124     private JPanel jPanelGeneralContainer = null;
 125
 126     private JLabel jLabelSupArch = null;
 127
 128     private JCheckBox jCheckBoxIa32 = null;
 129
 130     private JCheckBox jCheckBoxX64 = null;
 131
 132     private JCheckBox jCheckBoxIpf = null;
 133
 134     private JComboBox jComboBoxInterDir = null;
 135
 136     private JTable jTableBuildTargets = null;
 137
 138     private JPanel jArchitectureSelections = null;
 139
 140     private JLabel jLabelBuildTargets = null;
 141
 142     private JTextField jTextFieldBuildTarget = null;
 143
 144     private JButton jButtonAddBuildTarget = null;
 145
 146     private JButton jButtonDelBuildTarget = null;
 147
 148     private JScrollPane jScrollPaneBuildTargets = null;
 149
 150     private JScrollPane jScrollPaneSkuInfo = null;
 151
 152     private JTable jTableSkuInfo = null;
 153
 154     private JCheckBox jCheckBoxEbc = null;
 155
 156     private JCheckBox jCheckBoxArm = null;
 157
 158     private JCheckBox jCheckBoxPpc = null;
 159
 160     private JLabel jLabelSkuInfo = null;
 161
 162     private JLabel jLabelSkuId = null;
 163
 164     private JTextField jTextFieldSkuId = null;
 165
 166     private JLabel jLabelSkuName = null;
 167
 168     private JTextField jTextFieldSkuName = null;
 169
 170     private JButton jButtonSkuAdd = null;
 171
 172     private JButton jButtonSkuDel = null;
 173
 174     private JLabel jLabelIntermediateDirs = null;
 175
 176     private JLabel jLabelOutputDir = null;
 177
 178     private JTextField jTextFieldOutputDir = null;
 179
 180     private JLabel jLabelOutputInfo = null;
 181
 182     private int selectedRow = -1;
 183
 184     public FpdPlatformDefs() {
 185         super();
 186         initialize();
 187         this.setBounds(new java.awt.Rectangle(0, 0, 500, 370));
 188         this.setVisible(true);
 189     }
 190
 191     public FpdPlatformDefs(PlatformSurfaceAreaDocument.PlatformSurfaceArea fpd) {
 192         this();
 193         ffc = new FpdFileContents(fpd);
 194         init(ffc);
 195     }
 196
 197     public FpdPlatformDefs(OpeningPlatformType opt) {
 198         this(opt.getXmlFpd());
 199         docConsole = opt;
 200     }
 201
 202     /**
 203      * This method initializes jTabbedPane
 204      *
 205      * @return javax.swing.JTabbedPane
 206      */
 207     private JTabbedPane getJTabbedPane() {
 208         if (jTabbedPane == null) {
 209             jTabbedPane = new JTabbedPane();
 210             jTabbedPane.addTab("General", null, getJPanelGeneralTab(), null);
 211         }
 212         return jTabbedPane;
 213     }
 214
 215     /**
 216      * This method initializes this
 217      *
 218      * @return void
 219      */
 220     private void initialize() {
 221         this.setSize(dialogWidth, dialogHeight);
 222         this.setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_CLOSE);
 223         this.setTitle("FPD Platform Definitions");
 224         this.setContentPane(getJContentPane());
 225         this.addInternalFrameListener(new InternalFrameAdapter() {
 226             public void internalFrameDeactivated(InternalFrameEvent e) {
 227                 if (jTableBuildTargets.isEditing()) {
 228                     jTableBuildTargets.getCellEditor().stopCellEditing();
 229                 }
 230                 if (jTableSkuInfo.isEditing()) {
 231                     jTableSkuInfo.getCellEditor().stopCellEditing();
 232                 }
 233
 234             }
 235         });
 236     }
 237
 238     private void init(FpdFileContents ffc) {
 239         Vector<Object> v = new Vector<Object>();
 240         ffc.getPlatformDefsSupportedArchs(v);
 241         showSupportedArchitectures(v);
 242         v.removeAllElements();
 243
 244         ffc.getPlatformDefsBuildTargets(v);
 245         buildTargetTableModel.setRowCount(0);
 246         for (int i = 0; i < v.size(); ++i) {
 247             Object[] row = { v.get(i) };
 248             buildTargetTableModel.addRow(row);
 249         }
 250
 251         String[][] saa = new String[ffc.getPlatformDefsSkuInfoCount()][2];
 252         ffc.getPlatformDefsSkuInfos(saa);
 253         for (int i = 0; i < saa.length; ++i) {
 254             skuInfoTableModel.addRow(saa[i]);
 255         }
 256
 257         String interDir = ffc.getPlatformDefsInterDir();
 258         if (interDir != null) {
 259             jComboBoxInterDir.setSelectedItem(interDir);
 260         }
 261
 262         String outputDir = ffc.getPlatformDefsOutputDir();
 263         if (outputDir != null) {
 264             jTextFieldOutputDir.setText(outputDir);
 265         }
 266     }
 267
 268     private void showSupportedArchitectures(Vector<Object> v) {
 269         if (v.contains("IA32")) {
 270             jCheckBoxIa32.setSelected(true);
 271         } else {
 272             jCheckBoxIa32.setSelected(false);
 273         }
 274         if (v.contains("X64")) {
 275             jCheckBoxX64.setSelected(true);
 276         } else {
 277             jCheckBoxX64.setSelected(false);
 278         }
 279         if (v.contains("IPF")) {
 280             jCheckBoxIpf.setSelected(true);
 281         } else {
 282             jCheckBoxIpf.setSelected(false);
 283         }
 284         if (v.contains("EBC")) {
 285             jCheckBoxEbc.setSelected(true);
 286         } else {
 287             jCheckBoxEbc.setSelected(false);
 288         }
 289         if (v.contains("ARM")) {
 290             jCheckBoxArm.setSelected(true);
 291         } else {
 292             jCheckBoxArm.setSelected(false);
 293         }
 294         if (v.contains("PPC")) {
 295             jCheckBoxPpc.setSelected(true);
 296         } else {
 297             jCheckBoxPpc.setSelected(false);
 298         }
 299     }
 300
 301     private void getSupportedArchitectures(Vector<Object> v) {
 302         if (docConsole != null) {
 303             docConsole.setSaved(false);
 304         }
 305         v.removeAllElements();
 306         if (jCheckBoxIa32.isSelected()) {
 307             v.add("IA32");
 308         }
 309         if (jCheckBoxX64.isSelected()) {
 310             v.add("X64");
 311         }
 312         if (jCheckBoxIpf.isSelected()) {
 313             v.add("IPF");
 314         }
 315         if (jCheckBoxEbc.isSelected()) {
 316             v.add("EBC");
 317         }
 318         if (jCheckBoxArm.isSelected()) {
 319             v.add("ARM");
 320         }
 321         if (jCheckBoxPpc.isSelected()) {
 322             v.add("PPC");
 323         }
 324
 325     }
 326
 327     /**
 328      * This method initializes jContentPane
 329      *
 330      * @return javax.swing.JPanel
 331      */
 332     private JPanel getJContentPane() {
 333         if (jContentPane == null) {
 334             jContentPane = new JPanel();
 335             jContentPane.setLayout(new BorderLayout());
 336             jContentPane.add(getJTabbedPane(), java.awt.BorderLayout.CENTER);
 337         }
 338         return jContentPane;
 339     }
 340
 341     /**
 342      * This method initializes jPanel4
 343      *
 344      * @return javax.swing.JPanel
 345      */
 346     private JPanel getJPanelGeneralTab() {
 347         if (jPanelGeneralTab == null) {
 348             jPanelGeneralTab = new JPanel();
 349             jPanelGeneralTab.setBounds(new java.awt.Rectangle(0, 0, dialogWidth * 2, dialogHeight * 3));
 350             jPanelGeneralTab.setPreferredSize(new java.awt.Dimension(dialogWidth + 10, (dialogHeight * 3) + 10));
 351             jPanelGeneralTab.setAutoscrolls(true);
 352             jPanelGeneralTab.setLocation(0, 0);
 353             jPanelGeneralTab.setLayout(null);
 354             jPanelGeneralTab.add(getJPanelGeneralContainer(), null);
 355         }
 356         return jPanelGeneralTab;
 357     }
 358
 359     /**
 360      * This method initializes jPanel5
 361      *
 362      * @return javax.swing.JPanel
 363      */
 364     private JPanel getJPanelGeneralContainer() {
 365         if (jPanelGeneralContainer == null) {
 366             jLabelSupArch = new JLabel();
 367             jLabelSupArch.setText("Supported Architectures");
 368             jLabelSupArch.setBounds(new java.awt.Rectangle(labelColumn, rowOne, labelWidth, oneRowHeight));
 369             jLabelBuildTargets = new JLabel();
 370             jLabelBuildTargets.setText("Build Targets");
 371             jLabelBuildTargets.setBounds(new java.awt.Rectangle(labelColumn, rowTwo, labelWidth, oneRowHeight));
 372             jLabelSkuInfo = new JLabel();
 373             jLabelSkuInfo.setText("SKU Information");
 374             jLabelSkuInfo.setBounds(new java.awt.Rectangle(labelColumn, rowFive, labelWidth, oneRowHeight));
 375             jLabelSkuId = new JLabel();
 376             jLabelSkuId.setText("SKU ID Number");
 377             jLabelSkuId.setBounds(new java.awt.Rectangle(labelColumn + 10, rowSix, labelWidth, oneRowHeight));
 378             jLabelSkuName = new JLabel();
 379             jLabelSkuName.setText("SKU Name");
 380             jLabelSkuName.setBounds(new java.awt.Rectangle(labelColumn + 10, rowSeven, labelWidth, oneRowHeight));
 381             jLabelOutputInfo = new JLabel();
 382             jLabelOutputInfo.setText("Output Directory Configuration");
 383             jLabelOutputInfo.setBounds(new java.awt.Rectangle(labelColumn, rowTen, valueWidth, oneRowHeight));
 384             jLabelIntermediateDirs = new JLabel();
 385             jLabelIntermediateDirs.setText("Intermediate Build Directories");
 386             jLabelIntermediateDirs.setBounds(new java.awt.Rectangle(labelColumn + 10, rowEleven, valueWidth,
 387                                                                     oneRowHeight));
 388             jLabelOutputDir = new JLabel();
 389             jLabelOutputDir.setText("Name of the Output Directory");
 390             jLabelOutputDir.setBounds(new java.awt.Rectangle(labelColumn + 10, rowTwelve, valueWidth, oneRowHeight));
 391
 392             jPanelGeneralContainer = new JPanel();
 393             jPanelGeneralContainer.setLayout(null);
 394             jPanelGeneralContainer.setLocation(new java.awt.Point(2, 2));
 395             jPanelGeneralContainer.setBounds(new java.awt.Rectangle(2, 2, dialogWidth * 2, dialogHeight));
 396             jPanelGeneralContainer.setPreferredSize(new java.awt.Dimension(dialogWidth, dialogHeight));
 397
 398             jPanelGeneralContainer.add(jLabelSupArch, null);
 399             jPanelGeneralContainer.add(getArchitectureSelections(), null);
 400
 401             jPanelGeneralContainer.add(jLabelBuildTargets, null);
 402             jPanelGeneralContainer.add(getJTextFieldBuildTarget(), null);
 403             jPanelGeneralContainer.add(getJButtonAddBuildTarget(), null);
 404             jPanelGeneralContainer.add(getJButtonDelBuildTarget(), null);
 405             jPanelGeneralContainer.add(getJScrollPaneBuildTargets(), null);
 406
 407             jPanelGeneralContainer.add(jLabelSkuInfo, null);
 408             jPanelGeneralContainer.add(jLabelSkuId, null);
 409             jPanelGeneralContainer.add(getJTextFieldSkuId(), null);
 410             jPanelGeneralContainer.add(jLabelSkuName, null);
 411             jPanelGeneralContainer.add(getJTextFieldSkuName(), null);
 412             jPanelGeneralContainer.add(getJButtonSkuAdd(), null);
 413             jPanelGeneralContainer.add(getJButtonSkuDel(), null);
 414             jPanelGeneralContainer.add(getJScrollPaneSkuInfo(), null);
 415
 416             jPanelGeneralContainer.add(jLabelOutputInfo, null);
 417             jPanelGeneralContainer.add(jLabelIntermediateDirs, null);
 418             jPanelGeneralContainer.add(getJComboBoxInterDir(), null);
 419             jPanelGeneralContainer.add(jLabelOutputDir, null);
 420             jPanelGeneralContainer.add(getJTextFieldOutputDir(), null);
 421
 422         }
 423         return jPanelGeneralContainer;
 424     }
 425
 426     /**
 427      * This method initializes jArchitectureSelections Row 4
 428      *
 429      * @return jArchitectureSelections
 430      */
 431     private JPanel getArchitectureSelections() {
 432         if (jArchitectureSelections == null) {
 433             jArchitectureSelections = new JPanel();
 434             jArchitectureSelections.setLayout(null);
 435             jArchitectureSelections.add(getJCheckBoxIa32(), null);
 436             jArchitectureSelections.add(getJCheckBoxX64(), null);
 437             jArchitectureSelections.add(getJCheckBoxIpf(), null);
 438             jArchitectureSelections.add(getJCheckBoxEbc(), null);
 439             jArchitectureSelections.add(getJCheckBoxArm(), null);
 440             jArchitectureSelections.add(getJCheckBoxPpc(), null);
 441             jArchitectureSelections.setBounds(new java.awt.Rectangle(valueColumn, rowOne, valueWidth, oneRowHeight));
 442             jArchitectureSelections.setPreferredSize(new java.awt.Dimension(valueWidth, oneRowHeight));
 443             jArchitectureSelections.setLocation(new java.awt.Point(valueColumn, rowOne));
 444         }
 445         return jArchitectureSelections;
 446     }
 447
 448     /**
 449      * This method initializes jCheckBox1
 450      *
 451      * @return javax.swing.JCheckBox
 452      */
 453     private JCheckBox getJCheckBoxIa32() {
 454         if (jCheckBoxIa32 == null) {
 455             jCheckBoxIa32 = new JCheckBox();
 456             jCheckBoxIa32.setText("IA32");
 457             jCheckBoxIa32.setBounds(new java.awt.Rectangle(0, 0, 55, 20));
 458             jCheckBoxIa32.addItemListener(new java.awt.event.ItemListener() {
 459                 public void itemStateChanged(java.awt.event.ItemEvent e) {
 460                     Vector<Object> v = new Vector<Object>();
 461                     getSupportedArchitectures(v);
 462                     if (v.size() == 0) {
 463                         JOptionPane.showMessageDialog(frame, "Platform must support at least ONE Architecture.");
 464                         return;
 465                     }
 466                     ffc.setPlatformDefsSupportedArchs(v);
 467                 }
 468             });
 469         }
 470         return jCheckBoxIa32;
 471     }
 472
 473     /**
 474      * This method initializes jCheckBox2
 475      *
 476      * @return javax.swing.JCheckBox
 477      */
 478     private JCheckBox getJCheckBoxX64() {
 479         if (jCheckBoxX64 == null) {
 480             jCheckBoxX64 = new JCheckBox();
 481             jCheckBoxX64.setText("X64");
 482             jCheckBoxX64.setBounds(new java.awt.Rectangle(55, 0, 53, 20));
 483             jCheckBoxX64.addItemListener(new java.awt.event.ItemListener() {
 484                 public void itemStateChanged(java.awt.event.ItemEvent e) {
 485                     Vector<Object> v = new Vector<Object>();
 486                     getSupportedArchitectures(v);
 487                     if (v.size() == 0) {
 488                         JOptionPane.showMessageDialog(frame, "Platform must support at least ONE Architecture.");
 489                         return;
 490                     }
 491                     ffc.setPlatformDefsSupportedArchs(v);
 492                 }
 493             });
 494         }
 495         return jCheckBoxX64;
 496     }
 497
 498     /**
 499      * This method initializes jCheckBox3
 500      *
 501      * @return javax.swing.JCheckBox
 502      */
 503     private JCheckBox getJCheckBoxIpf() {
 504         if (jCheckBoxIpf == null) {
 505             jCheckBoxIpf = new JCheckBox();
 506             jCheckBoxIpf.setText("IPF");
 507             jCheckBoxIpf.setBounds(new java.awt.Rectangle(108, 0, 52, 20));
 508             jCheckBoxIpf.addItemListener(new java.awt.event.ItemListener() {
 509                 public void itemStateChanged(java.awt.event.ItemEvent e) {
 510                     Vector<Object> v = new Vector<Object>();
 511                     getSupportedArchitectures(v);
 512                     if (v.size() == 0) {
 513                         JOptionPane.showMessageDialog(frame, "Platform must support at least ONE Architecture.");
 514                         return;
 515                     }
 516                     ffc.setPlatformDefsSupportedArchs(v);
 517                 }
 518             });
 519         }
 520         return jCheckBoxIpf;
 521     }
 522
 523     /**
 524      * This method initializes jCheckBox
 525      *
 526      * @return javax.swing.JCheckBox
 527      */
 528     private JCheckBox getJCheckBoxEbc() {
 529         if (jCheckBoxEbc == null) {
 530             jCheckBoxEbc = new JCheckBox();
 531             // jCheckBoxEbc.setPreferredSize(new java.awt.Dimension(50, 20));
 532             jCheckBoxEbc.setBounds(new java.awt.Rectangle(160, 0, 53, 20));
 533             jCheckBoxEbc.setText("EBC");
 534             jCheckBoxEbc.setVisible(true);
 535             jCheckBoxEbc.addItemListener(new java.awt.event.ItemListener() {
 536                 public void itemStateChanged(java.awt.event.ItemEvent e) {
 537                     Vector<Object> v = new Vector<Object>();
 538                     getSupportedArchitectures(v);
 539                     if (v.size() == 0) {
 540                         JOptionPane.showMessageDialog(frame, "Platform must support at least ONE Architecture.");
 541                         return;
 542                     }
 543                     ffc.setPlatformDefsSupportedArchs(v);
 544                 }
 545             });
 546         }
 547         return jCheckBoxEbc;
 548     }
 549
 550     /**
 551      * This method initializes jCheckBox5
 552      *
 553      * @return javax.swing.JCheckBox
 554      */
 555     private JCheckBox getJCheckBoxArm() {
 556         if (jCheckBoxArm == null) {
 557             jCheckBoxArm = new JCheckBox();
 558             // jCheckBoxArm.setPreferredSize(new java.awt.Dimension(52, 20));
 559             jCheckBoxArm.setBounds(new java.awt.Rectangle(213, 0, 54, 20));
 560             jCheckBoxArm.setText("ARM");
 561             jCheckBoxArm.setVisible(true);
 562             jCheckBoxArm.addItemListener(new java.awt.event.ItemListener() {
 563                 public void itemStateChanged(java.awt.event.ItemEvent e) {
 564                     Vector<Object> v = new Vector<Object>();
 565                     getSupportedArchitectures(v);
 566                     if (v.size() == 0) {
 567                         JOptionPane.showMessageDialog(frame, "Platform must support at least ONE Architecture.");
 568                         return;
 569                     }
 570                     ffc.setPlatformDefsSupportedArchs(v);
 571                 }
 572             });
 573         }
 574         return jCheckBoxArm;
 575     }
 576
 577     /**
 578      * This method initializes jCheckBox6
 579      *
 580      * @return javax.swing.JCheckBox
 581      */
 582     private JCheckBox getJCheckBoxPpc() {
 583         if (jCheckBoxPpc == null) {
 584             jCheckBoxPpc = new JCheckBox();
 585             // jCheckBoxPpc.setPreferredSize(new Dimension(50, 20));
 586             jCheckBoxPpc.setBounds(new java.awt.Rectangle(267, 0, 53, 20));
 587             jCheckBoxPpc.setText("PPC");
 588             jCheckBoxPpc.setVisible(true);
 589             jCheckBoxPpc.addItemListener(new java.awt.event.ItemListener() {
 590                 public void itemStateChanged(java.awt.event.ItemEvent e) {
 591                     Vector<Object> v = new Vector<Object>();
 592                     getSupportedArchitectures(v);
 593                     if (v.size() == 0) {
 594                         JOptionPane.showMessageDialog(frame, "Platform must support at least ONE  Architecture.");
 595                         return;
 596                     }
 597                     ffc.setPlatformDefsSupportedArchs(v);
 598                 }
 599             });
 600         }
 601         return jCheckBoxPpc;
 602     }
 603
 604     /**
 605      * This method initializes jTextField1
 606      *
 607      * @return javax.swing.JTextField
 608      */
 609     private JTextField getJTextFieldBuildTarget() {
 610         if (jTextFieldBuildTarget == null) {
 611             jTextFieldBuildTarget = new JTextField();
 612             jTextFieldBuildTarget.setPreferredSize(new Dimension(valueWidth, oneRowHeight));
 613             jTextFieldBuildTarget.setBounds(new java.awt.Rectangle(valueColumn, rowTwo, valueWidth, oneRowHeight));
 614             jTextFieldBuildTarget.setLocation(new java.awt.Point(valueColumn, rowTwo));
 615         }
 616         return jTextFieldBuildTarget;
 617     }
 618
 619     /**
 620      * This method initializes jButton2
 621      *
 622      * @return javax.swing.JButton
 623      */
 624     private JButton getJButtonAddBuildTarget() {
 625         if (jButtonAddBuildTarget == null) {
 626             jButtonAddBuildTarget = new JButton();
 627             jButtonAddBuildTarget.setPreferredSize(new Dimension(buttonWidth, oneRowHeight));
 628             jButtonAddBuildTarget.setBounds(new java.awt.Rectangle(valueCenter - buttonWidth - 5, rowThree,
 629                                                                    buttonWidth, oneRowHeight));
 630             jButtonAddBuildTarget.setLocation(new java.awt.Point(valueCenter - buttonWidth - 5, rowThree));
 631             jButtonAddBuildTarget.setText("Add");
 632             jButtonAddBuildTarget.setVisible(true);
 633
 634             jButtonAddBuildTarget.addActionListener(new java.awt.event.ActionListener() {
 635                 public void actionPerformed(java.awt.event.ActionEvent e) {
 636                     if (jTextFieldBuildTarget.getText().length() > 0) {
 637                         String[] row = { jTextFieldBuildTarget.getText() };
 638                         jTextFieldBuildTarget.setText("");
 639                         buildTargetTableModel.addRow(row);
 640                         Vector<Object> v = new Vector<Object>();
 641                         for (int i = 0; i < jTableBuildTargets.getRowCount(); ++i) {
 642                             v.add(buildTargetTableModel.getValueAt(i, 0));
 643                         }
 644                         docConsole.setSaved(false);
 645                         ffc.setPlatformDefsBuildTargets(v);
 646                     }
 647                 }
 648             });
 649         }
 650         return jButtonAddBuildTarget;
 651     }
 652
 653     /**
 654      * This method initializes jButton3
 655      *
 656      * @return javax.swing.JButton
 657      */
 658     private JButton getJButtonDelBuildTarget() {
 659         if (jButtonDelBuildTarget == null) {
 660             jButtonDelBuildTarget = new JButton();
 661             jButtonDelBuildTarget.setPreferredSize(new Dimension(buttonWidth, oneRowHeight));
 662             jButtonDelBuildTarget
 663                                  .setBounds(new java.awt.Rectangle(valueCenter + 5, rowThree, buttonWidth, oneRowHeight));
 664             jButtonDelBuildTarget.setLocation(new java.awt.Point(valueCenter + 5, rowThree));
 665             jButtonDelBuildTarget.setText("Delete");
 666             jButtonDelBuildTarget.setVisible(true);
 667
 668             jButtonDelBuildTarget.addActionListener(new java.awt.event.ActionListener() {
 669                 public void actionPerformed(java.awt.event.ActionEvent e) {
 670                     if (jTableBuildTargets.getSelectedRow() < 0 || jTableBuildTargets.getSelectedRow() < 0) {
 671                         return;
 672                     }
 673                     buildTargetTableModel.removeRow(jTableBuildTargets.getSelectedRow());
 674                     Vector<Object> v = new Vector<Object>();
 675                     for (int i = 0; i < jTableBuildTargets.getRowCount(); ++i) {
 676                         v.remove(buildTargetTableModel.getValueAt(i, 0));
 677                     }
 678                     docConsole.setSaved(false);
 679                     ffc.setPlatformDefsBuildTargets(v);
 680                 }
 681             });
 682         }
 683         return jButtonDelBuildTarget;
 684     }
 685
 686     /**
 687      * This method initializes jScrollPane2
 688      *
 689      * @return javax.swing.JScrollPane
 690      */
 691     private JScrollPane getJScrollPaneBuildTargets() {
 692         if (jScrollPaneBuildTargets == null) {
 693             jScrollPaneBuildTargets = new JScrollPane();
 694             jScrollPaneBuildTargets.setPreferredSize(new Dimension(tableWidth - 20, tableHeight - 20));
 695             jScrollPaneBuildTargets.setBounds(new java.awt.Rectangle(valueColumn, rowFour, tableWidth - 5,
 696                                                                      tableHeight - 5));
 697             jScrollPaneBuildTargets.setLocation(new java.awt.Point(valueColumn, rowFour));
 698             jScrollPaneBuildTargets
 699                                    .setBorder(javax.swing.BorderFactory
 700                                                                        .createEtchedBorder(javax.swing.border.EtchedBorder.RAISED));
 701
 702             jScrollPaneBuildTargets.setViewportView(getJTableBuildTargets());
 703         }
 704         return jScrollPaneBuildTargets;
 705     }
 706
 707     /**
 708      * This method initializes jTable
 709      *
 710      * @return javax.swing.JTable
 711      */
 712     private JTable getJTableBuildTargets() {
 713         if (jTableBuildTargets == null) {
 714             buildTargetTableModel = new TargetTableModel();
 715
 716             jTableBuildTargets = new JTable(buildTargetTableModel);
 717             jTableBuildTargets.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
 718             jTableBuildTargets.setRowHeight(oneRowHeight);
 719             buildTargetTableModel.addColumn("Build Target");
 720
 721             jTableBuildTargets.getModel().addTableModelListener(new TableModelListener() {
 722                 public void tableChanged(TableModelEvent arg0) {
 723                     // TODO Auto-generated method stub
 724                     selectedRow = jTableBuildTargets.getSelectedRow();
 725                     if (selectedRow < 0) {
 726                         return;
 727                     }
 728                     TableModel m = (TableModel) arg0.getSource();
 729                     if (arg0.getType() == TableModelEvent.UPDATE) {
 730                         //ToDo Data Validition check.
 731                         Vector<Object> v = new Vector<Object>();
 732                         for (int i = 0; i < jTableBuildTargets.getRowCount(); ++i) {
 733                             v.add(m.getValueAt(i, 0));
 734                         }
 735                         docConsole.setSaved(false);
 736                         ffc.setPlatformDefsBuildTargets(v);
 737                     }
 738                 }
 739             });
 740
 741         }
 742         return jTableBuildTargets;
 743     }
 744
 745     /**
 746      * This method initializes jTextField2
 747      *
 748      * @return javax.swing.JTextField
 749      */
 750     private JTextField getJTextFieldSkuId() {
 751         if (jTextFieldSkuId == null) {
 752             jTextFieldSkuId = new JTextField();
 753             jTextFieldSkuId.setPreferredSize(new Dimension(40, oneRowHeight));
 754             jTextFieldSkuId.setBounds(new java.awt.Rectangle(valueColumn, rowSix, 40, oneRowHeight));
 755             jTextFieldSkuId.setLocation(new java.awt.Point(valueColumn, rowSix));
 756         }
 757         return jTextFieldSkuId;
 758     }
 759
 760     /**
 761      * This method initializes jTextField3
 762      *
 763      * @return javax.swing.JTextField
 764      */
 765     private JTextField getJTextFieldSkuName() {
 766         if (jTextFieldSkuName == null) {
 767             jTextFieldSkuName = new JTextField();
 768             jTextFieldSkuName.setPreferredSize(new Dimension(valueWidth, oneRowHeight));
 769             jTextFieldSkuName.setBounds(new java.awt.Rectangle(valueColumn, rowSeven, valueWidth, oneRowHeight));
 770             jTextFieldSkuName.setLocation(new java.awt.Point(valueColumn, rowSeven));
 771         }
 772         return jTextFieldSkuName;
 773     }
 774
 775     /**
 776      * This method initializes jButton
 777      *
 778      * @return javax.swing.JButton
 779      */
 780     private JButton getJButtonSkuAdd() {
 781         if (jButtonSkuAdd == null) {
 782             jButtonSkuAdd = new JButton();
 783
 784             jButtonSkuAdd.setPreferredSize(new Dimension(buttonWidth, oneRowHeight));
 785             jButtonSkuAdd.setBounds(new java.awt.Rectangle(valueCenter - buttonWidth - 5, rowEight, buttonWidth,
 786                                                            oneRowHeight));
 787             jButtonSkuAdd.setLocation(new java.awt.Point(valueCenter - buttonWidth - 5, rowEight));
 788             jButtonSkuAdd.setText("Add");
 789             jButtonSkuAdd.setVisible(true);
 790
 791             jButtonSkuAdd.addActionListener(new java.awt.event.ActionListener() {
 792                 public void actionPerformed(java.awt.event.ActionEvent e) {
 793                     if (jTextFieldSkuId.getText().length() > 0) {
 794                         String[] row = { jTextFieldSkuId.getText(), jTextFieldSkuName.getText() };
 795                         skuInfoTableModel.addRow(row);
 796                         docConsole.setSaved(false);
 797                         ffc.genPlatformDefsSkuInfo(row[0], row[1]);
 798                     }
 799                 }
 800             });
 801         }
 802         return jButtonSkuAdd;
 803     }
 804
 805     /**
 806      * This method initializes jButton1
 807      *
 808      * @return javax.swing.JButton
 809      */
 810     private JButton getJButtonSkuDel() {
 811         if (jButtonSkuDel == null) {
 812             jButtonSkuDel = new JButton();
 813             jButtonSkuDel.setPreferredSize(new Dimension(buttonWidth, oneRowHeight));
 814             jButtonSkuDel.setBounds(new java.awt.Rectangle(valueCenter + 5, rowEight, buttonWidth, oneRowHeight));
 815             jButtonSkuDel.setLocation(new java.awt.Point(valueCenter + 5, rowEight));
 816             jButtonSkuDel.setText("Delete");
 817             jButtonSkuDel.setVisible(true);
 818             jButtonSkuDel.addActionListener(new java.awt.event.ActionListener() {
 819                 public void actionPerformed(java.awt.event.ActionEvent e) {
 820                     if (jTableSkuInfo.isEditing()) {
 821                         jTableSkuInfo.getCellEditor().stopCellEditing();
 822                     }
 823                     if (jTableSkuInfo.getSelectedRow() < 1) {
 824                         return;
 825                     }
 826                     docConsole.setSaved(false);
 827                     ffc.removePlatformDefsSkuInfo(jTableSkuInfo.getSelectedRow());
 828                     skuInfoTableModel.removeRow(jTableSkuInfo.getSelectedRow());
 829                 }
 830             });
 831         }
 832         return jButtonSkuDel;
 833     }
 834
 835     /**
 836      * This method initializes jScrollPane3
 837      *
 838      * @return javax.swing.JScrollPane
 839      */
 840     private JScrollPane getJScrollPaneSkuInfo() {
 841         if (jScrollPaneSkuInfo == null) {
 842             jScrollPaneSkuInfo = new JScrollPane();
 843             jScrollPaneSkuInfo.setPreferredSize(new Dimension(tableWidth - 20, tableHeight - 20));
 844             jScrollPaneSkuInfo.setBounds(new java.awt.Rectangle(valueColumn, rowNine, tableWidth - 5, tableHeight - 5));
 845             jScrollPaneSkuInfo.setLocation(new java.awt.Point(valueColumn, rowNine));
 846             jScrollPaneSkuInfo.setBorder(null);
 847
 848             jScrollPaneSkuInfo.setViewportView(getJTableSkuInfo());
 849         }
 850         return jScrollPaneSkuInfo;
 851     }
 852
 853     /**
 854      * This method initializes jTable2
 855      *
 856      * @return javax.swing.JTable
 857      */
 858     private JTable getJTableSkuInfo() {
 859         if (jTableSkuInfo == null) {
 860             skuInfoTableModel = new SkuInfoTableModel();
 861             skuInfoTableModel.addColumn("SKU ID");
 862             skuInfoTableModel.addColumn("Name");
 863             jTableSkuInfo = new JTable(skuInfoTableModel);
 864
 865             jTableSkuInfo.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
 866
 867             jTableSkuInfo.getModel().addTableModelListener(new TableModelListener() {
 868                 public void tableChanged(TableModelEvent arg0) {
 869                     // TODO Auto-generated method stub
 870                     int row = arg0.getFirstRow();
 871                     TableModel m = (TableModel) arg0.getSource();
 872                     if (arg0.getType() == TableModelEvent.UPDATE) {
 873                         //ToDo Data Validition check.
 874                         String id = m.getValueAt(row, 0) + "";
 875                         String name = m.getValueAt(row, 1) + "";
 876                         docConsole.setSaved(false);
 877                         ffc.updatePlatformDefsSkuInfo(row, id, name);
 878                     }
 879                 }
 880             });
 881         }
 882         return jTableSkuInfo;
 883     }
 884
 885     /**
 886      * This method initializes jComboBox
 887      *
 888      * @return javax.swing.JComboBox
 889      */
 890     private JComboBox getJComboBoxInterDir() {
 891         if (jComboBoxInterDir == null) {
 892             jComboBoxInterDir = new JComboBox();
 893             jComboBoxInterDir.setPreferredSize(new Dimension(75, oneRowHeight));
 894             jComboBoxInterDir.setBounds(new java.awt.Rectangle(valueColumn + 30, rowEleven, 75, oneRowHeight));
 895             jComboBoxInterDir.setLocation(new java.awt.Point(valueColumn + 30, rowEleven));
 896             jComboBoxInterDir.addItem("UNIFIED");
 897             jComboBoxInterDir.addItem("MODULE");
 898             jComboBoxInterDir.setSelectedIndex(0);
 899             jComboBoxInterDir.addItemListener(new java.awt.event.ItemListener() {
 900                 public void itemStateChanged(java.awt.event.ItemEvent e) {
 901                     if (docConsole != null) {
 902                         docConsole.setSaved(false);
 903                     }
 904                     ffc.setPlatformDefsInterDir(jComboBoxInterDir.getSelectedItem() + "");
 905                 }
 906             });
 907         }
 908         return jComboBoxInterDir;
 909     }
 910
 911     /**
 912      * This method initializes jTextField
 913      *
 914      * @return javax.swing.JTextField  Row Twelve
 915      */
 916     private JTextField getJTextFieldOutputDir() {
 917         if (jTextFieldOutputDir == null) {
 918             jTextFieldOutputDir = new JTextField();
 919             jTextFieldOutputDir.setPreferredSize(new java.awt.Dimension(290, 20));
 920             jTextFieldOutputDir.setBounds(new java.awt.Rectangle(valueColumn + 30, rowTwelve, valueWidth - 30,
 921                                                                  oneRowHeight));
 922             jTextFieldOutputDir.setLocation(new java.awt.Point(valueColumn + 30, rowTwelve));
 923             jTextFieldOutputDir.addFocusListener(new java.awt.event.FocusAdapter() {
 924                 public void focusLost(java.awt.event.FocusEvent e) {
 925                     docConsole.setSaved(false);
 926                     ffc.setPlatformDefsOutputDir(jTextFieldOutputDir.getText());
 927                 }
 928             });
 929         }
 930         return jTextFieldOutputDir;
 931     }
 932
 933 } //  @jve:decl-index=0:visual-constraint="10,10"
 934
 935 class SkuInfoTableModel extends DefaultTableModel {
 936     private static final long serialVersionUID = 1L;
 937
 938     public boolean isCellEditable(int row, int column) {
 939         if (row == 0) {
 940             return false;
 941         }
 942         return true;
 943     }
 944 }
 945
 946 class TargetTableModel extends DefaultTableModel {
 947     private static final long serialVersionUID = 1L;
 948
 949     public boolean isCellEditable(int row, int column) {
 950         if (row < 2) {
 951             return false;
 952         }
 953         return true;
 954     }
 955 }