Tools/Source/FrameworkWizard/src/org/tianocore/frameworkwizard/toolchain/Preferences.java

   1 /** @file
   2  <<The file is used to update the Build Preferences file, target.txt>>
   3
   4  <<The program will use target.txt, the tools config file specified in that file,
   5  or it will use the default tools_def.txt file, and it will also scan the
   6  FrameworkDatabase.db file for certain parameters. >>
   7
   8  Copyright (c) 2006, Intel Corporation
   9  All rights reserved. This program and the accompanying materials
  10  are licensed and made available under the terms and conditions of the BSD License
  11  which accompanies this distribution.  The full text of the license may be found at
  12  http://opensource.org/licenses/bsd-license.php
  13
  14  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  15  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  16
  17  Package Name: Tools
  18  Module Name:  FrameworkWizard
  19
  20  **/
  21
  22 package org.tianocore.frameworkwizard.toolchain;
  23
  24 import java.awt.event.ActionEvent;
  25 import java.io.*;
  26 import java.util.Vector;
  27 import java.util.Iterator;
  28 import java.util.Scanner;
  29
  30 import javax.swing.*;
  31 import javax.swing.JScrollPane;
  32 import javax.swing.JTextField;
  33 import javax.swing.JFrame;
  34
  35 import org.tianocore.frameworkwizard.common.GlobalData;
  36 import org.tianocore.frameworkwizard.common.Tools;
  37 import org.tianocore.frameworkwizard.common.Log;
  38 import org.tianocore.frameworkwizard.common.ui.ArchCheckBox;
  39 import org.tianocore.frameworkwizard.common.ui.iCheckBoxList.*;
  40 import org.tianocore.frameworkwizard.common.ui.IFrame;
  41 import org.tianocore.frameworkwizard.workspace.Workspace;
  42 import org.tianocore.frameworkwizard.workspace.WorkspaceTools;
  43 import org.tianocore.frameworkwizard.platform.PlatformIdentification;
  44 import org.tianocore.PlatformSurfaceAreaDocument;
  45
  46 /**
  47  * The class is used to update the target.txt file.
  48  *
  49  * It extends IDialog
  50  *
  51  */
  52 public class Preferences extends IFrame {
  53
  54     // /
  55     // / Define class Serial Version UID
  56     // /
  57     private static final long serialVersionUID = -4777906991966638888L;
  58
  59     private final boolean Debug = false;
  60
  61     //
  62     // Define class members
  63     //
  64     private final int oneRowHeight = 20;
  65
  66     private final int twoRowHeight = 40;
  67
  68     private final int threeRowHeight = 60;
  69
  70     private final int sepHeight = 6;
  71
  72     private final int rowOne = 12;
  73
  74     private final int rowTwo = rowOne + oneRowHeight + sepHeight;
  75
  76     private final int rowThree = rowTwo + oneRowHeight + sepHeight;
  77
  78     private final int rowFour = rowThree + threeRowHeight + sepHeight;
  79
  80     private final int rowFive = rowFour + threeRowHeight + sepHeight;
  81
  82     private final int rowSix = rowFive + oneRowHeight + sepHeight;
  83
  84     private final int buttonRow = rowSix + oneRowHeight + sepHeight + sepHeight;
  85
  86     private final int dialogHeight = buttonRow + twoRowHeight + twoRowHeight;
  87
  88     private final int dialogWidth = 540;
  89
  90     private final int lastButtonXLoc = 430;
  91
  92     private final int next2LastButtonLoc = 329;
  93
  94     /*
  95      * Define the contents for this dialog box
  96      */
  97     private static Preferences bTarget = null;
  98
  99     private WorkspaceTools wt = new WorkspaceTools();
 100
 101     private JFrame frame;
 102
 103     private final int activePlatformId = 0;
 104
 105     private final int buildTargetId = 1;
 106
 107     private final int targetArchId = 2;
 108
 109     private final int toolDefFileId = 3;
 110
 111     private final int tagNameId = 4;
 112
 113     private final int threadEnableId = 5;
 114
 115     private final int threadCountId = 6;
 116
 117     private final int maxTargetLines = threadCountId + 1;
 118
 119     private JPanel jContentPane = null;
 120
 121     private JLabel jLabelToolsConfigFile = null;
 122
 123     private JTextField jTextFieldToolsConfigFile = null;
 124
 125     private final int toolConfigFileRow = rowOne;
 126
 127     private JLabel jLabelActivePlatform = null;
 128
 129     private JComboBox jComboBoxActivePlatform = null;
 130
 131     private final int activePlatformRow = rowTwo;
 132
 133     private JLabel jLabelToolChainTagName = null;
 134
 135     private JScrollPane jScrollPaneTagName = null;
 136
 137     private ICheckBoxList iCheckBoxListTagName = null;
 138
 139     private final int toolChainTagNameRow = rowThree;
 140
 141     private JLabel jLabelBuildTarget = null;
 142
 143     private JScrollPane jScrollPaneBuildTarget = null;
 144
 145     private ICheckBoxList iCheckBoxListBuildTarget = null;
 146
 147     private final int buildTargetRow = rowFour;
 148
 149     private JLabel jLabelTargetArch = null;
 150
 151     private ArchCheckBox jArchCheckBox = null;
 152
 153     private final int targetArchRow = rowFive;
 154
 155     private JLabel jLabelEnableThreads = null;
 156
 157     private JLabel jLabelThreadCount = null;
 158
 159     private final int threadRow = rowSix;
 160
 161     private JCheckBox jCheckBoxEnableThreads = null;
 162
 163     private JTextField jTextFieldThreadCount = null;
 164
 165     private String threadCount;
 166
 167     private boolean threadEnabled = false;
 168
 169     private JButton jButtonBrowse = null;
 170
 171     private JButton jButtonSave = null;
 172
 173     private JButton jButtonCancel = null;
 174
 175     private final int labelColumn = 12;
 176
 177     private final int labelWidth = 155;
 178
 179     private final int valueColumn = 168;
 180
 181     private final int valueWidth = 352;
 182
 183     private final int valueWidthShort = 260;
 184
 185     private final int buttonWidth = 90;
 186
 187     private String workspaceDir = Workspace.getCurrentWorkspace() + System.getProperty("file.separator");
 188
 189     private String toolsDir = Workspace.getCurrentWorkspace() + System.getProperty("file.separator") + "Tools"
 190                               + System.getProperty("file.separator") + "Conf";
 191
 192     private String defaultToolsConf = toolsDir + System.getProperty("file.separator") + "tools_def.txt";
 193
 194     private String targetFile = toolsDir + System.getProperty("file.separator") + "target.txt";
 195
 196     private String[] targetFileContents = new String[500];
 197
 198     // private String[] toolsConfContents;
 199
 200     private String[] targetLines = new String[maxTargetLines];
 201
 202     private int targetLineNumber[] = new int[maxTargetLines];
 203
 204     private String toolsConfFile;
 205
 206     private String toolsDefTargetNames = null;
 207
 208     private final int toolsDefTargetNameField = 0;
 209
 210     private String toolsDefTagNames = null;
 211
 212     private final int toolsDefTagNameField = 1;
 213
 214     private String toolsDefArchNames = null;
 215
 216     private final int toolsDefArchNameField = 2;
 217
 218     private String toolsDefIdentifier = null;
 219
 220     private int targetLineNumberMax;
 221
 222     private final int toolDefFieldCount = 5;
 223
 224     private Vector<String> vArchList = null;
 225
 226     private Vector<String> vDisableArchList = null;
 227
 228     //
 229     // Not used by UI
 230     //
 231     //    private Preferences id = null;
 232
 233     //    private EnumerationData ed = new EnumerationData();
 234
 235     /**
 236      This method initializes jTextFieldToolsConfigFile
 237
 238      @return javax.swing.JTextField  jTextFieldToolsConfigFile
 239      **/
 240     private JTextField getJTextFieldToolsConfigFile() {
 241         if (jTextFieldToolsConfigFile == null) {
 242             if (targetLines[toolDefFileId] != null) {
 243                 String sLine[] = targetLines[toolDefFileId].trim().split("=");
 244                 jTextFieldToolsConfigFile = new JTextField(sLine[1].trim());
 245             } else
 246                 jTextFieldToolsConfigFile = new JTextField();
 247
 248             jTextFieldToolsConfigFile.setBounds(new java.awt.Rectangle(valueColumn, toolConfigFileRow, valueWidthShort,
 249                                                                        oneRowHeight));
 250             jTextFieldToolsConfigFile.setPreferredSize(new java.awt.Dimension(valueWidthShort, oneRowHeight));
 251             jTextFieldToolsConfigFile
 252                                      .setToolTipText("<html>"
 253                                                      + "Specify the name of the filename to use for specifying"
 254                                                      + "<br>the tools to use for the build.  If not specified,"
 255                                                      + "<br>tools_def.txt will be used for the build.  This file"
 256                                                      + "<br>MUST be located in the WORKSPACE/Tools/Conf directory.</html>");
 257
 258         }
 259         return jTextFieldToolsConfigFile;
 260     }
 261
 262     /**
 263      * This method initializes jComboBoxActivePlatform
 264      *
 265      * @return javax.swing.JComboBox jComboBoxActivePlatform
 266      *
 267      */
 268     private JComboBox getActivePlatform() {
 269         Vector<PlatformIdentification> vPlatformId = wt.getAllPlatforms();
 270
 271         if (jComboBoxActivePlatform == null) {
 272             jComboBoxActivePlatform = new JComboBox();
 273             jComboBoxActivePlatform.setBounds(new java.awt.Rectangle(valueColumn, activePlatformRow, valueWidth,
 274                                                                      oneRowHeight));
 275             jComboBoxActivePlatform.setPreferredSize(new java.awt.Dimension(valueWidth, oneRowHeight));
 276             jComboBoxActivePlatform
 277                                    .setToolTipText("<html>Select &quot;Do Not Set&quot; if you want to build a platform"
 278                                                    + "<br>from the directory where the FPD file exists,"
 279                                                    + "<br>otherwise scroll down to select the platform.</html>");
 280
 281             /*
 282              * Generate the data, selecting what is in target.txt
 283              */
 284             jComboBoxActivePlatform.addItem("Do Not Set");
 285             Iterator<PlatformIdentification> iter = vPlatformId.iterator();
 286             while (iter.hasNext()) {
 287                 PlatformIdentification item = iter.next();
 288                 String path = item.getPath().trim();
 289                 String str = path.substring(workspaceDir.length(), path.length());
 290                 str.replace(System.getProperty("file.separator"), "/");
 291                 jComboBoxActivePlatform.addItem(str.trim());
 292             }
 293             if (targetLines[activePlatformId] == null)
 294                 jComboBoxActivePlatform.setSelectedItem("Do Not Set");
 295             else
 296                 jComboBoxActivePlatform.setSelectedItem(targetLines[activePlatformId]);
 297         }
 298         return jComboBoxActivePlatform;
 299     }
 300
 301     /**
 302      * This method initializes jScrollPaneTagName
 303      *
 304      * @return javax.swing.JScrollPane jScrollPaneTagName
 305      *
 306      */
 307     private JScrollPane getJScrollPaneTagName() {
 308
 309         if (jScrollPaneTagName == null) {
 310             jScrollPaneTagName = new JScrollPane();
 311             jScrollPaneTagName.setBounds(new java.awt.Rectangle(valueColumn, toolChainTagNameRow, valueWidth,
 312                                                                 threeRowHeight));
 313             jScrollPaneTagName.setPreferredSize(new java.awt.Dimension(valueWidth, threeRowHeight));
 314             jScrollPaneTagName.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
 315             jScrollPaneTagName.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
 316             jScrollPaneTagName.setViewportView(getICheckBoxListTagName());
 317             jScrollPaneTagName.setToolTipText("<html>"
 318                                               + "Specify the TagName(s) from the tool configuration file to use"
 319                                               + "<br>for your builds.  If not specified, all applicable TagName"
 320                                               + " <br>tools will be used for the build.</html>");
 321             jScrollPaneTagName.setVisible(true);
 322
 323         }
 324         return jScrollPaneTagName;
 325     }
 326
 327     private ICheckBoxList getICheckBoxListTagName() {
 328         if (iCheckBoxListTagName == null) {
 329             iCheckBoxListTagName = new ICheckBoxList();
 330
 331             if (toolsDefTagNames != null) {
 332                 toolsDefTagNames.trim();
 333                 String aTagNames[] = toolsDefTagNames.trim().split(" ");
 334                 Vector<String> vTags = new Vector<String>();
 335                 for (int i = 0; i < aTagNames.length; i++) {
 336                     vTags.add(aTagNames[i]);
 337                 }
 338                 iCheckBoxListTagName.setAllItems(vTags);
 339             } else {
 340                 Vector<String> defaultTags = stringToVector("MYTOOLS");
 341                 iCheckBoxListTagName.setAllItems(defaultTags);
 342             }
 343
 344             iCheckBoxListTagName.setAllItemsUnchecked();
 345             iCheckBoxListTagName.setToolTipText("<html>"
 346                                                 + "Specify the TagName(s) from the tool configuration file to use"
 347                                                 + "<br>for your builds.  If not specified, all applicable TagName"
 348                                                 + " <br>tools will be used for the build.</html>");
 349             Vector<String> vSelectedTags = new Vector<String>();
 350             if (targetLines[tagNameId] != null) {
 351                 targetLines[tagNameId].trim();
 352                 String targetTags[] = targetLines[tagNameId].trim().split(" ");
 353                 for (int j = 0; j < targetTags.length; j++)
 354                     vSelectedTags.add(targetTags[j]);
 355                 iCheckBoxListTagName.initCheckedItem(true, vSelectedTags);
 356             }
 357         }
 358         return iCheckBoxListTagName;
 359     }
 360
 361     /**
 362      * This method initializes jScrollPaneBuildTarget
 363      *
 364      * @return javax.swing.JComboBox jScrollPaneBuildTarget
 365      *
 366      */
 367     private JScrollPane getJScrollPaneBuildTarget() {
 368         if (jScrollPaneBuildTarget == null) {
 369             jScrollPaneBuildTarget = new JScrollPane();
 370             jScrollPaneBuildTarget.setBounds(new java.awt.Rectangle(valueColumn, buildTargetRow, valueWidth,
 371                                                                     threeRowHeight));
 372             jScrollPaneBuildTarget.setPreferredSize(new java.awt.Dimension(valueWidth, threeRowHeight));
 373             jScrollPaneBuildTarget.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
 374             jScrollPaneBuildTarget.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
 375             jScrollPaneBuildTarget.setViewportView(getICheckBoxListBuildTarget());
 376             jScrollPaneBuildTarget.setVisible(true);
 377             jScrollPaneBuildTarget.setToolTipText("<html>"
 378                                                   + "Select the TARGET Names that you want to build, such as<BR>"
 379                                                   + "BUILD or BUILD and RELEASE"
 380                                                   + "<br>If you do not set any of these, all available targets"
 381                                                   + "<br>will be built.</html>");
 382
 383         }
 384         return jScrollPaneBuildTarget;
 385     }
 386
 387     private JCheckBox getCheckBoxEnableThreads() {
 388         if (jCheckBoxEnableThreads == null) {
 389             jCheckBoxEnableThreads = new JCheckBox();
 390             jCheckBoxEnableThreads.setBounds(valueColumn, threadRow, 20, oneRowHeight);
 391             jCheckBoxEnableThreads.setToolTipText("Select this if you want to enable parallel compilation.");
 392             jCheckBoxEnableThreads.setSelected(threadEnabled);
 393             jCheckBoxEnableThreads.addActionListener(this);
 394
 395         }
 396         return jCheckBoxEnableThreads;
 397     }
 398
 399     private JTextField getTextFieldThreadCount() {
 400         if (jTextFieldThreadCount == null) {
 401             jTextFieldThreadCount = new JTextField();
 402             jTextFieldThreadCount.setBounds(valueColumn + 215, threadRow, 30, oneRowHeight);
 403             if (threadCount.length() > 0)
 404                 jTextFieldThreadCount.setText(threadCount);
 405             jTextFieldThreadCount.setToolTipText("<html>Recommended setting is N+1,<br> where N is the number of physical processors or cores in the system</html>");
 406             // If CheckBoxEnableThreads is selected, then enable editing
 407
 408         }
 409         return jTextFieldThreadCount;
 410     }
 411
 412     private ICheckBoxList getICheckBoxListBuildTarget() {
 413         if (iCheckBoxListBuildTarget == null) {
 414
 415             String aBuildTargets[] = toolsDefTargetNames.trim().split(" ");
 416             Vector<String> vBuildTargets = new Vector<String>();
 417             for (int i = 0; i < aBuildTargets.length; i++) {
 418                 vBuildTargets.add(aBuildTargets[i]);
 419             }
 420             iCheckBoxListBuildTarget = new ICheckBoxList();
 421             iCheckBoxListBuildTarget.setAllItems(vBuildTargets);
 422             iCheckBoxListBuildTarget.setAllItemsUnchecked();
 423             iCheckBoxListBuildTarget.setToolTipText("<html>"
 424                                                     + "Select the TARGET Names that you want to build, such as<BR>"
 425                                                     + "BUILD or BUILD and RELEASE"
 426                                                     + "<br>If you do not set any of these, all available targets"
 427                                                     + "<br>will be built.</html>");
 428
 429             Vector<String> vSelectedTags = new Vector<String>();
 430             if (targetLines[buildTargetId] != null) {
 431                 targetLines[buildTargetId].trim();
 432                 String targetTags[] = targetLines[buildTargetId].trim().split(" ");
 433                 for (int j = 0; j < targetTags.length; j++)
 434                     vSelectedTags.add(targetTags[j]);
 435                 iCheckBoxListBuildTarget.initCheckedItem(true, vSelectedTags);
 436             }
 437         }
 438         return iCheckBoxListBuildTarget;
 439     }
 440
 441     /**
 442      This method initializes jButtonBrowse
 443
 444      @return javax.swing.JButton
 445      **/
 446     private JButton getJButtonBrowse() {
 447         if (jButtonBrowse == null) {
 448             jButtonBrowse = new JButton();
 449             jButtonBrowse
 450                          .setBounds(new java.awt.Rectangle(lastButtonXLoc, toolConfigFileRow, buttonWidth, oneRowHeight));
 451             jButtonBrowse.setText("Browse");
 452             jButtonBrowse.setPreferredSize(new java.awt.Dimension(buttonWidth, oneRowHeight));
 453             jButtonBrowse.addActionListener(new AbstractAction() {
 454                 /**
 455                  *
 456                  */
 457                 private static final long serialVersionUID = 1L;
 458
 459                 public void actionPerformed(ActionEvent e) {
 460                     //
 461                     // Select files from current workspace
 462                     //
 463                     String dirPrefix = toolsDir + System.getProperty("file.separator");
 464                     JFileChooser chooser = new JFileChooser(dirPrefix);
 465                     File theFile = null;
 466                     //                    String headerDest = null;
 467
 468                     chooser.setMultiSelectionEnabled(false);
 469                     chooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
 470                     int retval = chooser.showOpenDialog(frame);
 471                     if (retval == JFileChooser.APPROVE_OPTION) {
 472
 473                         theFile = chooser.getSelectedFile();
 474                         String file = theFile.getPath();
 475                         if (!file.startsWith(dirPrefix)) {
 476                             JOptionPane.showMessageDialog(frame, "You can only select files in the Tools"
 477                                                                  + System.getProperty("file.separator")
 478                                                                  + "Conf directory!");
 479
 480                             return;
 481                         }
 482
 483                         jTextFieldToolsConfigFile.setText("Tools/Conf/" + theFile.getName());
 484                     } else {
 485                         return;
 486                     }
 487                 }
 488             });
 489         }
 490         return jButtonBrowse;
 491     }
 492
 493     /**
 494      * This method initializes jButtonOk
 495      *
 496      * @return javax.swing.JButton
 497      *
 498      */
 499     private JButton getJButtonSave() {
 500         if (jButtonSave == null) {
 501             jButtonSave = new JButton();
 502             jButtonSave.setBounds(new java.awt.Rectangle(next2LastButtonLoc, buttonRow, buttonWidth, oneRowHeight));
 503             jButtonSave.setText("Save");
 504             jButtonSave.addActionListener(this);
 505         }
 506         return jButtonSave;
 507     }
 508
 509     /**
 510      * This method initializes jButtonCancel
 511      *
 512      * @return javax.swing.JButton
 513      *
 514      */
 515     private JButton getJButtonCancel() {
 516         if (jButtonCancel == null) {
 517             jButtonCancel = new JButton();
 518             jButtonCancel.setBounds(new java.awt.Rectangle(lastButtonXLoc, buttonRow, buttonWidth, oneRowHeight));
 519             jButtonCancel.setText("Cancel");
 520             jButtonCancel.addActionListener(this);
 521         }
 522         return jButtonCancel;
 523     }
 524
 525     public static void main(String[] args) {
 526         // TODO Auto-generated method stub
 527
 528     }
 529
 530     public static Preferences getInstance() {
 531         if (bTarget == null) {
 532             bTarget = new Preferences();
 533         }
 534         return bTarget;
 535     }
 536
 537     /**
 538      * This is the default constructor
 539      */
 540     public Preferences() {
 541         super();
 542         init();
 543     }
 544
 545     /**
 546      * This method initializes this
 547      *
 548      */
 549     private void init() {
 550
 551         for (int i = 0; i < maxTargetLines; i++) {
 552             targetLines[i] = null;
 553             targetLineNumber[i] = -1;
 554         }
 555         initReadFiles();
 556         this.setSize(dialogWidth, dialogHeight);
 557         this.setContentPane(getJContentPane());
 558         this.setTitle("Build Preferences [" + toolsDefIdentifier + "]");
 559         this.setDefaultCloseOperation(IFrame.EXIT_ON_CLOSE);
 560         this.centerWindow();
 561         this.setVisible(true);
 562     }
 563
 564     /**
 565      * This method initializes this Fill values to all fields if these values are
 566      * not empty
 567      *
 568      * @param initReadFiles
 569      *
 570      */
 571     private void initReadFiles() {
 572         /*
 573          * TODO
 574          * Read Current target.txt file first
 575          * Read TOOL_CHAIN_CONF file if specified, otherwise use tools_def.txt
 576          */
 577
 578         readTargetTxtFile();
 579         boolean haveBuildTargets = readToolDefinitionFile();
 580         if (!haveBuildTargets) {
 581             // Lookup Build Targets from the platforms
 582             readPlatformFileBuildTargets();
 583         }
 584     }
 585
 586     private void readPlatformFileBuildTargets() {
 587         Vector<PlatformIdentification> vPlatformId = wt.getAllPlatforms();
 588         String sBuildTargets = "";
 589
 590         // foreach platform, build a list of BuildTargets
 591         Iterator<PlatformIdentification> iter = vPlatformId.iterator();
 592         while (iter.hasNext()) {
 593             PlatformIdentification item = iter.next();
 594             PlatformSurfaceAreaDocument.PlatformSurfaceArea fpd = GlobalData.openingPlatformList
 595                                                                                                 .getOpeningPlatformById(
 596                                                                                                                         item)
 597                                                                                                 .getXmlFpd();
 598             sBuildTargets += fpd.getPlatformDefinitions().getBuildTargets().toString() + " ";
 599         }
 600         String allTargets[] = sBuildTargets.trim().split(" ");
 601         for (int i = 0; i < allTargets.length; i++) {
 602             if (!toolsDefTargetNames.contains(allTargets[i])) {
 603                 toolsDefTargetNames += allTargets[i] + " ";
 604             }
 605         }
 606     }
 607
 608     private boolean readToolDefinitionFile() {
 609
 610         // Parse the tool definition file looking for targets and architectures
 611         toolsConfFile = null;
 612         boolean buildTargetsExist = true;
 613
 614         if (targetLines[toolDefFileId] != null) {
 615             String[] result = new String[2];
 616             targetLines[toolDefFileId].trim();
 617             result = (targetLines[toolDefFileId]).split("=");
 618             String resString = (Tools.convertPathToCurrentOsType(result[1])).trim();
 619             toolsConfFile = workspaceDir.trim() + resString.trim();
 620             File toolsDefFile = new File(toolsConfFile);
 621             if (!toolsDefFile.exists()) {
 622                 JOptionPane.showMessageDialog(this, "<html>" + "Tool Definition file, " + toolsConfFile
 623                                                     + "<br>specified in the target.txt file does not exist!"
 624                                                     + "<br>Using the default Tool Definition File:<br>"
 625                                                     + defaultToolsConf);
 626                 toolsConfFile = defaultToolsConf;
 627             }
 628         } else {
 629             toolsConfFile = defaultToolsConf;
 630         }
 631         String[] toolsDefFields = new String[toolDefFieldCount];
 632         for (int i = 0; i < toolDefFieldCount; i++)
 633             toolsDefFields[i] = null;
 634         File toolDefFile = new File(toolsConfFile);
 635         if (toolDefFile.exists()) {
 636             try {
 637                 FileReader fileReader = new FileReader(toolDefFile);
 638                 BufferedReader reader = new BufferedReader(fileReader);
 639                 String rLine = null;
 640                 String result[];
 641                 int lineCounter = 0;
 642                 while ((rLine = reader.readLine()) != null) {
 643
 644                     if (rLine.startsWith("IDENTIFIER")) {
 645                         result = rLine.split("=");
 646                         toolsDefIdentifier = (result[1]).trim();
 647                     } else if ((!rLine.startsWith("#")) && (rLine.contains("="))) {
 648                         result = rLine.split("=");
 649                         toolsDefFields = ((result[0]).trim()).split("_");
 650                         if (toolsDefTargetNames == null) {
 651                             toolsDefTargetNames = (toolsDefFields[toolsDefTargetNameField]).trim() + " ";
 652                         } else if (!toolsDefTargetNames.contains((toolsDefFields[toolsDefTargetNameField]).trim())) {
 653                             toolsDefTargetNames += (toolsDefFields[toolsDefTargetNameField]).trim() + " ";
 654                         }
 655                         if (toolsDefTagNames == null) {
 656                             toolsDefTagNames = (toolsDefFields[toolsDefTagNameField]).trim() + " ";
 657                         } else if (!toolsDefTagNames.contains((toolsDefFields[toolsDefTagNameField]).trim())) {
 658                             toolsDefTagNames += (toolsDefFields[toolsDefTagNameField]).trim() + " ";
 659                         }
 660                         if (toolsDefArchNames == null) {
 661                             toolsDefArchNames = (toolsDefFields[toolsDefArchNameField]).trim() + " ";
 662                         } else if (!toolsDefArchNames.contains((toolsDefFields[toolsDefArchNameField]).trim())) {
 663                             toolsDefArchNames += (toolsDefFields[toolsDefArchNameField]).trim() + " ";
 664                         }
 665                     }
 666                     lineCounter++;
 667                 }
 668                 reader.close();
 669                 // Only enable Architecture selection based on tool chain installations
 670                 String turnOff = "";
 671                 if (!toolsDefArchNames.contains("EBC"))
 672                     turnOff = "EBC ";
 673                 if (!toolsDefArchNames.contains("PPC"))
 674                     turnOff += "PPC ";
 675                 if (!toolsDefArchNames.contains("IPF"))
 676                     turnOff += "IPF ";
 677                 if (!toolsDefArchNames.contains("X64"))
 678                     turnOff += "X64 ";
 679                 if (!toolsDefArchNames.contains("IA32"))
 680                     turnOff += "X64 ";
 681                 if (!toolsDefArchNames.contains("ARM"))
 682                     turnOff += "ARM ";
 683                 turnOff = turnOff.trim();
 684                 vDisableArchList = stringToVector(turnOff);
 685
 686                 if (!toolsDefTargetNames.matches("[A-Z]+")) {
 687                     toolsDefTargetNames = toolsDefTargetNames.replace("* ", "").trim();
 688                     if (Debug)
 689                         System.out.println("tools_def file does not define build targets: '" + toolsDefTargetNames
 690                                            + "'");
 691                     buildTargetsExist = false;
 692                 }
 693             } catch (IOException e) {
 694                 Log.log(toolsConfFile + " Read Error ", e.getMessage());
 695                 e.printStackTrace();
 696             }
 697         }
 698         return buildTargetsExist;
 699     }
 700
 701     private void readTargetTxtFile() {
 702         File tFile = new File(targetFile);
 703
 704         if (tFile.exists()) {
 705             try {
 706                 FileReader fileReader = new FileReader(targetFile);
 707                 BufferedReader reader = new BufferedReader(fileReader);
 708                 targetLineNumberMax = 0;
 709                 String rLine = null;
 710                 while ((rLine = reader.readLine()) != null) {
 711                     targetFileContents[targetLineNumberMax] = rLine;
 712                     if (rLine.startsWith("ACTIVE_PLATFORM")) {
 713                         // Only one active platform is permitted!
 714                         targetLines[activePlatformId] = rLine;
 715                         targetLineNumber[activePlatformId] = targetLineNumberMax;
 716                     }
 717                     if ((rLine.startsWith("TARGET" + " ")) || (rLine.startsWith("TARGET" + "\t"))
 718                         || (rLine.startsWith("TARGET="))) {
 719                         // Handle multiple Target Names
 720                         if (rLine.contains(","))
 721                             targetLines[buildTargetId] = rLine.trim().replaceAll(",", " ");
 722                         else
 723                             targetLines[buildTargetId] = rLine.trim();
 724                         targetLineNumber[buildTargetId] = targetLineNumberMax;
 725                     }
 726                     if (rLine.startsWith("TARGET_ARCH")) {
 727                         // Handle multiple Target Architectures
 728                         if (rLine.contains(","))
 729                             targetLines[targetArchId] = rLine.trim().replaceAll(",", " ");
 730                         else
 731                             targetLines[targetArchId] = rLine.trim();
 732                         targetLineNumber[targetArchId] = targetLineNumberMax;
 733                     }
 734                     if (rLine.startsWith("TOOL_CHAIN_CONF")) {
 735                         // Only one file is permitted
 736                         targetLines[toolDefFileId] = rLine.trim();
 737                         targetLineNumber[toolDefFileId] = targetLineNumberMax;
 738                     }
 739
 740                     if (rLine.startsWith("TOOL_CHAIN_TAG")) {
 741                         // Handle multiple Tool TagNames
 742                         if (rLine.contains(","))
 743                             targetLines[tagNameId] = rLine.trim().replaceAll(",", " ");
 744                         else
 745                             targetLines[tagNameId] = rLine.trim();
 746                         targetLineNumber[tagNameId] = targetLineNumberMax;
 747                     }
 748
 749                     if (rLine.startsWith("MULTIPLE_THREAD")) {
 750                         // Handle Thread Enable flag
 751                         targetLines[threadEnableId] = rLine.trim();
 752                         targetLineNumber[threadEnableId] = targetLineNumberMax;
 753                         if ((rLine.trim().toLowerCase().contains("enabled")) || (rLine.trim().toLowerCase().contains("true"))) {
 754                             threadEnabled = true;
 755                         } else {
 756                             threadEnabled = false;
 757                         }
 758                     }
 759
 760                     if (rLine.startsWith("MAX_CONCURRENT_THREAD_NUMBER")) {
 761                         // Handle Thread Enable flag
 762                         targetLines[threadCountId] = rLine.trim();
 763                         targetLineNumber[threadCountId] = targetLineNumberMax;
 764                     }
 765                     targetLineNumberMax++;
 766                 }
 767                 reader.close();
 768                 String archLine[] = new String[2];
 769                 if (targetLines[targetArchId] != null) {
 770                     if (targetLines[targetArchId].contains("=")) {
 771                         if (targetLines[targetArchId].contains(","))
 772                             targetLines[targetArchId] = targetLines[targetArchId].trim().replaceAll(",", " ");
 773                         if (targetLines[targetArchId].length() > 0)
 774                             archLine = targetLines[targetArchId].trim().split("=");
 775                         vArchList = stringToVector(archLine[1]);
 776                     }
 777                 }
 778
 779                 if (targetLines[threadCountId] != null) {
 780                     String tcLine[] = new String[2];
 781                     tcLine = targetLines[threadCountId].trim().split("=");
 782                     threadCount = tcLine[1];
 783                 } else
 784                     threadCount = "";
 785
 786                 if (Debug == true)
 787                     for (int i = 0; i <= maxTargetLines; i++)
 788                         System.out.println("targetLines[" + i + "] contains: " + targetLines[i] + " index is: "
 789                                            + targetLineNumber[i]);
 790             } catch (IOException e) {
 791                 Log.log(this.targetFile + " Read Error ", e.getMessage());
 792                 e.printStackTrace();
 793             }
 794         }
 795
 796     }
 797
 798     /**
 799      * This method initializes jContentPane
 800      *
 801      * @return javax.swing.JPanel jContentPane
 802      *
 803      */
 804     private JPanel getJContentPane() {
 805         if (jContentPane == null) {
 806             jLabelToolsConfigFile = new JLabel();
 807             jLabelToolsConfigFile.setBounds(new java.awt.Rectangle(labelColumn, toolConfigFileRow, labelWidth,
 808                                                                    oneRowHeight));
 809             jLabelToolsConfigFile.setText("Tool Chain Definition File");
 810             jLabelActivePlatform = new JLabel();
 811             jLabelActivePlatform.setText("Select Active Platform");
 812             jLabelActivePlatform.setBounds(new java.awt.Rectangle(labelColumn, activePlatformRow, labelWidth,
 813                                                                   oneRowHeight));
 814             jLabelToolChainTagName = new JLabel();
 815             jLabelToolChainTagName.setBounds(new java.awt.Rectangle(labelColumn, toolChainTagNameRow, labelWidth,
 816                                                                     oneRowHeight));
 817             jLabelToolChainTagName.setText("Select Tool Tag Name");
 818             jLabelBuildTarget = new JLabel();
 819             jLabelBuildTarget.setBounds(new java.awt.Rectangle(labelColumn, buildTargetRow, labelWidth, oneRowHeight));
 820             jLabelBuildTarget.setText("Select Build Target");
 821             jLabelTargetArch = new JLabel();
 822             jLabelTargetArch.setBounds(new java.awt.Rectangle(labelColumn, targetArchRow, labelWidth, oneRowHeight));
 823             jLabelTargetArch.setText("Build Architectures");
 824
 825             jArchCheckBox = new ArchCheckBox();
 826             jArchCheckBox.setBounds(new java.awt.Rectangle(valueColumn, targetArchRow, valueWidth, oneRowHeight));
 827             jArchCheckBox.setPreferredSize(new java.awt.Dimension(valueWidth, oneRowHeight));
 828
 829             jLabelEnableThreads = new JLabel();
 830             jLabelEnableThreads.setBounds(new java.awt.Rectangle(labelColumn, threadRow, labelWidth, oneRowHeight));
 831             jLabelEnableThreads.setText("Enable Compiler Threading");
 832
 833             jLabelThreadCount = new JLabel();
 834             jLabelThreadCount.setBounds(new java.awt.Rectangle(valueColumn + 60, threadRow, labelWidth, oneRowHeight));
 835             jLabelThreadCount.setText("Number of threads to start");
 836
 837             jContentPane = new JPanel();
 838             jContentPane.setLayout(null);
 839             jContentPane.setPreferredSize(new java.awt.Dimension(dialogWidth - 10, dialogHeight - 10));
 840
 841             jContentPane.add(jLabelToolsConfigFile, null);
 842             jContentPane.add(getJTextFieldToolsConfigFile(), null);
 843             jContentPane.add(getJButtonBrowse(), null);
 844
 845             jContentPane.add(jLabelActivePlatform, null);
 846             jContentPane.add(getActivePlatform(), null);
 847
 848             jContentPane.add(jLabelToolChainTagName, null);
 849             jContentPane.add(getJScrollPaneTagName(), null);
 850
 851             jContentPane.add(jLabelBuildTarget, null);
 852             jContentPane.add(getJScrollPaneBuildTarget(), null);
 853
 854             jContentPane.add(jLabelTargetArch, null);
 855
 856             jArchCheckBox.setDisabledItems(vDisableArchList);
 857             jArchCheckBox.setSelectedItems(vArchList);
 858             jContentPane.add(jArchCheckBox, null);
 859
 860             jContentPane.add(jLabelEnableThreads, null);
 861             jContentPane.add(getCheckBoxEnableThreads(), null);
 862
 863             jContentPane.add(jLabelThreadCount, null);
 864             jContentPane.add(getTextFieldThreadCount(), null);
 865
 866             jContentPane.add(getJButtonSave(), null);
 867             jContentPane.add(getJButtonCancel(), null);
 868         }
 869         return jContentPane;
 870     }
 871
 872     /*
 873      * (non-Javadoc)
 874      *
 875      * @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
 876      *
 877      * Override actionPerformed to listen all actions
 878      *
 879      */
 880     public void actionPerformed(ActionEvent arg0) {
 881
 882         if (arg0.getSource() == jButtonBrowse) {
 883             // TODO: Call file browser, starting in $WORKSPACE/Tools/Conf directory
 884
 885         }
 886
 887         if (arg0.getSource() == jButtonSave) {
 888             saveTargetFile();
 889             JOptionPane.showMessageDialog(this, "<html>The target.txt file has been saved!"
 890                                                 + "<br>A copy of the original file, target.txt.bak has"
 891                                                 + "<br>also been created.</html>");
 892             this.exit();
 893         }
 894
 895         if (arg0.getSource() == jButtonCancel) {
 896             this.exit();
 897         }
 898
 899         if (arg0.getSource() == jCheckBoxEnableThreads) {
 900             if (jCheckBoxEnableThreads.isSelected() == false) {
 901                 threadCount = "";
 902                 jTextFieldThreadCount.setText(threadCount);
 903             }
 904         }
 905     }
 906
 907
 908     private void updateActivePlatform() {
 909         int lineAP;
 910         if (targetLines[activePlatformId] != null) {
 911             lineAP = targetLineNumber[activePlatformId];
 912         } else {
 913             lineAP = targetLineNumberMax;
 914             targetLineNumber[activePlatformId] = lineAP;
 915             targetLineNumberMax++;
 916         }
 917         if (jComboBoxActivePlatform.getSelectedItem() == "Do Not Set") {
 918             targetFileContents[lineAP] = "";
 919             targetLines[activePlatformId] = "";
 920         } else {
 921             targetFileContents[lineAP] = "ACTIVE_PLATFORM = " + jComboBoxActivePlatform.getSelectedItem() + "\r\n";
 922             targetLines[activePlatformId] = targetFileContents[lineAP];
 923         }
 924         if (Debug)
 925             System.out.println("Active Platform: " + targetFileContents[lineAP]);
 926     }
 927
 928     private void updateToolDefFile() {
 929         int lineTDF;
 930         if (targetLines[toolDefFileId] != null) {
 931             lineTDF = targetLineNumber[toolDefFileId];
 932         } else {
 933             lineTDF = targetLineNumberMax;
 934             targetLineNumber[toolDefFileId] = lineTDF;
 935             targetLineNumberMax++;
 936         }
 937         if (Debug)
 938             System.out.println("Tool Config File: " + jTextFieldToolsConfigFile.getText());
 939         if (jTextFieldToolsConfigFile.getText() == null) {
 940             targetFileContents[lineTDF] = "#MT#";
 941             targetLines[toolDefFileId] = "";
 942         } else {
 943             targetFileContents[lineTDF] = "TOOL_CHAIN_CONF = " + jTextFieldToolsConfigFile.getText();
 944             targetLines[toolDefFileId] = targetFileContents[lineTDF];
 945         }
 946     }
 947
 948     private void updateToolTagNames() {
 949         String sTagNames = vectorToString(iCheckBoxListTagName.getAllCheckedItemsString());
 950         int lineTTN;
 951
 952         if (targetLines[tagNameId] != null) {
 953             lineTTN = targetLineNumber[tagNameId];
 954         } else {
 955             lineTTN = targetLineNumberMax;
 956             targetLineNumber[tagNameId] = lineTTN;
 957             targetLineNumberMax++;
 958         }
 959
 960         if (Debug)
 961             System.out.println("Tag Name(s): " + sTagNames);
 962
 963         if (sTagNames.length() > 0) {
 964             targetFileContents[lineTTN] = "TOOL_CHAIN_TAG = " + sTagNames;
 965             targetLines[tagNameId] = targetFileContents[lineTTN];
 966         } else {
 967             targetFileContents[lineTTN] = "#MT#";
 968             targetLines[tagNameId] = "";
 969         }
 970     }
 971
 972     private void updateBuildTargets() {
 973         String sBuildTargets = vectorToString(iCheckBoxListBuildTarget.getAllCheckedItemsString());
 974         int lineBT;
 975
 976         if (targetLines[buildTargetId] != null) {
 977             lineBT = targetLineNumber[buildTargetId];
 978         } else {
 979             lineBT = targetLineNumberMax;
 980             targetLineNumber[buildTargetId] = lineBT;
 981             targetLineNumberMax++;
 982         }
 983         if (Debug)
 984             System.out.println("Build Target(s): " + sBuildTargets);
 985         if (sBuildTargets.length() > 0) {
 986             targetFileContents[lineBT] = "TARGET = " + sBuildTargets;
 987             targetLines[buildTargetId] = targetFileContents[lineBT];
 988         } else {
 989             targetFileContents[lineBT] = "#MT#";
 990             targetLines[buildTargetId] = "";
 991         }
 992
 993     }
 994
 995     private void updateArchitectures() {
 996         String sArchList = jArchCheckBox.getSelectedItemsString().trim();
 997
 998         if (Debug)
 999             System.out.println("Architectures: " + sArchList);
1000
1001         int lineSA;
1002         if (targetLines[targetArchId] != null) {
1003             lineSA = targetLineNumber[targetArchId];
1004         } else {
1005             lineSA = targetLineNumberMax;
1006             targetLineNumber[targetArchId] = lineSA;
1007             targetLineNumberMax++;
1008         }
1009         if (sArchList == "") {
1010             targetFileContents[lineSA] = "#MT#";
1011             targetLines[targetArchId] = "";
1012         } else {
1013             targetFileContents[lineSA] = "TARGET_ARCH = " + sArchList;
1014             targetLines[targetArchId] = targetFileContents[lineSA];
1015         }
1016
1017     }
1018
1019     private void updateEnableThreads() {
1020         int lineET;
1021         if (targetLines[threadEnableId] != null) {
1022             lineET = targetLineNumber[threadEnableId];
1023         } else {
1024             lineET = targetLineNumberMax;
1025             targetLineNumber[threadEnableId] = lineET;
1026             targetLineNumberMax++;
1027         }
1028         if (jCheckBoxEnableThreads.isSelected() == true) {
1029             targetFileContents[lineET] = "MULTIPLE_THREAD = enabled";
1030             targetLines[threadEnableId] = targetFileContents[lineET];
1031         } else {
1032             targetFileContents[lineET] = "#MT#";
1033             targetLines[threadEnableId] = "";
1034         }
1035     }
1036
1037     private void updateThreadCount() {
1038         int lineTC;
1039
1040         if (targetLines[threadCountId] != null) {
1041             lineTC = targetLineNumber[threadCountId];
1042         } else {
1043             lineTC = targetLineNumberMax;
1044             targetLineNumber[threadCountId] = lineTC;
1045             targetLineNumberMax++;
1046         }
1047         if (jCheckBoxEnableThreads.isSelected() == true) {
1048             // Threading must be enabled
1049             if (jTextFieldThreadCount.getText().length() > 0) {
1050                 // Thread Count must be greater than 0
1051                 Scanner scan = new Scanner(jTextFieldThreadCount.getText().trim());
1052                 if (scan.nextInt() > 0) {
1053                     targetFileContents[lineTC] = "MAX_CONCURRENT_THREAD_NUMBER = " + jTextFieldThreadCount.getText().trim();
1054                     targetLines[threadCountId] = targetFileContents[lineTC];
1055                 } else {
1056                     Log.wrn("Build Preferences", "Threading Enabled, but thread count is not set, setting to default of 1.");
1057                     targetFileContents[lineTC] = "MAX_CONCURRENT_THREAD_NUMBER = 1";
1058                     targetLines[threadCountId] = "MAX_CONCURRENT_THREAD_NUMBER = 1";
1059                 }
1060             } else {
1061                 Log.wrn("Build Preferences", "Threading Enabled, but thread count is not set, setting to default of 1.");
1062                 targetFileContents[lineTC] = "MAX_CONCURRENT_THREAD_NUMBER = 1";
1063                 targetLines[threadCountId] = "MAX_CONCURRENT_THREAD_NUMBER = 1";
1064             }
1065         } else {
1066             // Don't track threads if threading is not enabled
1067             targetFileContents[lineTC] = "#MT#";
1068             targetLines[threadCountId] = "";
1069             threadCount = "";
1070         }
1071
1072     }
1073     private String vectorToString(Vector<String> v) {
1074         String s = " ";
1075         for (int i = 0; i < v.size(); ++i) {
1076             s += v.get(i);
1077             s += " ";
1078         }
1079         return s.trim();
1080     }
1081
1082     protected Vector<String> stringToVector(String s) {
1083         if (s == null) {
1084             return null;
1085         }
1086         String[] sArray = s.split(" ");
1087         Vector<String> v = new Vector<String>();
1088         for (int i = 0; i < sArray.length; ++i) {
1089             v.add(sArray[i]);
1090         }
1091         return v;
1092     }
1093
1094     private void saveTargetFile() {
1095         updateActivePlatform();
1096         updateToolDefFile();
1097         updateToolTagNames();
1098         updateBuildTargets();
1099         updateArchitectures();
1100         updateEnableThreads();
1101         updateThreadCount();
1102
1103         try {
1104             copy(targetFile, targetFile + ".bak");
1105             FileWriter fileWriter = new FileWriter(targetFile);
1106             BufferedWriter writer = new BufferedWriter(fileWriter);
1107             for (int i = 0; i < targetLineNumberMax; i++) {
1108                 if (! targetFileContents[i].contains("#MT#"))
1109                     writer.write(targetFileContents[i] + "\n");
1110             }
1111             writer.close();
1112         } catch (IOException e) {
1113             Log.err(toolsConfFile + " Write Error ", e.getMessage());
1114             e.printStackTrace();
1115         }
1116     }
1117
1118     private void copy(String txtFile, String bakFile) throws IOException {
1119         File fromFile = new File(txtFile);
1120         File toFile = new File(bakFile);
1121         FileInputStream fromTxt = null;
1122         FileOutputStream toBak = null;
1123         try {
1124             fromTxt = new FileInputStream(fromFile);
1125             toBak = new FileOutputStream(toFile);
1126             byte[] buffer = new byte[4096];
1127             int bytes_read;
1128             while ((bytes_read = fromTxt.read(buffer)) != -1) {
1129                 toBak.write(buffer, 0, bytes_read);
1130             }
1131         } finally {
1132             if (fromTxt != null)
1133                 try {
1134                     fromTxt.close();
1135                 } catch (IOException e) {
1136                     Log.err(toolsConfFile + " Read Error ", e.getMessage());
1137
1138                 }
1139             if (toBak != null)
1140                 try {
1141                     toBak.close();
1142                 } catch (IOException e) {
1143                     Log.err(toolsConfFile + ".bak Write Error ", e.getMessage());
1144                 }
1145         }
1146     }
1147
1148     private void exit() {
1149         this.setVisible(false);
1150         if (bTarget != null) {
1151             bTarget.dispose();
1152         }
1153     }
1154 }