title: SwingPropertyChangeSupport refresh GUI after reading from a file
body: <p>Following on from my question last night: <a href="https://stackoverflow.com/questions/11827326/swingpropertychangesupport-to-dynamically-update-array-displayed-in-jtextarea">SwingPropertyChangeSupport to dynamically update JTextArea</a>, I'm trying to refresh a GUI after reading in a text file.</p>
  
  <p>I have an array which holds integers of two digits. I can update it dynamically by typing a string of digits into a text area, then choosing which index to modify. The string is broken into two-digit pieces and added sequentially. After typing in the String of characters and clicking a button, this method is called:</p>
  
  <pre><code>public void modifyArray() {
  
      // show dialog to retrieve entered address
      addressToModify = (String) JOptionPane
              .showInputDialog("At which location?");
  
      // convert to integer if decimal address entered
      memAddress = Integer.parseInt(addressToModify);
      arrayForUpdate.instructionsIn(codeIn.getText(), memAddress);
  }
  </code></pre>
  
  <p>This part of my code now works as expected. That is, if I type in "123456" and then enter location "0" (or "0000"), the display is updated to something like:</p>
  
  <pre><code>Index     0000   Value:   12
  Index     0001   Value:   34
  Index     0002   Value:   56
  Index     0003   Value:   00
  </code></pre>
  
  <p>I also have a text file containing a String comprised of four digits donating the array index, followed by a series of two-digit values to be added to the array. I can load this via a gui button/file chooser. The contents of the example file are:</p>
  
  <pre><code>0000123456
  </code></pre>
  
  <p>I have the following methods to process the file:</p>
  
  <pre><code>    public void readRecord(File fileName) {
  
      // create file reader
      try {
          FileReader reader = null;
          try {
              // open input file
              reader = new FileReader(fileName);
  
              // create scanner to read from file reader
              Scanner in = new Scanner(reader);
  
              // read each line and remove whitespace
              while (in.hasNextLine()) {
                  String line = in.nextLine().trim();
                  parseRecord(line);
              }
  
          } finally {
              // close reader assuming it was successfully opened
              if (reader != null)
                  reader.close();
          }
        } catch (IOException e) {
          e.printStackTrace();
      }
    }
  
  public void parseRecord(String record) {
  
      // create address substring from start, 4 long
      String addrString = record.substring(0, 3);
      int s1Address = Integer.parseInt(addrString);
  
      // create binary data substring (4 from start, up to end)
      String dataString = record.substring(4, record.length());
  
      // pass data string as parameter to InstructionsIn method
      arrayForUpdate.instructionsIn(dataString, s1Address);
  }
  </code></pre>
  
  <p>In both of the scenarios above, the "instructionsIn" method is called. In the first scenario  this results in the display being updated but in the second it doesn't and I can't figure out why. I was hoping someone might be able to spot something I'm missing.</p>
  
  <p>Here is a complete, simplified version of the code which runs:</p>
  
  <pre><code>import java.awt.BorderLayout;
  import java.awt.Color;
  import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;
  import java.awt.event.FocusListener;
  import java.beans.PropertyChangeEvent;
  import java.beans.PropertyChangeListener;
  import java.io.File;
  import java.io.FileReader;
  import java.io.IOException;
  import java.util.Scanner;
  
  import javax.swing.JButton;
  import javax.swing.JFileChooser;
  import javax.swing.JFrame;
  import javax.swing.JOptionPane;
  import javax.swing.JPanel;
  import javax.swing.JTextArea;
  import javax.swing.event.SwingPropertyChangeSupport;
  
  public class PropertyChangeExample extends JFrame implements ActionListener {
  
  private static final long serialVersionUID = 1L;
  private String addressToModify, mList;
  private int memAddress;
  private JTextArea codeIn, displayOutput;
  private S_Record sRec;
  private JButton loadButton, modifyArrayButton;
  private FocusListener focusListener;
  private JPanel displayPanel;
  private ArrayForUpdate arrayForUpdate = new ArrayForUpdate();
  
  public static void main(String[] arg) {
      PropertyChangeExample display = new PropertyChangeExample();
      display.setVisible(true);
  }
  
  public PropertyChangeExample() {
      setDefaultCloseOperation(EXIT_ON_CLOSE);
      setSize(450, 170);
      layoutLeft();
      layoutDisplay();
      layoutBottom();
  }
  
  public void layoutDisplay() {
      displayPanel = new JPanel();
      add(displayPanel, BorderLayout.CENTER);
      displayOutput = new JTextArea(32, 38);
      displayPanel.add(displayOutput);
      displayOutput.addFocusListener(focusListener);
  
      mList = arrayForUpdate.getBoundProperty();
      displayOutput.setText(mList);
  
      arrayForUpdate.addPropertyChangeListener(new PropertyChangeListener() {
  
          @Override
          public void propertyChange(PropertyChangeEvent pcEvt) {
              if (pcEvt.getPropertyName().equals(
                      ArrayForUpdate.BOUND_PROPERTY)) {
                  mList = (pcEvt.getNewValue().toString());
                  displayOutput.setText(mList);
              }
          }
      });
  }
  
  public void layoutLeft() {
      JPanel left = new JPanel();
      add(left, BorderLayout.WEST);
      codeIn = new JTextArea(10, 7);
      left.add(codeIn, BorderLayout.NORTH);
      codeIn.addFocusListener(focusListener);
  }
  
  public void layoutBottom() {
      JPanel bottom = new JPanel();
      bottom.setBackground(Color.LIGHT_GRAY);
      loadButton = new JButton("Load file");
      loadButton.addActionListener(this);
      bottom.add(loadButton);
      add(bottom, BorderLayout.SOUTH);
      modifyArrayButton = new JButton("Add value to array");
      modifyArrayButton.addActionListener(this);
      bottom.add(modifyArrayButton);
  }
  
  public void actionPerformed(ActionEvent ae) {
      if (ae.getSource() == modifyArrayButton) {
          modifyArray();
      }
  
      if (ae.getSource() == loadButton) {
          processInputFile();
      }
  }
  
  public void modifyArray() {
      addressToModify = (String) JOptionPane
              .showInputDialog("At which location?");
  
      // convert to integer if decimal address entered
      memAddress = Integer.parseInt(addressToModify);
      arrayForUpdate.instructionsIn(codeIn.getText(), memAddress);
  }
  
  public void processInputFile() {
  
      sRec = new S_Record();
      JFileChooser chooser = new JFileChooser();
      int returnVal = chooser.showOpenDialog(getParent());
      if (returnVal == JFileChooser.APPROVE_OPTION) {
          // create the file
          File file = chooser.getSelectedFile();
  
          // pass to readRecord method in S_Record class
          sRec.readRecord(file);
      }
   }
  }
  
  class S_Record {
  
  private ArrayForUpdate arrayForUpdate = new ArrayForUpdate();
  
  public void readRecord(File fileName) {
  
      // create file reader
      try {
          FileReader reader = null;
          try {
              // open input file
              reader = new FileReader(fileName);
  
              // create scanner to read from file reader
              Scanner in = new Scanner(reader);
  
              // read each line and remove whitespace
              while (in.hasNextLine()) {
                  String line = in.nextLine().trim();
                  parseRecord(line);
              }
          } finally {
              // close reader assuming it was successfully opened
              if (reader != null)
                  reader.close();
          }
      } catch (IOException e) {
          e.printStackTrace();
      }
  }
  
  public void parseRecord(String record) {
  
      // create address substring from start, 4 long
      String addrString = record.substring(0, 3);
  
      int s1Address = Integer.parseInt(addrString);
  
      // create binary data substring (4 from start, up to end)
      String dataString = record.substring(4, record.length());
  
      // pass data string as parameter to InstructionsIn method
      arrayForUpdate.instructionsIn(dataString, s1Address);
   }
  }
  
  class ArrayForUpdate {
  
  public static final String BOUND_PROPERTY = "bound property";
  private String boundProperty = "";
  private SwingPropertyChangeSupport spcSupport = new SwingPropertyChangeSupport(
          this);
  private int[] myArray;
  private final int MEM_LOCATIONS = 6;
  /** StringBuilder object for displaying memory */
  private StringBuilder mList;
  
  public ArrayForUpdate() {
  
      myArray = new int[MEM_LOCATIONS];
      for (int i = 0; i &lt; myArray.length; i++) {
          myArray[i] = 0;
      }
      setArrayyDisplayString();
  }
  
  /** 
   * method to create formatted string of array
   */
  public void setArrayyDisplayString() {
  
      // create StringBuilder for display in memory tab
      mList = new StringBuilder();
      for (int i = 0; i &lt; myArray.length; i++) {
  
          mList.append(String.format("%10s %04x %10s %02x", "Index:   ", i,
                  "Value:  ", myArray[i]));
          mList.append("\n");
      }
      setBoundProperty(mList.toString());
  }
  
  /**
   * This method takes in a string passed through from the GUI
   */
  public void instructionsIn(String codeIn, int loc) {
  
      String code = codeIn.trim();
      int len = code.length();
      int chunkLength = 2; // the length of each chunk of code
      int i = 0;
  
      // traverse entered code and split into 2 digit chunks
      for (i = 0; i &lt; len; i += chunkLength) {
  
          String chunk = code.substring(i, Math.min(len, i + chunkLength));
          int oc = Integer.parseInt(chunk, 16);
  
          // add the data to the array
          setArrayData(loc, oc);
          loc++;
      }
  }
  
  /**   
   * method to add data to the array
   */
  public void setArrayData(int a, int memData) {
      myArray[a] = memData;
      setArrayyDisplayString();
  }
  
  public String getBoundProperty() {
      return boundProperty;
  }
  
  /**
   * Method to implement changes to array for display
   * 
   * @param boundProperty - the String representing the memory array
   */
  public void setBoundProperty(String boundProperty) {
      String oldValue = this.boundProperty;
      String newValue = boundProperty;
      this.boundProperty = newValue;
      spcSupport.firePropertyChange(BOUND_PROPERTY, oldValue, newValue);
  }
  
  public void addPropertyChangeListener(PropertyChangeListener listener) {
      spcSupport.addPropertyChangeListener(listener);
   }
  }
  </code></pre>