Changeset 1989


Ignore:
Timestamp:
01/02/07 12:37:49 (13 years ago)
Author:
curtis
Message:

Whitespace.

Location:
trunk/loci
Files:
143 edited

Legend:

Unmodified
Added
Removed
  • trunk/loci/formats/DataTools.java

    r1806 r1989  
    224224  } 
    225225 
    226  
    227226  // -- Word decoding -- 
    228227 
  • trunk/loci/formats/FileStitcher.java

    r1988 r1989  
    497497  } 
    498498 
    499  
    500499  /* @see IFormatReader#getMetadataValue(String, String) */ 
    501500  public Object getMetadataValue(String id, String field) 
     
    590589    for (int i=0; i<readers.length; i++) readers[i].setIdMap(map); 
    591590  } 
    592  
    593591 
    594592  // -- Helper methods -- 
     
    883881  } 
    884882 
    885  
    886883} 
  • trunk/loci/formats/ImageTools.java

    r1988 r1989  
    931931  } 
    932932 
    933  
    934933  /** 
    935934   * Convert an arbitrary primitive type array with 3 samples per pixel to 
  • trunk/loci/formats/TiffTools.java

    r1867 r1989  
    189189  public static final int BIG = 0x4d; 
    190190 
    191  
    192191  // -- Constructor -- 
    193192 
  • trunk/loci/formats/in/NikonReader.java

    r1947 r1989  
    114114  /** The original IFD. */ 
    115115  protected Hashtable original; 
    116  
    117116 
    118117  // -- Constructor -- 
  • trunk/loci/ome/notebook/ClickableList.java

    r1505 r1989  
    190190            tableP.el.getAttribute("XMLName").toUpperCase() + "_ANNOTATION."; 
    191191 
    192  
    193192          childE = DOMUtil.createChild(stE, "Element"); 
    194193          childE.setAttribute("Name", "Name"); 
  • trunk/loci/ome/notebook/ClickableTable.java

    r1505 r1989  
    283283  } 
    284284 
    285  
    286285  // -- Static ClickableTable API Methods -- 
    287286 
  • trunk/loci/ome/notebook/MetadataNotebook.java

    r1506 r1989  
    324324  } 
    325325 
    326  
    327326  // -- ActionListener API methods -- 
    328327 
  • trunk/loci/ome/notebook/MetadataPane.java

    r1855 r1989  
    144144  /** Whether XML is being displayed in raw form. */ 
    145145  protected boolean raw; 
    146  
    147146 
    148147  // -- Constructor -- 
     
    699698      p.setEditor(); 
    700699    } 
    701  
    702700 
    703701    //set the displayed tab to be by default the first image 
  • trunk/loci/ome/upload/OMEUploader.java

    r1909 r1989  
    7777 
    7878  /** Construct a new OMEUploader for the specified server. */ 
    79   public OMEUploader(String server) {  
    80     this.server = server;  
     79  public OMEUploader(String server) { 
     80    this.server = server; 
    8181    files = new Vector(); 
    8282  } 
    8383 
    8484  /** Construct a new OMEUploader for the specified user on the server. */ 
    85   public OMEUploader(String server, String user, String pass)  
    86     throws UploadException  
     85  public OMEUploader(String server, String user, String pass) 
     86    throws UploadException 
    8787  { 
    8888    this.server = server; 
     
    9696 
    9797  /** Log in to the specified server, with the specified credentials. */ 
    98   public void login(String server, String user, String pass)  
     98  public void login(String server, String user, String pass) 
    9999    throws UploadException 
    100100  { 
     
    110110    v.add(user); 
    111111    v.add(pass); 
    112     
     112 
    113113    String xml = buildXML("createSession", v); 
    114114 
     
    120120    try { 
    121121      int ndx = sessionKey.indexOf("<string>"); 
    122       sessionKey = sessionKey.substring(ndx + 8,  
     122      sessionKey = sessionKey.substring(ndx + 8, 
    123123        sessionKey.indexOf("</string>")); 
    124124    } 
     
    129129    setupImport(0); 
    130130  } 
    131    
     131 
    132132  /** Log all users out of the current server. */ 
    133133  public void logout() { 
     
    143143   * image in the process.  If the "stitch" flag is set to true, then all files 
    144144   * that are similar to the given file will be uploaded as well. 
    145    *  
     145   * 
    146146   * @return the number of pixel bytes uploaded 
    147147   */ 
     
    170170      } 
    171171 
    172       String id = newPixels(f.getSizeX(file), f.getSizeY(file),  
    173         f.getSizeZ(file), f.getSizeC(file), f.getSizeT(file), bytesPerPixel);  
    174   
     172      String id = newPixels(f.getSizeX(file), f.getSizeY(file), 
     173        f.getSizeZ(file), f.getSizeC(file), f.getSizeT(file), bytesPerPixel); 
     174 
    175175      int num = f.getImageCount(file); 
    176176      int bytesUploaded = 0; 
     
    178178      for (int i=0; i<num; i++) { 
    179179        int[] coords = f.getZCTCoords(file, i); 
    180         bytesUploaded += uploadPlane(f.openBytes(file, i), coords[0],  
     180        bytesUploaded += uploadPlane(f.openBytes(file, i), coords[0], 
    181181          coords[1], coords[2], id, !f.isLittleEndian(file)); 
    182182      } 
     
    194194   * set to true, then all files that are similar to the given file will be 
    195195   * uploaded as well. 
    196    *  
    197    * @return the number of pixel bytes uploaded 
    198    */ 
    199   public int uploadFile(String file, boolean stitch, Integer image,  
     196   * 
     197   * @return the number of pixel bytes uploaded 
     198   */ 
     199  public int uploadFile(String file, boolean stitch, Integer image, 
    200200    Integer dataset) throws UploadException 
    201201  { 
     
    233233  } 
    234234 
    235   /**  
    236    * Upload a single BufferedImage to the server, creating a new  
    237    * image in the process.  If the 'close' flag is set,  
     235  /** 
     236   * Upload a single BufferedImage to the server, creating a new 
     237   * image in the process.  If the 'close' flag is set, 
    238238   * the pixels file will be closed. 
    239    *  
    240    * @return the number of pixel bytes uploaded 
    241    */ 
    242   public int uploadPlane(BufferedImage plane, int num, MetadataStore store,  
     239   * 
     240   * @return the number of pixel bytes uploaded 
     241   */ 
     242  public int uploadPlane(BufferedImage plane, int num, MetadataStore store, 
    243243    boolean close) throws UploadException 
    244244  { 
     
    256256  } 
    257257 
    258   /**  
    259    * Upload a single BufferedImage to the server, placing it in the  
     258  /** 
     259   * Upload a single BufferedImage to the server, placing it in the 
    260260   * given image, and optionally the given dataset.  If the 'close' flag is 
    261261   * set, the pixels file will be closed. 
    262    *  
    263    * @return the number of pixel bytes uploaded 
    264    */ 
    265   public int uploadPlane(BufferedImage plane, int num, MetadataStore store,  
     262   * 
     263   * @return the number of pixel bytes uploaded 
     264   */ 
     265  public int uploadPlane(BufferedImage plane, int num, MetadataStore store, 
    266266    Integer image, Integer dataset, boolean close) throws UploadException 
    267267  { 
    268268    if (!validLogin) throw new UploadException("Not logged in to the server."); 
    269    
     269 
    270270    byte[][] b = ImageTools.getBytes(plane); 
    271271    byte[] data = new byte[b.length * b[0].length]; 
     
    282282   * Upload a single byte array to the server, creating a new 
    283283   * image in the process.  Assumes the byte array represents the first plane. 
    284    *  
    285    * @return the number of pixel bytes uploaded 
    286    */ 
    287   public int uploadPlane(byte[] plane, int num, MetadataStore store,  
     284   * 
     285   * @return the number of pixel bytes uploaded 
     286   */ 
     287  public int uploadPlane(byte[] plane, int num, MetadataStore store, 
    288288    boolean close) throws UploadException 
    289289  { 
     
    317317   * Upload a single byte array to the server, placing it in the given image, 
    318318   * and optionally the given dataset. 
    319    *  
    320    * @return the number of pixel bytes uploaded 
    321    */ 
    322   public int uploadPlane(byte[] plane, int num, MetadataStore store,  
     319   * 
     320   * @return the number of pixel bytes uploaded 
     321   */ 
     322  public int uploadPlane(byte[] plane, int num, MetadataStore store, 
    323323    Integer image, Integer dataset, boolean close) throws UploadException 
    324324  { 
     
    343343    // check if the plane contains multiple channels; if so, we need to split 
    344344    // the plane and upload each channel separately 
    345   
     345 
    346346    int bytesPerChannel = sizeX * sizeY * bytesPerPixel; 
    347347    int bytesUploaded = 0; 
     
    352352          System.arraycopy(plane, i*bytesPerChannel, b, 0, bytesPerChannel); 
    353353          int[] indices = FormatReader.getZCTCoords( 
    354             xmlStore.getDimensionOrder(null), sizeZ, sizeC, sizeT,  
    355             sizeZ * sizeC * sizeT, false, num);   
    356           bytesUploaded +=  
     354            xmlStore.getDimensionOrder(null), sizeZ, sizeC, sizeT, 
     355            sizeZ * sizeC * sizeT, false, num); 
     356          bytesUploaded += 
    357357            uploadPlane(plane, indices[0], indices[1], indices[2], id, 
    358               xmlStore.getBigEndian(null).booleanValue());   
     358              xmlStore.getBigEndian(null).booleanValue()); 
    359359        } 
    360360 
     
    367367      } 
    368368      int[] indices = FormatReader.getZCTCoords( 
    369         xmlStore.getDimensionOrder(null), sizeZ, sizeC, sizeT,  
    370         sizeZ * sizeC * sizeT, false, num);   
     369        xmlStore.getDimensionOrder(null), sizeZ, sizeC, sizeT, 
     370        sizeZ * sizeC * sizeT, false, num); 
    371371      int bytes = uploadPlane(plane, indices[0], indices[1], indices[2], id, 
    372         xmlStore.getBigEndian(null).booleanValue());   
    373         
     372        xmlStore.getBigEndian(null).booleanValue()); 
     373 
    374374      if (close) { 
    375375        id = closePixels(id).trim(); 
     
    384384   * Upload an array of BufferedImages to the server, creating a new image 
    385385   * in the process. 
    386    *  
    387    * @return the number of pixel bytes uploaded 
    388    */ 
    389   public int uploadPlanes(BufferedImage[] planes, int first, int last,  
     386   * 
     387   * @return the number of pixel bytes uploaded 
     388   */ 
     389  public int uploadPlanes(BufferedImage[] planes, int first, int last, 
    390390    int step, MetadataStore store, boolean close) throws UploadException 
    391391  { 
     
    407407 
    408408    String id = newPixels(sizeX, sizeY, sizeZ, sizeC, sizeT, bytesPerPixel); 
    409      
    410     return uploadPlanes(planes, first, last, step, store, new Integer(id),  
    411       null, close);  
     409 
     410    return uploadPlanes(planes, first, last, step, store, new Integer(id), 
     411      null, close); 
    412412  } 
    413413 
     
    415415   * Upload an array of BufferedImages to the server, placing them in the given 
    416416   * image, and optionally the given dataset. 
    417    *  
    418    * @return the number of pixel bytes uploaded 
    419    */ 
    420   public int uploadPlanes(BufferedImage[] planes, int first, int last,  
    421     int step, MetadataStore store, Integer image, Integer dataset,  
     417   * 
     418   * @return the number of pixel bytes uploaded 
     419   */ 
     420  public int uploadPlanes(BufferedImage[] planes, int first, int last, 
     421    int step, MetadataStore store, Integer image, Integer dataset, 
    422422    boolean close) throws UploadException 
    423423  { 
     
    427427    int ndx = 0; 
    428428    for (int i=first; i<=last; i+=step) { 
    429       uploaded += uploadPlane(planes[ndx], i, store, image, dataset,  
     429      uploaded += uploadPlane(planes[ndx], i, store, image, dataset, 
    430430        i == last && close); 
    431431      ndx++; 
     
    437437   * Upload an array of byte arrays to the server, creating a new image 
    438438   * in the process. 
    439    *  
    440    * @return the number of pixel bytes uploaded 
    441    */ 
    442   public int uploadPlanes(byte[][] planes, int first, int last, int step,  
     439   * 
     440   * @return the number of pixel bytes uploaded 
     441   */ 
     442  public int uploadPlanes(byte[][] planes, int first, int last, int step, 
    443443    MetadataStore store, boolean close) throws UploadException 
    444444  { 
     
    458458      bytesPerPixel = Integer.parseInt(pixelType) / 8; 
    459459    } 
    460   
     460 
    461461    String id = newPixels(sizeX, sizeY, sizeZ, sizeC, sizeT, bytesPerPixel); 
    462      
     462 
    463463    return uploadPlanes(planes, first, last, step, store, new Integer(id), 
    464464      null, close); 
     
    468468   * Upload an array of byte arrays to the server, placing them in the given 
    469469   * image, and optionally the given dataset. 
    470    *  
    471    * @return the number of pixel bytes uploaded 
    472    */ 
    473   public int uploadPlanes(byte[][] planes, int first, int last, int step,  
    474     MetadataStore store, Integer image, Integer dataset, boolean close)  
     470   * 
     471   * @return the number of pixel bytes uploaded 
     472   */ 
     473  public int uploadPlanes(byte[][] planes, int first, int last, int step, 
     474    MetadataStore store, Integer image, Integer dataset, boolean close) 
    475475    throws UploadException 
    476476  { 
     
    480480    int ndx = 0; 
    481481    for (int i=first; i<=last; i+=step) { 
    482       uploaded += uploadPlane(planes[ndx], i, store, image, dataset,  
     482      uploaded += uploadPlane(planes[ndx], i, store, image, dataset, 
    483483        i == last && close); 
    484484      ndx++; 
     
    492492  private String sendRequest(String request) throws UploadException { 
    493493    try { 
    494       HttpURLConnection conn =  
    495         (HttpURLConnection) (new URL(server)).openConnection();   
    496      
     494      HttpURLConnection conn = 
     495        (HttpURLConnection) (new URL(server)).openConnection(); 
     496 
    497497      conn.setRequestMethod("POST"); 
    498498      conn.setDoOutput(true); 
     
    525525      for (int i=0; i<params.size(); i++) { 
    526526        request += "<param><value>" + params.get(i) + "</value></param>"; 
    527       }  
     527      } 
    528528 
    529529      request += "</params></methodCall>"; 
    530      
     530 
    531531      return request; 
    532532    } 
     
    539539  { 
    540540    try { 
    541       String boundary = "------------------------------" +  
     541      String boundary = "------------------------------" + 
    542542        System.currentTimeMillis(); 
    543543 
     
    560560        os.write(("name=\"" + keys.get(i) + "\"").getBytes()); 
    561561        if (keys.get(i).toString().equals("File")) { 
    562           String file = files == null || files.size() == 0 ? "unknown" :  
     562          String file = files == null || files.size() == 0 ? "unknown" : 
    563563            files.get(0).toString(); 
    564           os.write(("; filename=\"" + file + "\"" + lf +  
    565             "Content-Type: application/octet-stream").getBytes());  
     564          os.write(("; filename=\"" + file + "\"" + lf + 
     565            "Content-Type: application/octet-stream").getBytes()); 
    566566        } 
    567567        os.write((lf + lf + values.get(i) + lf + boundary + lf).getBytes()); 
     
    619619 
    620620  /** Upload a single plane to the given OMEIS pixels file. */ 
    621   private int uploadPlane(byte[] b, int z, int c, int t, String id,  
     621  private int uploadPlane(byte[] b, int z, int c, int t, String id, 
    622622    boolean bigEndian) throws UploadException 
    623623  { 
     
    642642    values.add(bigEndian ? "1" : "0"); 
    643643    values.add(new String(b)); 
    644    
     644 
    645645    int bytes = Integer.parseInt(buildMultipart(keys, values).trim()); 
    646646    return bytes; 
    647647  } 
    648648 
    649   /**  
    650    * Set everything up to begin the import.  
     649  /** 
     650   * Set everything up to begin the import. 
    651651   * 
    652652   * @param int size - the number of pixel bytes we expect to upload 
     
    654654  private void setupImport(long size) throws UploadException { 
    655655    if (files != null) files.clear(); 
    656      
     656 
    657657    try { 
    658658      rs = DataServer.getDefaultServices(server); 
     
    662662    rc = rs.getRemoteCaller(); 
    663663    rc.login(user, pass); 
    664     
     664 
    665665    df = (DataFactory) rs.getService(DataFactory.class); 
    666666    im = (ImportManager) rs.getService(ImportManager.class); 
     
    679679    } 
    680680    catch (Exception e) { throw new UploadException(e); } 
    681      
     681 
    682682    im.startImport(exp); 
    683683  } 
    684684 
    685   /**  
    686    * Parse and upload the given MetadataStore and link  
     685  /** 
     686   * Parse and upload the given MetadataStore and link 
    687687   * it to the given OMEIS ID. 
    688688   */ 
    689   private void uploadMetadata(MetadataStore store, String id)  
     689  private void uploadMetadata(MetadataStore store, String id) 
    690690    throws UploadException 
    691691  { 
    692692    OMEXMLMetadataStore xml = (OMEXMLMetadataStore) store; 
    693693 
    694     // upload the OME-XML  
     694    // upload the OME-XML 
    695695 
    696696    String xmlString = ""; 
     
    721721 
    722722    List imageIDs = rim.importFiles(v); 
    723      
     723 
    724724    // set the Image information 
    725725 
     
    776776    try { 
    777777      pf.setThumbnail(pixels, CompositingSettings.createDefaultPGISettings( 
    778         xml.getSizeZ(null).intValue(), xml.getSizeC(null).intValue(),  
     778        xml.getSizeZ(null).intValue(), xml.getSizeC(null).intValue(), 
    779779        xml.getSizeT(null).intValue())); 
    780780    } 
  • trunk/loci/ome/viewer/MetadataPane.java

    r1262 r1989  
    5151  protected static final String[] TREE_COLUMNS = {"Attribute", "Value"}; 
    5252 
    53  
    5453  // -- Fields - XML tree -- 
    5554 
     
    6968  protected DefaultTableModel treeTableModel; 
    7069 
    71  
    7270  // -- Fields - raw panel -- 
    7371 
     
    8078  /** Whether XML is being displayed in raw form. */ 
    8179  protected boolean raw; 
    82  
    8380 
    8481  // -- Constructor -- 
     
    155152    add(rawPanel); 
    156153  } 
    157  
    158154 
    159155  // -- MetadataPane API methods -- 
     
    233229  } 
    234230 
    235  
    236231  // -- Component API methods -- 
    237232 
    238233  /** Sets the initial size of the metadata pane to be reasonable. */ 
    239234  public Dimension getPreferredSize() { return new Dimension(700, 500); } 
    240  
    241235 
    242236  // -- Runnable API methods -- 
     
    275269    } 
    276270  } 
    277  
    278271 
    279272  // -- Helper methods -- 
     
    291284  } 
    292285 
    293  
    294286  // -- Utility methods -- 
    295287 
     
    304296  } 
    305297 
    306  
    307298  // -- Helper classes -- 
    308299 
  • trunk/loci/ome/viewer/MetadataViewer.java

    r1269 r1989  
    4141    Toolkit.getDefaultToolkit().getMenuShortcutKeyMask(); 
    4242 
    43  
    4443  // -- Fields -- 
    4544 
    4645  protected JFileChooser chooser; 
    4746  protected MetadataPane metadata; 
    48  
    4947 
    5048  // -- Constructor -- 
     
    8987  } 
    9088 
    91  
    9289  // -- MetadataViewer API methods -- 
    9390 
    9491  public void openFile(File file) { metadata.setOMEXML(file); } 
    95  
    9692 
    9793  // -- ActionListener API methods -- 
     
    117113  } 
    118114 
    119  
    120115  // -- Runnable API methods -- 
    121116 
     
    129124  } 
    130125 
    131  
    132126  // -- Helper methods -- 
    133127 
     
    137131  } 
    138132 
    139  
    140133  // -- Main method -- 
    141134 
  • trunk/loci/plugins/Exporter.java

    r1544 r1989  
    247247  } 
    248248 
    249  
    250249} 
  • trunk/loci/plugins/MetadataPane.java

    r1498 r1989  
    3939  protected static final String[] META_COLUMNS = {"Name", "Value"}; 
    4040 
    41  
    4241  // -- Fields -- 
    4342 
     
    5352  /** Table model backing metadata table. */ 
    5453  protected DefaultTableModel metaTableModel; 
    55  
    5654 
    5755  // -- Constructor -- 
  • trunk/loci/plugins/browser/CacheIndicator.java

    r1920 r1989  
    3838  protected double ratio; 
    3939  protected JScrollBar scroll; 
    40    
    4140 
    4241  public CacheIndicator(JScrollBar scroll) { 
     
    6564      int [] loadCount = new int[getWidth()]; 
    6665      int [] cacheCount = new int[getWidth()]; 
    67        
     66 
    6867      for(int i = 0;i < loadCount.length;i++) { 
    6968        loadCount[i] = 0; 
    7069        cacheCount[i] = 0; 
    7170      } 
    72        
     71 
    7372      //find how many entries of the cache are handled per pixel of indicator 
    7473      int perPixel; 
    7574      double integers = 2; 
    76       double dPerPixel = ratio * integers;   
    77        
     75      double dPerPixel = ratio * integers; 
     76 
    7877      if(DEBUG) System.out.println("Ratio: " + ratio); 
    7978      while(dPerPixel < 1) { 
     
    8180        dPerPixel = ratio * integers; 
    8281      } 
    83        
     82 
    8483      Double temp = new Double(integers); 
    8584      perPixel = temp.intValue(); 
    86        
     85 
    8786      if(DEBUG) System.out.println("PerPixel: " + perPixel); 
    88        
     87 
    8988      int colorAmount = 255 / perPixel; 
    9089      if(DEBUG) System.out.println("ColorAmount: " + colorAmount); 
    91        
     90 
    9291      for(int i = 0;i<loadList.length;i++) { 
    9392        boolean isLoaded = false; 
     
    117116      for(int i = 0;i<loadList.length;i++) { 
    118117        int toLoad = loadList[i]; 
    119          
     118 
    120119        //correct for bug with length 1 
    121120        if(loadList.length == 1) { 
     
    123122          prevLoad = toLoad; 
    124123        } 
    125          
     124 
    126125        if(startLoad == -1) { 
    127126          startLoad = toLoad; 
     
    139138        } 
    140139      } 
    141        
     140 
    142141      prevLoad = -1; 
    143142      startLoad = -1; 
     
    145144      for(int i = 0;i<cache.length;i++) { 
    146145        int toLoad = cache[i]; 
    147          
     146 
    148147        //correct for bug with length 1 
    149148        if(loadList.length == 1) { 
     
    151150          prevLoad = toLoad; 
    152151        } 
    153          
     152 
    154153        if(startLoad == -1) { 
    155154          startLoad = toLoad; 
     
    170169  } 
    171170 
    172   private int translate(int cacheIndex) {  
     171  private int translate(int cacheIndex) { 
    173172    Integer width = new Integer(scroll.getWidth()); 
    174173    double compSize = width.doubleValue(); 
  • trunk/loci/plugins/browser/CacheManager.java

    r1980 r1989  
    7070  /** The IFormatReader that handles conversion of formats.*/ 
    7171  private IFormatReader read; 
    72    
     72 
    7373  /** The FileStitcher we're using to stitch files.*/ 
    7474  private FileStitcher fs; 
    75    
     75 
    7676  /** The two axes scrollbars in the CustomWindow.*/ 
    7777  private JScrollBar zSel, tSel; 
    78    
     78 
    7979  /** The two indicators of the cache.*/ 
    8080  private CacheIndicator zInd, tInd; 
     
    145145  */ 
    146146  private boolean loop; 
    147    
     147 
    148148  /**flag to zap the cache entirely if dimensions are switched*/ 
    149149  private boolean zapCache; 
     
    18551855    if (DEBUG) System.out.println("CLEARING CACHE"); 
    18561856    quit = true; 
    1857      
     1857 
    18581858    int[] oldIndex = null; 
    1859      
     1859 
    18601860    boolean erase = true; 
    18611861    if(!zapCache) { 
     
    18711871      erase = false; 
    18721872    } 
    1873      
     1873 
    18741874    oldZ = curZ; 
    18751875    oldT = curT; 
     
    18791879    oldMode = curMode; 
    18801880    oldAxis = curAxis; 
    1881      
     1881 
    18821882    oldBackZ = curBackZ; 
    18831883    oldBackT = curBackT; 
     
    18861886    oldForwardT = curForwardT; 
    18871887    oldForwardC = curForwardC; 
    1888      
     1888 
    18891889    oldZPriority = curZPriority; 
    18901890    oldTPriority = curZPriority; 
    18911891    oldCPriority = curCPriority; 
    1892      
     1892 
    18931893    int[] newIndex = getToCache(false); 
    18941894 
     
    19301930    if (DEBUG) System.out.println("Cache Size after clear: " + getSize()); 
    19311931  } 
    1932    
     1932 
    19331933  protected void dimChange() { 
    19341934    zapCache = true; 
     
    19461946    } 
    19471947  } 
    1948    
     1948 
    19491949  protected void setIndicators(int aZ, int aT, int aC) { 
    19501950    zInd = db.cw.zIndicator; 
    19511951    tInd = db.cw.tIndicator; 
    1952    
     1952 
    19531953    Vector zInCache = new Vector(); 
    19541954    Vector tInCache = new Vector(); 
    1955      
     1955 
    19561956    for(int i = 0;i < sizeZ;i++) { 
    19571957      int index = -1; 
     
    19621962        LociDataBrowser.exceptionMessage(exc); 
    19631963      } 
    1964        
     1964 
    19651965      if (index != -1 && cache[index] != null) zInCache.add(new Integer(i)); 
    19661966    } 
    1967      
     1967 
    19681968    for(int i = 0;i < sizeT;i++) { 
    1969       int index = -1;  
     1969      int index = -1; 
    19701970      try { 
    19711971        index = read.getIndex(fileName, aZ - 1, aC - 1, i); 
     
    19741974        LociDataBrowser.exceptionMessage(exc); 
    19751975      } 
    1976        
     1976 
    19771977      if (index != -1 && cache[index] != null) tInCache.add(new Integer(i)); 
    19781978    } 
    1979      
     1979 
    19801980    int[] loadCopy = new int[loadList.length]; 
    19811981    System.arraycopy(loadList, 0, loadCopy, 0, loadList.length); 
    19821982    Arrays.sort(loadCopy); 
    1983      
     1983 
    19841984    Vector zLoad = new Vector(); 
    19851985    Vector tLoad = new Vector(); 
    1986      
     1986 
    19871987    for(int i = 0;i < loadCopy.length;i++) { 
    19881988      int[] coords = null; 
     
    20012001      } 
    20022002    } 
    2003      
     2003 
    20042004    if(DEBUG) { 
    20052005      System.out.println("Z in Cache: " + zInCache); 
     
    20082008      System.out.println("T in Load: " + tLoad); 
    20092009    } 
    2010      
     2010 
    20112011    int[] zC = makeInt(zInCache.toArray()); 
    20122012    int[] tC = makeInt(tInCache.toArray()); 
    20132013    int[] zL = makeInt(zLoad.toArray()); 
    20142014    int[] tL = makeInt(tLoad.toArray()); 
    2015      
     2015 
    20162016    Arrays.sort(zL); 
    20172017    Arrays.sort(tL); 
    2018      
     2018 
    20192019    zInd.setIndicator(zC, zL, sizeZ); 
    20202020    tInd.setIndicator(tC, tL, sizeT); 
    20212021  } 
    2022    
     2022 
    20232023  private static int [] makeInt(Object[] array) { 
    20242024    int [] result  = new int[array.length]; 
     
    20442044        cache[loadList[i]] = imp; 
    20452045      } 
    2046        
     2046 
    20472047      if(db.cw != null) { 
    20482048        int aC = 1; 
  • trunk/loci/plugins/browser/CustomWindow.java

    r1985 r1989  
    9191    ow = null; 
    9292    update = true; 
    93      
     93 
    9494    String id = db.id; 
    95      
     95 
    9696    FilePattern fp = null; 
    9797 
    9898    if(db.fStitch != null) { 
    9999      try { 
    100         fp = db.fStitch.getFilePattern(id);  
     100        fp = db.fStitch.getFilePattern(id); 
    101101        patternTitle = fp.getPattern(); 
    102102      } 
     
    173173      Class.forName("com.jgoodies.forms.layout.FormLayout"); // forms-1.0.4.jar 
    174174    } 
    175     catch (Throwable e) {  
     175    catch (Throwable e) { 
    176176      canDoXML = false; 
    177177    } 
     
    186186    channelPanel = new JPanel(switcher); 
    187187    channelPanel.setOpaque(false); 
    188      
     188 
    189189    channelBox = new JCheckBox("Transmitted"); 
    190190    channelBox.setBackground(Color.white); 
     
    210210    } 
    211211    else c = 1; 
    212      
     212 
    213213    setC(); 
    214214 
     
    217217    zPanel.add(zSliceSel,BorderLayout.CENTER); 
    218218    tPanel.add(tSliceSel,BorderLayout.CENTER); 
    219      
     219 
    220220    if(db.virtual) { 
    221221      zIndicator = new CacheIndicator(zSliceSel); 
     
    280280    update = true; 
    281281  } 
    282    
     282 
    283283  public int getC() { 
    284284    return c; 
     
    310310      c = channelBox.isSelected() ? 2 : 1; 
    311311      if (!hasThis) { 
    312         channelBox.setEnabled(false);     
     312        channelBox.setEnabled(false); 
    313313        c = 1; 
    314314      } 
     
    379379      int zVal = zSliceSel == null ? 1 : zSliceSel.getValue(); 
    380380      int tVal = tSliceSel == null ? 1 : tSliceSel.getValue(); 
    381    
     381 
    382382      int textGap = 0; 
    383    
     383 
    384384      int nSlices = db.numZ * db.numT * db.numC; 
    385385      int currentSlice = imp.getCurrentSlice(); 
    386386      if (db.manager != null) currentSlice = db.manager.getSlice(); 
    387    
     387 
    388388      StringBuffer sb = new StringBuffer(); 
    389389      sb.append(currentSlice); 
     
    414414        } 
    415415      } 
    416    
     416 
    417417      int width = imp.getWidth(), height = imp.getHeight(); 
    418418      Calibration cal = imp.getCalibration(); 
     
    462462      sb.append(size); 
    463463      sb.append("M"); 
    464    
     464 
    465465      Insets insets = super.getInsets(); 
    466466      g.drawString(sb.toString(), 5, insets.top + textGap); 
     
    530530    if(update) { 
    531531      JScrollBar src = (JScrollBar) adjustmentEvent.getSource(); 
    532    
     532 
    533533      z = zSliceSel.getValue(); 
    534534      t = tSliceSel.getValue(); 
    535    
     535 
    536536      if (!src.getValueIsAdjusting() || db.manager == null) showSlice(z, t, c); 
    537537      else showTempSlice(z,t,c); 
     
    544544    if(update) { 
    545545      JCheckBox channels = (JCheckBox) e.getSource(); 
    546        
     546 
    547547      z = zSliceSel.getValue(); 
    548548      t = tSliceSel.getValue(); 
    549549      c = channels.isSelected() ? 2 : 1; 
    550    
     550 
    551551      showSlice(z, t, c); 
    552552    } 
    553553  } 
    554    
     554 
    555555  // -- ChangeListener methods -- 
    556    
     556 
    557557  public void stateChanged(ChangeEvent e) { 
    558558    if(update) { 
  • trunk/loci/plugins/browser/ImagePlusWrapper.java

    r1980 r1989  
    6060 
    6161      // get # images in all matching files 
    62        
     62 
    6363      try { 
    6464        numTotal = fs.getImageCount(name); 
    65          
     65 
    6666        dim = fs.getDimensionOrder(name); 
    6767        sizeX = fs.getSizeX(name); 
  • trunk/loci/plugins/browser/ImagePreview.java

    r1925 r1989  
    6565      } 
    6666 
    67        
    68  
    6967      synchronized(ir) { 
    7068        String path = file.getAbsolutePath(); 
     
    9795      file = (File) e.getNewValue(); 
    9896      if (file == null) initial = true; 
    99       else if (file != null && file.isDirectory()) initial = true;  
     97      else if (file != null && file.isDirectory()) initial = true; 
    10098      update = true; 
    10199    } 
     
    109107    } 
    110108  } 
    111    
     109 
    112110  // -- Runnable API methods -- 
    113111 
  • trunk/loci/plugins/browser/LociDataBrowser.java

    r1985 r1989  
    5656  /** The file format reader used by the plugin. */ 
    5757  protected IFormatReader reader; 
    58    
     58 
    5959  /** The file stitcher used by the reader.*/ 
    6060  protected FileStitcher fStitch; 
    61    
     61 
    6262  /** The CustomWindow used to display data.*/ 
    6363  protected CustomWindow cw; 
     
    9696    reader = new ChannelSeparator(fStitch); 
    9797  } 
    98    
     98 
    9999  public LociDataBrowser(String name) { 
    100100    this(); 
     
    102102    virtual = true; 
    103103  } 
    104    
     104 
    105105  public LociDataBrowser(boolean merged) { 
    106106    fStitch = new FileStitcher(); 
     
    108108    else reader = new ChannelSeparator(fStitch); 
    109109  } 
    110    
     110 
    111111  public LociDataBrowser(String name, boolean merged) { 
    112112    this(merged); 
     
    114114    virtual = true; 
    115115  } 
    116    
     116 
    117117  public LociDataBrowser(IFormatReader r, FileStitcher fs, String name) { 
    118118    virtual = true; 
     
    124124  // -- LociDataBrowser API methods -- 
    125125 
    126   /**  
     126  /** 
    127127  * Displays the given ImageJ image in a 4D browser window. 
    128128  * NB: this method is needed only internally. Do not call. 
     
    144144    cw = new CustomWindow(this, imp, new ImageCanvas(imp)); 
    145145  } 
    146    
     146 
    147147  /** Set the length of each dimensional axis and the dimension order. */ 
    148148  public void setDimensions(int sizeZ, int sizeC, int sizeT, int z, 
     
    166166    tIndex = t; 
    167167  } 
    168    
     168 
    169169  /** Reset all dimensional data in case they've switched.*/ 
    170170  public void setDimensions() { 
    171171    String order = null; 
    172      
     172 
    173173    if (fStitch != null) { 
    174174      try { 
     
    202202      } 
    203203    } 
    204      
     204 
    205205    hasZ = numZ > 1; 
    206206    hasC = numC > 1; 
    207207    hasT = numT > 1; 
    208      
     208 
    209209    zIndex = order.indexOf("Z") - 2; 
    210210    cIndex = order.indexOf("C") - 2; 
     
    246246    series = Integer.parseInt(datasets.getNextChoice()); 
    247247  } 
    248    
     248 
    249249  public static void exceptionMessage(Exception exc) { 
    250250    String msg = exc.toString(); 
     
    253253     msg = msg + "\n" + ste[i].toString(); 
    254254    } 
    255      
     255 
    256256    IJ.showMessage(msg); 
    257257  } 
    258    
     258 
    259259  public void toggleCache(boolean cached) { 
    260260    if(cached) { 
     
    298298            IJ.log("virtual = " + virtual); 
    299299          } 
    300          
     300 
    301301          id = name; 
    302302          if (DEBUG) System.err.println("id = " + id); 
  • trunk/loci/plugins/browser/OptionsWindow.java

    r1983 r1989  
    5353  /** The CacheManager for this instance of data browser.*/ 
    5454  private CacheManager manager; 
    55    
     55 
    5656  /** The FileStitcher used to stich files together.*/ 
    5757  private FileStitcher fStitch; 
     
    5959  /** CheckBoxes to indicate which axes to store.*/ 
    6060  private JCheckBox zCheck,tCheck,cCheck; 
    61    
     61 
    6262  /** CheckBoxes to control if caching is on or off */ 
    6363  private JCheckBox cacheToggle; 
     
    8080  /** Storage of what priority settings used to be.*/ 
    8181  private int oldTop,oldMid,oldLow; 
    82    
     82 
    8383  FileStitcher fs; 
    84    
     84 
    8585  JComboBox[] blockBoxes; 
    8686  String id = null,order = null,suffix = null; 
     
    8989  int[] axes = null; 
    9090  FilePattern fp = null; 
    91    
     91 
    9292  JComboBox zGroup,tGroup,cGroup; 
    9393 
     
    100100 
    101101    manager = cw.db.manager; 
    102      
     102 
    103103    fs = cw.db.fStitch; 
    104104 
     
    106106 
    107107    Border etchB = BorderFactory.createEtchedBorder(EtchedBorder.LOWERED); 
    108      
     108 
    109109    // get FilePattern Data 
    110110    try { 
     
    147147      blockLabels[i].setForeground(getColor(i)); 
    148148    } 
    149      
     149 
    150150    Object[] choices = {"Z-Depth", "Time", "Channel"}; 
    151151    zGroup = new JComboBox(choices); 
     
    175175      blockBoxes[i] = temp; 
    176176    } 
    177      
     177 
    178178    JPanel slicePanel = new JPanel(); 
    179179    slicePanel.add(sliceLab); 
     
    195195    JLabel sufLab = new JLabel(suffix); 
    196196    filePane.add(sufLab); 
    197      
     197 
    198198    int[] internalSizes = new int[3]; 
    199199    for(int i = 0;i<internalSizes.length;i++) { 
    200200      internalSizes[i] = getOrderSize(i); 
    201201    } 
    202      
     202 
    203203    JLabel zLab = new JLabel("First ("+ internalSizes[0] + "):"); 
    204204    JLabel tLab = new JLabel("Second (" + internalSizes[1] + "):"); 
    205205    JLabel cLab = new JLabel("Third (" + internalSizes[2] + "):"); 
    206206    JLabel fileLab = new JLabel("Filename:"); 
    207      
     207 
    208208    String rowString = "pref," + TAB + ",pref,pref,pref," + TAB + 
    209209      ",pref,pref"; 
     
    211211      rowString += ",pref"; 
    212212    } 
    213      
     213 
    214214    FormLayout layout = new FormLayout( 
    215215        TAB + ",pref," + TAB + ",pref:grow," + TAB, 
     
    234234    for(int i = 0;i<blockLabels.length;i++) { 
    235235      disPane.add(blockLabels[i], cc.xy(2,9+i)); 
    236       disPane.add(blockBoxes[i], cc.xy(4,9+i));  
     236      disPane.add(blockBoxes[i], cc.xy(4,9+i)); 
    237237    } 
    238238 
     
    308308    tCheck.addItemListener(this); 
    309309    cCheck.addItemListener(this); 
    310      
     310 
    311311    cacheToggle = new JCheckBox("Cache Images (on/off)"); 
    312312    cacheToggle.setSelected(cw.db.virtual); 
    313313    cacheToggle.addItemListener(this); 
    314      
    315314 
    316315    String[] modes = {"Crosshair", "Rectangle", "Cross/Rect"}; 
     
    414413    pack(); 
    415414    setVisible(true); 
    416      
     415 
    417416    update = true; 
    418417  } 
    419    
     418 
    420419  private int getBoxIndex(JComboBox jcb) { 
    421420    for(int i = 0;i<blockBoxes.length;i++) { 
     
    444443          tempColor = tempColor.darker(); 
    445444        } 
    446         return tempColor;  
     445        return tempColor; 
    447446    } 
    448447  } 
     
    463462    return -1; 
    464463  } 
    465    
     464 
    466465  /** Set up the combo box to reflect appropriate axis.*/ 
    467466  private void setBox(JComboBox thisBox, int index) { 
     
    478477    } 
    479478  } 
    480    
     479 
    481480  private char convertInt(int index) { 
    482481    switch (index) { 
     
    491490    } 
    492491  } 
    493    
     492 
    494493  private int convertChar(char c) { 
    495494    switch (c) { 
     
    504503    } 
    505504  } 
    506    
     505 
    507506  private int getOrderSize(int i) { 
    508507    int thisSize = 1; 
     
    523522    return thisSize; 
    524523  } 
    525    
     524 
    526525  private int getBlockCount(int index) { 
    527526    int total = 0; 
     
    535534    return total; 
    536535  } 
    537    
     536 
    538537  private int getAxis(int i) { 
    539538    switch (i) { 
     
    689688        int sel = zGroup.getSelectedIndex(); 
    690689        char zChar = convertInt(sel); 
    691          
     690 
    692691        sel = tGroup.getSelectedIndex(); 
    693692        char tChar = convertInt(sel); 
    694693        if(tChar == zChar) tChar = oldChar; 
    695          
     694 
    696695        sel = cGroup.getSelectedIndex(); 
    697696        char cChar = convertInt(sel); 
    698697        if(cChar == zChar) cChar = oldChar; 
    699          
     698 
    700699        order = String.valueOf(zChar) + String.valueOf(tChar) 
    701700          + String.valueOf(cChar); 
     
    723722        int sel = tGroup.getSelectedIndex(); 
    724723        char tChar = convertInt(sel); 
    725          
     724 
    726725        sel = zGroup.getSelectedIndex(); 
    727726        char zChar = convertInt(sel); 
    728727        if(zChar == tChar) zChar = oldChar; 
    729          
     728 
    730729        sel = cGroup.getSelectedIndex(); 
    731730        char cChar = convertInt(sel); 
    732731        if(cChar == tChar) cChar = oldChar; 
    733          
     732 
    734733        order = String.valueOf(zChar) + String.valueOf(tChar) 
    735734          + String.valueOf(cChar); 
     
    757756        int sel = cGroup.getSelectedIndex(); 
    758757        char cChar = convertInt(sel); 
    759          
     758 
    760759        sel = zGroup.getSelectedIndex(); 
    761760        char zChar = convertInt(sel); 
    762761        if(zChar == cChar) zChar = oldChar; 
    763          
     762 
    764763        sel = tGroup.getSelectedIndex(); 
    765764        char tChar = convertInt(sel); 
    766765        if(tChar == cChar) tChar = oldChar; 
    767          
     766 
    768767        order = String.valueOf(zChar) + String.valueOf(tChar) 
    769768          + String.valueOf(cChar); 
  • trunk/loci/plugins/ome/MetaPanel.java

    r1346 r1989  
    169169  } 
    170170 
    171  
    172171  // -- OMEMetaDataHandler methods -- 
    173172 
  • trunk/loci/plugins/ome/OMEController.java

    r1346 r1989  
    121121 
    122122    cleanup(toRemove, true); 
    123  
    124123 
    125124    // iterate through the list and look for duplicates 
  • trunk/loci/plugins/ome/OMERetrieve.java

    r1273 r1989  
    255255  } 
    256256 
    257  
    258257  /** method that returns all image IDs in a certain project */ 
    259258  public static ArrayList getProjectImageIDs(Project project) { 
  • trunk/loci/plugins/ome/OMESidePanel.java

    r1346 r1989  
    258258  } 
    259259 
    260  
    261260  // -- ActionListener methods -- 
    262261 
     
    309308  } 
    310309 
    311  
    312310  // -- Utility methods -- 
    313311 
  • trunk/loci/plugins/ome/OMETools.java

    r1970 r1989  
    221221    exc.printStackTrace(); 
    222222  } 
    223  
    224223 
    225224  // -- Upload methods -- 
  • trunk/loci/visbio/BioDropHandler.java

    r1264 r1989  
    4444  private VisBioFrame bio; 
    4545 
    46  
    4746  // -- Constructor -- 
    4847 
     
    5251    this.bio = bio; 
    5352  } 
    54  
    5553 
    5654  // -- TransferHandler API methods -- 
  • trunk/loci/visbio/BioTask.java

    r1264 r1989  
    4444  protected boolean stopped = false; 
    4545 
    46  
    4746  // -- GUI components -- 
    4847 
     
    5857  /** Button for halting and resuming the task. */ 
    5958  protected JButton stop; 
    60  
    6159 
    6260  // -- Constructor -- 
     
    9492    add(builder.getPanel()); 
    9593  } 
    96  
    9794 
    9895  // -- BioTask API methods -- 
     
    132129  public boolean isStopped() { return stopped; } 
    133130 
    134  
    135131  // -- Component API methods -- 
    136132 
     
    140136    return new Dimension(max.width, pref.height); 
    141137  } 
    142  
    143138 
    144139  // -- ActionListener methods -- 
  • trunk/loci/visbio/ConsoleManager.java

    r1264 r1989  
    4646    "Dump output to console rather than graphical windows"; 
    4747 
    48  
    4948  // -- Fields -- 
    5049 
     
    6766  private boolean debug; 
    6867 
    69  
    7068  // -- Constructor -- 
    7169 
    7270  /** Constructs an exit manager. */ 
    7371  public ConsoleManager(VisBioFrame bio) { super(bio); } 
    74  
    7572 
    7673  // -- ConsoleManager API methods -- 
     
    10097  public boolean isDebug() { return debug; } 
    10198 
    102  
    10399  // -- Menu commands -- 
    104100 
     
    109105    else if (console.equals("out")) wm.showWindow(out.getWindow()); 
    110106  } 
    111  
    112107 
    113108  // -- LogicManager API methods -- 
     
    135130  public int getTasks() { return 2; } 
    136131 
    137  
    138132  // -- OutputListener API methods -- 
    139133 
     
    150144    } 
    151145  } 
    152  
    153146 
    154147  // -- Helper methods -- 
  • trunk/loci/visbio/ControlPanel.java

    r1264 r1989  
    4141  protected String tip; 
    4242 
    43  
    4443  // -- Constructor -- 
    4544 
     
    5251    setLayout(new BorderLayout()); 
    5352  } 
    54  
    5553 
    5654  // -- ControlPanel API methods -- 
  • trunk/loci/visbio/ExitManager.java

    r1264 r1989  
    3636  private boolean exitOk; 
    3737 
    38  
    3938  // -- Constructor -- 
    4039 
     
    4241  public ExitManager(VisBioFrame bio) { super(bio); } 
    4342 
    44  
    4543  // -- ExitManager API methods -- 
    4644 
    4745  /** Trip flag indicating shutdown process should not continue. */ 
    4846  public void cancelShutdown() { exitOk = false; } 
    49  
    5047 
    5148  // -- LogicManager API methods -- 
     
    6259  /** Gets the number of tasks required to initialize this logic manager. */ 
    6360  public int getTasks() { return 2; } 
    64  
    6561 
    6662  // -- Helper methods -- 
     
    8177    } 
    8278  } 
    83  
    8479 
    8580  // -- WindowListener API methods -- 
     
    106101  public void windowOpened(WindowEvent e) { } 
    107102 
    108  
    109103  // -- Menu commands -- 
    110104 
  • trunk/loci/visbio/LogicManager.java

    r1264 r1989  
    3636  protected VisBioFrame bio; 
    3737 
    38  
    3938  // -- Constructor -- 
    4039 
    4140  /** Constructs a logic manager. */ 
    4241  public LogicManager(VisBioFrame bio) { this.bio = bio; } 
    43  
    4442 
    4543  // -- LogicManager API methods -- 
     
    5452  public int getTasks() { return 0; } 
    5553 
    56  
    5754  // -- Saveable API methods -- 
    5855 
  • trunk/loci/visbio/MacAdapter.java

    r1390 r1989  
    4444  private VisBioFrame bio; 
    4545 
    46  
    4746  // -- Constructor -- 
    4847 
    4948  /** Constructs a Mac OS X adapter. */ 
    5049  public MacAdapter(VisBioFrame bio) { this.bio = bio; } 
    51  
    5250 
    5351  // -- MacAdapter API methods -- 
     
    5957    app.addApplicationListener(new MacAdapter(bio)); 
    6058  } 
    61  
    6259 
    6360  // -- ApplicationAdapter API methods -- 
  • trunk/loci/visbio/PanelManager.java

    r1264 r1989  
    6363  private JPanel pane; 
    6464 
    65  
    6665  // -- Constructor -- 
    6766 
    6867  /** Constructs a panel manager. */ 
    6968  public PanelManager(VisBioFrame bio) { super(bio); } 
    70  
    7169 
    7270  // -- PanelManager API methods -- 
     
    103101    return null; 
    104102  } 
    105  
    106103 
    107104  // -- LogicManager API methods -- 
     
    171168  public int getTasks() { return 2; } 
    172169 
    173  
    174170  // -- Helper methods -- 
    175171 
  • trunk/loci/visbio/SystemControls.java

    r1492 r1989  
    5050  private JTextField lafField; 
    5151 
    52  
    5352  // -- Fields -- 
    5453 
    5554  /** Current memory usage. */ 
    5655  protected String memUsage; 
    57  
    5856 
    5957  // -- Constructor -- 
     
    240238    t.start(); 
    241239  } 
    242  
    243240 
    244241  // -- ActionListener API methods -- 
     
    351348  } 
    352349 
    353  
    354350  // -- Utility methods -- 
    355351 
  • trunk/loci/visbio/SystemManager.java

    r1264 r1989  
    4848  private JFrame systemFrame; 
    4949 
    50  
    5150  // -- Constructor -- 
    5251 
    5352  /** Constructs a system manager. */ 
    5453  public SystemManager(VisBioFrame bio) { super(bio); } 
    55  
    5654 
    5755  // -- SystemManager API methods -- 
     
    196194  } 
    197195 
    198  
    199196  // -- Menu commands -- 
    200197 
     
    205202    wm.showWindow(systemFrame); 
    206203  } 
    207  
    208204 
    209205  // -- LogicManager API methods -- 
     
    221217  public int getTasks() { return 2; } 
    222218 
    223  
    224219  // -- ActionListener API methods -- 
    225220 
     
    228223    System.out.println(System.currentTimeMillis() + ": " + getMemoryUsage()); 
    229224  } 
    230  
    231225 
    232226  // -- Runnable API methods -- 
     
    239233    wm.setWaitCursor(false); 
    240234  } 
    241  
    242235 
    243236  // -- Helper methods -- 
     
    265258  } 
    266259 
    267  
    268260  // -- Utility methods -- 
    269261 
  • trunk/loci/visbio/TaskControls.java

    r1264 r1989  
    3939  private JScrollPane scroll; 
    4040 
    41  
    4241  // -- Constructor -- 
    4342 
     
    5958  } 
    6059 
    61  
    6260  // -- TaskControls API methods -- 
    6361 
  • trunk/loci/visbio/TaskEvent.java

    r1264 r1989  
    3838  protected String status; 
    3939 
    40  
    4140  // -- Constructor -- 
    4241 
     
    4746    status = message; 
    4847  } 
    49  
    5048 
    5149  // -- TaskEvent API methods -- 
  • trunk/loci/visbio/TaskManager.java

    r1264 r1989  
    3434  protected TaskControls taskControls; 
    3535 
    36  
    3736  // -- Constructor -- 
    3837 
    3938  /** Constructs a tasks manager. */ 
    4039  public TaskManager(VisBioFrame bio) { super(bio); } 
    41  
    4240 
    4341  // -- TaskManager API methods -- 
     
    5654  public TaskControls getControls() { return taskControls; } 
    5755 
    58  
    5956  // -- LogicManager API methods -- 
    6057 
     
    7067  /** Gets the number of tasks required to initialize this logic manager. */ 
    7168  public int getTasks() { return 2; } 
    72  
    7369 
    7470  // -- Helper methods -- 
  • trunk/loci/visbio/VisBio.java

    r1744 r1989  
    6262  public static final int INSTANCE_PORT = 0xabcd; 
    6363 
    64  
    6564  // -- Constructor -- 
    6665 
    6766  /** Ensure this class can't be externally instantiated. */ 
    6867  private VisBio() { } 
    69  
    7068 
    7169  // -- VisBio API methods -- 
     
    110108  } 
    111109 
    112  
    113110  // -- Thread API methods -- 
    114111 
     
    118115    catch (Exception exc) { exc.printStackTrace(); } 
    119116  } 
    120  
    121117 
    122118  // -- Main -- 
  • trunk/loci/visbio/VisBioEvent.java

    r1264 r1989  
    3737  public static final int STATE_CHANGED = 2; 
    3838 
    39  
    4039  // -- Fields -- 
    4140 
     
    4847  /** Flag indicating whether event is undoable. */ 
    4948  private boolean undoable; 
    50  
    5149 
    5250  // -- Constructor -- 
     
    6159    this.undoable = undoable; 
    6260  } 
    63  
    6461 
    6562  // -- VisBioEvent API methods -- 
  • trunk/loci/visbio/VisBioFrame.java

    r1746 r1989  
    5757    "true".equalsIgnoreCase(System.getProperty("visbio.debug")); 
    5858 
    59  
    6059  // -- Fields -- 
    6160 
     
    7170  /** Instance server for this instance of VisBio. */ 
    7271  protected InstanceServer instanceServer; 
    73  
    7472 
    7573  // -- Constructor -- 
     
    221219  } 
    222220 
    223  
    224221  // -- VisBioFrame API methods -- 
    225222 
     
    376373  } 
    377374 
    378  
    379375  // -- ActionListener API methods -- 
    380376 
     
    388384    else call(cmd); 
    389385  } 
    390  
    391386 
    392387  // -- Runnable API methods -- 
     
    434429  } 
    435430 
    436  
    437431  // -- SpawnListener API methods -- 
    438432 
  • trunk/loci/visbio/WindowInfo.java

    r1492 r1989  
    4040  protected static int gap; 
    4141 
    42  
    4342  // -- Fields -- 
    4443 
     
    5150  /** True if the window has not yet been shown onscreen. */ 
    5251  protected boolean first; 
    53  
    5452 
    5553  // -- Constructor -- 
     
    6664    window.addWindowListener(this); 
    6765  } 
    68  
    6966 
    7067  // -- WindowInfo API methods -- 
     
    10198  public Window getWindow() { return window; } 
    10299 
    103  
    104100  // -- WindowListener API methods -- 
    105101 
  • trunk/loci/visbio/WindowManager.java

    r1492 r1989  
    4949    "Hide all windows when main window is minimized"; 
    5050 
    51  
    5251  // -- Fields -- 
    5352 
     
    7372  protected boolean distributed; 
    7473 
    75  
    7674  // -- Fields - initial state -- 
    7775 
     
    7977  protected Hashtable windowStates = new Hashtable(); 
    8078 
    81  
    8279  // -- Constructor -- 
    8380 
    8481  /** Constructs a window manager. */ 
    8582  public WindowManager(VisBioFrame bio) { super(bio); } 
    86  
    8783 
    8884  // -- WindowManager API methods -- 
     
    211207  } 
    212208 
    213  
    214209  // -- LogicManager API methods -- 
    215210 
     
    237232  public int getTasks() { return 2; } 
    238233 
    239  
    240234  // -- WindowListener API methods -- 
    241235 
     
    259253  public void windowDeactivated(WindowEvent e) { } 
    260254  public void windowOpened(WindowEvent e) { } 
    261  
    262255 
    263256  // -- Saveable API methods -- 
     
    301294  } 
    302295 
    303  
    304296  // -- Helper methods -- 
    305297 
  • trunk/loci/visbio/WindowState.java

    r1264 r1989  
    4444  protected int width, height; 
    4545 
    46  
    4746  // -- Constructor -- 
    4847 
     
    5857    this.height = height; 
    5958  } 
    60  
    6159 
    6260  // -- WindowInfo API methods -- 
     
    9492  public int getHeight() { return height; } 
    9593 
    96  
    9794  // -- Object API methods -- 
    9895 
  • trunk/loci/visbio/data/ArbitrarySlice.java

    r1390 r1989  
    5656  private static final float T4SIN = (float) (RADIUS6 * Math.sin(THETA4)); 
    5757 
    58  
    5958  // -- Fields -- 
    6059 
     
    8281  /** Controls for the arbitrary slice. */ 
    8382  protected SliceWidget controls; 
    84  
    8583 
    8684  // -- Constructor -- 
     
    9593    parent.addTransformListener(this); 
    9694  } 
    97  
    9895 
    9996  // -- ArbitrarySlice API methods -- 
     
    180177  /** Gets whether arbitary slice is computed. */ 
    181178  public boolean isSliceComputed() { return compute; } 
    182  
    183179 
    184180  // -- Static DataTransform API methods -- 
     
    206202  /** Indicates whether this transform type requires a parent transform. */ 
    207203  public static boolean isParentRequired() { return true; } 
    208  
    209204 
    210205  // -- DataTransform API methods -- 
     
    503498  public JComponent getControls() { return controls; } 
    504499 
    505  
    506500  // -- Dynamic API methods -- 
    507501 
     
    555549    controls = new SliceWidget(this); 
    556550  } 
    557  
    558551 
    559552  // -- Saveable API methods -- 
     
    586579  } 
    587580 
    588  
    589581  // -- TransformListener API methods -- 
    590582 
     
    597589    } 
    598590  } 
    599  
    600591 
    601592  // -- Helper methods -- 
  • trunk/loci/visbio/data/CollapseTransform.java

    r1264 r1989  
    5050  protected CollapseWidget controls; 
    5151 
    52  
    5352  // -- Constructors -- 
    5453 
     
    6362  } 
    6463 
    65  
    6664  // -- CollapseTransform API methods -- 
    6765 
     
    7674  } 
    7775 
    78  
    7976  // -- ImageTransform API methods -- 
    8077 
     
    9188  /** Gets number of range components at each pixel. */ 
    9289  public int getRangeCount() { return range.length; } 
    93  
    9490 
    9591  // -- Static DataTransform API methods -- 
     
    123119  public static boolean isParentRequired() { return true; } 
    124120 
    125  
    126121  // -- DataTransform API methods -- 
    127122 
     
    171166  public JComponent getControls() { return controls; } 
    172167 
    173  
    174168  // -- Dynamic API methods -- 
    175169 
     
    209203    thumbs = new ThumbnailHandler(this, getCacheFilename()); 
    210204  } 
    211  
    212205 
    213206  // -- Saveable API methods -- 
     
    228221    axis = Integer.parseInt(el.getAttribute("axis")); 
    229222  } 
    230  
    231223 
    232224  // -- Utility methods -- 
     
    261253    return ff; 
    262254  } 
    263  
    264255 
    265256  // -- Helper methods -- 
  • trunk/loci/visbio/data/CollapseWidget.java

    r1264 r1989  
    4545  protected BioComboBox axes; 
    4646 
    47  
    4847  // -- Constructor -- 
    4948 
     
    7675  } 
    7776 
    78  
    7977  // -- ActionListener API methods -- 
    8078 
  • trunk/loci/visbio/data/DataCache.java

    r1284 r1989  
    3636  protected static final boolean DEBUG = false; 
    3737 
    38  
    3938  // -- Fields -- 
    4039 
     
    4241  protected Hashtable hash; 
    4342 
    44  
    4543  // -- Constructor -- 
    4644 
    4745  /** Constructs a cache for managing full-resolution data in memory. */ 
    4846  public DataCache() { hash = new Hashtable(); } 
    49  
    5047 
    5148  // -- DataCache API methods -- 
     
    115112  public synchronized void dumpAll() { hash.clear(); } 
    116113 
    117  
    118114  // -- Internal DataCache API methods -- 
    119115 
     
    139135  } 
    140136 
    141  
    142137  // -- Helper methods -- 
    143138 
  • trunk/loci/visbio/data/DataControls.java

    r1746 r1989  
    8888  private SendToIJPane sender; 
    8989 
    90  
    9190  // -- Other fields -- 
    9291 
    9392  /** Table of control frames corresponding to each data transform. */ 
    9493  private Hashtable frameTable; 
    95  
    9694 
    9795  // -- Constructor -- 
     
    209207    dataInfo.setTransferHandler(dropHandler); 
    210208  } 
    211  
    212209 
    213210  // -- DataControls API methods -- 
     
    380377    wm.showWindow(window); 
    381378  } 
    382  
    383379 
    384380  // -- ActionListener API methods -- 
     
    522518  } 
    523519 
    524  
    525520  // -- TransformListener API methods -- 
    526521 
     
    534529  } 
    535530 
    536  
    537531  // -- TreeSelectionListener API methods -- 
    538532 
     
    541535    doDataInfo(getSelectedData()); 
    542536  } 
    543  
    544537 
    545538  // -- Helper methods -- 
  • trunk/loci/visbio/data/DataManager.java

    r1366 r1989  
    5858  public static final String THUMB_RES = "Thumbnail resolution"; 
    5959 
    60  
    6160  // -- Control panel -- 
    6261 
     
    6463  protected DataControls dataControls; 
    6564 
    66  
    6765  // -- Other fields -- 
    6866 
     
    7371  protected Vector transformLabels; 
    7472 
    75  
    7673  // -- Constructor -- 
    7774 
    7875  /** Constructs a dataset manager. */ 
    7976  public DataManager(VisBioFrame bio) { super(bio); } 
    80  
    8177 
    8278  // -- DataManager API methods -- 
     
    328324  public DataControls getControls() { return dataControls; } 
    329325 
    330  
    331326  // -- LogicManager API methods -- 
    332327 
     
    342337  /** Gets the number of tasks required to initialize this logic manager. */ 
    343338  public int getTasks() { return 5; } 
    344  
    345339 
    346340  // -- Saveable API methods -- 
     
    441435    } 
    442436  } 
    443  
    444437 
    445438  // -- Helper methods -- 
  • trunk/loci/visbio/data/DataSampling.java

    r1848 r1989  
    6262  /** Controls for this data sampling. */ 
    6363  protected SamplingWidget controls; 
    64  
    6564 
    6665  // -- Constructors -- 
     
    8685  } 
    8786 
    88  
    8987  // -- DataSampling API methods -- 
    9088 
     
    126124  public boolean[] getRange() { return range; } 
    127125 
    128  
    129126  // -- ImageTransform API methods -- 
    130127 
     
    159156  } 
    160157 
    161  
    162158  // -- Static DataTransform API methods -- 
    163159 
     
    200196  /** Indicates whether this transform type requires a parent transform. */ 
    201197  public static boolean isParentRequired() { return true; } 
    202  
    203198 
    204199  // -- DataTransform API methods -- 
     
    323318  } 
    324319 
    325  
    326320  // -- Internal DataTransform API methods -- 
    327321 
     
    337331  } 
    338332 
    339  
    340333  // -- Dynamic API methods -- 
    341334 
     
    387380    thumbs = makeThumbnailHandler(); 
    388381  } 
    389  
    390382 
    391383  // -- Saveable API methods -- 
     
    415407    range = ObjectUtil.stringToBooleanArray(el.getAttribute("range")); 
    416408  } 
    417  
    418409 
    419410  // -- Helper methods -- 
  • trunk/loci/visbio/data/DataTransform.java

    r1885 r1989  
    4646  protected static int nextId = 0; 
    4747 
    48  
    4948  // -- Fields -- 
    5049 
     
    8180  /** List of transform listeners. */ 
    8281  protected Vector listeners = new Vector(); 
    83  
    8482 
    8583  // -- Constructors -- 
     
    9492    transformId = nextId++; 
    9593  } 
    96  
    9794 
    9895  // -- DataTransform API methods -- 
     
    243240  } 
    244241 
    245  
    246242  // -- Internal DataTransform API methods -- 
    247243 
     
    255251  } 
    256252 
    257  
    258253  // -- Object API methods -- 
    259254 
    260255  /** Gets a string representation of this transform. */ 
    261256  public String toString() { return name; } 
    262  
    263257 
    264258  // -- Dynamic API methods -- 
     
    307301    listeners.removeAllElements(); 
    308302  } 
    309  
    310303 
    311304  // -- Saveable API methods -- 
     
    336329    dims = ObjectUtil.stringToStringArray(el.getAttribute("dims")); 
    337330  } 
    338  
    339331 
    340332  // -- Utility methods -- 
  • trunk/loci/visbio/data/Dataset.java

    r1460 r1989  
    6767  protected static DatasetPane datasetImporter; 
    6868 
    69  
    7069  // -- Data fields -- 
    7170 
     
    7978  protected TaskListener listener; 
    8079 
    81  
    8280  // -- Computed fields -- 
    8381 
     
    117115  /** Types mapped to color components (RGBA). */ 
    118116  protected RealType[] color; 
    119  
    120117 
    121118  // -- Constructors -- 
     
    183180  } 
    184181 
    185  
    186182  // -- Dataset API methods -- 
    187183 
     
    208204  /** Gets the OME node associated with each source file. */ 
    209205  public OMENode[] getOMENodes() { return ome; } 
    210  
    211206 
    212207  // -- ImageTransform API methods -- 
     
    280275  /** Gets number of range components at each pixel. */ 
    281276  public int getRangeCount() { return numRange; } 
    282  
    283277 
    284278  // -- Static DataTransform API methods -- 
     
    337331  public static boolean isParentRequired() { return false; } 
    338332 
    339  
    340333  // -- DataTransform API methods -- 
    341334 
     
    441434  public JComponent getControls() { return controls; } 
    442435 
    443  
    444436  // -- Dynamic API methods -- 
    445437 
     
    607599  } 
    608600 
    609  
    610601  // -- Saveable API methods -- 
    611602 
     
    630621  } 
    631622 
    632  
    633623  // -- Helper methods -- 
    634624 
  • trunk/loci/visbio/data/DatasetPane.java

    r1284 r1989  
    6464  private static final String[] C_CODES = {"c", "ch"}; 
    6565 
    66  
    6766  // -- GUI components, page 1 -- 
    6867 
     
    7372  private JTextField groupField; 
    7473 
    75  
    7674  // -- GUI components, page 2 -- 
    7775 
     
    103101  private JPanel micronPanel; 
    104102 
    105  
    106103  // -- Other fields -- 
    107104 
     
    120117  /** Next free id number for dataset naming scheme. */ 
    121118  private int nameId; 
    122  
    123119 
    124120  // -- Constructor -- 
     
    196192  } 
    197193 
    198  
    199194  // -- DatasetPane API methods -- 
    200195 
     
    212207    groupField.setText(pattern); 
    213208  } 
    214  
    215209 
    216210  // -- ActionListener API methods -- 
     
    304298  } 
    305299 
    306  
    307300  // -- DocumentListener API methods -- 
    308301 
     
    315308  /** Gives notification that a portion of the document has been removed. */ 
    316309  public void removeUpdate(DocumentEvent e) { checkText(); } 
    317  
    318310 
    319311  // -- Helper methods -- 
  • trunk/loci/visbio/data/DatasetWidget.java

    r1390 r1989  
    4949  protected static final String[] META_COLUMNS = {"Name", "Value"}; 
    5050 
    51  
    5251  // -- Fields -- 
    5352 
     
    8483  /** Table model backing metadata table. */ 
    8584  protected DefaultTableModel metaTableModel; 
    86  
    8785 
    8886  // -- Constructor -- 
     
    171169  } 
    172170 
    173  
    174171  // -- ListSelectionListener API methods -- 
    175172 
     
    201198    } 
    202199  } 
    203  
    204200 
    205201  // -- TreeSelectionListener API methods -- 
     
    224220    } 
    225221  } 
    226  
    227222 
    228223  // -- Helper methods -- 
     
    240235  } 
    241236 
    242  
    243237  // -- Helper classes -- 
    244238 
  • trunk/loci/visbio/data/ExportPane.java

    r1312 r1989  
    6161  private BioComboBox formatBox; 
    6262 
    63  
    6463  // -- GUI components, page 2 -- 
    6564 
     
    7978  private BioComboBox[] letterBoxes; 
    8079 
    81  
    8280  // -- GUI components, page 3 -- 
    8381 
     
    8886  private JEditorPane summary; 
    8987 
    90  
    9188  // -- Other fields -- 
    9289 
     
    114111  /** Number of total files to export. */ 
    115112  private int numFiles; 
    116  
    117113 
    118114  // -- Constructor -- 
     
    187183    setPages(new JPanel[] {first, second, third}); 
    188184  } 
    189  
    190185 
    191186  // -- ExportPane API methods -- 
     
    314309  } 
    315310 
    316  
    317311  // -- DialogPane API methods -- 
    318312 
     
    323317    formatBox.setSelectedIndex(0); 
    324318  } 
    325  
    326319 
    327320  // -- ActionListener API methods -- 
  • trunk/loci/visbio/data/ImageTransform.java

    r1284 r1989  
    4141    new ScaledUnit(1e-6, SI.meter, "mu"); // VisAD font does not show MU char 
    4242 
    43  
    4443  // -- Fields -- 
    4544 
     
    6160  /** MathType of generated images. */ 
    6261  private FunctionType functionType; 
    63  
    6462 
    6563  // -- Constructors -- 
     
    102100    else zType = DataUtil.getRealType(name + "_Z", null); 
    103101  } 
    104  
    105102 
    106103  // -- ImageTransform API methods -- 
     
    191188    return new ScaledUnit(getMicronStep(axis), MICRON); 
    192189  } 
    193  
    194190 
    195191  // -- DataTransform API methods -- 
  • trunk/loci/visbio/data/ProjectionTransform.java

    r1264 r1989  
    5050  protected ProjectionWidget controls; 
    5151 
    52  
    5352  // -- Constructors -- 
    5453 
     
    6362  } 
    6463 
    65  
    6664  // -- ProjectionTransform API methods -- 
    6765 
     
    7674  } 
    7775 
    78  
    7976  // -- ImageTransform API methods -- 
    8077 
     
    9390    return ((ImageTransform) parent).getRangeCount(); 
    9491  } 
    95  
    9692 
    9793  // -- Static DataTransform API methods -- 
     
    125121  public static boolean isParentRequired() { return true; } 
    126122 
    127  
    128123  // -- DataTransform API methods -- 
    129124 
     
    173168  public JComponent getControls() { return controls; } 
    174169 
    175  
    176170  // -- Dynamic API methods -- 
    177171 
     
    211205    thumbs = new ThumbnailHandler(this, getCacheFilename()); 
    212206  } 
    213  
    214207 
    215208  // -- Saveable API methods -- 
     
    231224  } 
    232225 
    233  
    234226  // -- Utility methods -- 
    235227 
     
    246238    return ff; 
    247239  } 
    248  
    249240 
    250241  // -- Helper methods -- 
  • trunk/loci/visbio/data/ProjectionWidget.java

    r1264 r1989  
    4646  protected BioComboBox axes; 
    4747 
    48  
    4948  // -- Constructor -- 
    5049 
     
    7776  } 
    7877 
    79  
    8078  // -- ActionListener API methods -- 
    8179 
  • trunk/loci/visbio/data/SamplingThumbHandler.java

    r1264 r1989  
    3939  } 
    4040 
    41  
    4241  // -- Internal ThumbnailHandler API methods -- 
    4342 
  • trunk/loci/visbio/data/SamplingWidget.java

    r1264 r1989  
    5959  /** Check boxes for included range components. */ 
    6060  protected JCheckBox[] rangeBoxes; 
    61  
    6261 
    6362  // -- Constructor -- 
     
    133132  } 
    134133 
    135  
    136134  // -- ActionListener API methods -- 
    137135 
     
    188186  } 
    189187 
    190  
    191188  // -- Helper methods -- 
    192189 
  • trunk/loci/visbio/data/SendToIJPane.java

    r1264 r1989  
    5858  private BioComboBox stackAxis; 
    5959 
    60  
    6160  // -- Constructor -- 
    6261 
     
    6968    stackAxis.setActionCommand("stackAxis"); 
    7069  } 
    71  
    7270 
    7371  // -- SendToIJPane API methods -- 
     
    145143  } 
    146144 
    147  
    148145  // -- DialogPane API methods -- 
    149146 
     
    183180  } 
    184181 
    185  
    186182  // -- ActionListener API methods -- 
    187183 
  • trunk/loci/visbio/data/SliceWidget.java

    r1264 r1989  
    8484  protected JCheckBox recompute; 
    8585 
    86  
    8786  // -- Constructor -- 
    8887 
     
    180179  } 
    181180 
    182  
    183181  // -- SliceWidget API methods -- 
    184182 
     
    194192    if (res.getValue() != value) res.setValue(value); 
    195193  } 
    196  
    197194 
    198195  // -- ChangeListener API methods -- 
     
    211208  } 
    212209 
    213  
    214210  // -- ItemListener API methods -- 
    215211 
    216212  /** Handles combo box updates. */ 
    217213  public void itemStateChanged(ItemEvent e) { updateSlice(); } 
    218  
    219214 
    220215  // -- Helper methods -- 
  • trunk/loci/visbio/data/SpectralTransform.java

    r1264 r1989  
    5353  protected SpectralWidget controls; 
    5454 
    55  
    5655  // -- Constructors -- 
    5756 
     
    8180  } 
    8281 
    83  
    8482  // -- SpectralTransform API methods -- 
    8583 
     
    102100  public double[][] getWeights() { return weights; } 
    103101 
    104  
    105102  // -- ImageTransform API methods -- 
    106103 
     
    117114  /** Gets number of range components at each pixel. */ 
    118115  public int getRangeCount() { return range.length; } 
    119  
    120116 
    121117  // -- Static DataTransform API methods -- 
     
    148144  public static boolean isParentRequired() { return true; } 
    149145 
    150  
    151146  // -- DataTransform API methods -- 
    152147 
     
    190185  public JComponent getControls() { return controls; } 
    191186 
    192  
    193187  // -- Dynamic API methods -- 
    194188 
     
    241235    thumbs = new ThumbnailHandler(this, getCacheFilename()); 
    242236  } 
    243  
    244237 
    245238  // -- Saveable API methods -- 
     
    266259    } 
    267260  } 
    268  
    269261 
    270262  // -- TransformListener API methods -- 
     
    282274  } 
    283275 
    284  
    285276  // -- Utility methods -- 
    286277 
     
    319310    return null; 
    320311  } 
    321  
    322312 
    323313  // -- Helper methods -- 
  • trunk/loci/visbio/data/SpectralWidget.java

    r1264 r1989  
    4949  protected static final int PRECISION = 100; 
    5050 
    51  
    5251  // -- Fields -- 
    5352 
     
    6059  /** Labels indicating current slider values. */ 
    6160  protected JLabel[][] labels; 
    62  
    6361 
    6462  // -- Constructor -- 
     
    174172  } 
    175173 
    176  
    177174  // -- ActionListener API methods -- 
    178175 
     
    205202  } 
    206203 
    207  
    208204  // -- Helper methods -- 
    209205 
  • trunk/loci/visbio/data/ThumbnailCache.java

    r1264 r1989  
    5757  /** Last retrieved thumbnail index. */ 
    5858  protected int last; 
    59  
    6059 
    6160  // -- Constructor -- 
     
    109108  } 
    110109 
    111  
    112110  // -- API methods -- 
    113111 
     
    154152  public boolean isDefault() { return file.equals(DEFAULT_CACHE); } 
    155153 
    156  
    157154  // -- Helper methods -- 
    158155 
  • trunk/loci/visbio/data/ThumbnailHandler.java

    r1284 r1989  
    6666  /** Flag indicating background thumbnail generation is enabled. */ 
    6767  protected boolean on = false; 
    68  
    6968 
    7069  // -- Constructor -- 
     
    8079    clear(); 
    8180  } 
    82  
    8381 
    8482  // -- ThumbnailHandler API methods -- 
     
    148146  public ThumbnailCache getCache() { return cache; } 
    149147 
    150  
    151148  // -- Internal ThumbnailHandler API methods -- 
    152149 
     
    187184    return makeThumb(d); 
    188185  } 
    189  
    190186 
    191187  // -- Runnable API methods -- 
     
    216212  } 
    217213 
    218  
    219214  // -- TransformListener API methods -- 
    220215 
     
    224219    if (id == TransformEvent.DATA_CHANGED) clear(); 
    225220  } 
    226  
    227221 
    228222  // -- Helper methods -- 
  • trunk/loci/visbio/data/TransformEvent.java

    r1264 r1989  
    4343  public static final int DATA_REMOVED = 3; 
    4444 
    45  
    4645  // -- Fields -- 
    4746 
    4847  /** The type of transform event. */ 
    4948  protected int id; 
    50  
    5149 
    5250  // -- Constructors -- 
     
    6058    this.id = id; 
    6159  } 
    62  
    6360 
    6461  // -- TransformEvent API methods -- 
  • trunk/loci/visbio/ext/ExtManager.java

    r1264 r1989  
    3434public class ExtManager extends LogicManager { 
    3535 
    36  
    3736  // -- Constructor -- 
    3837 
    3938  /** Constructs an external interface manager. */ 
    4039  public ExtManager(VisBioFrame bio) { super(bio); } 
    41  
    4240 
    4341  // -- LogicManager API methods -- 
     
    5452  /** Gets the number of tasks required to initialize this logic manager. */ 
    5553  public int getTasks() { return 3; } 
    56  
    5754 
    5855  // -- Helper methods -- 
  • trunk/loci/visbio/ext/ExternalFunction.java

    r1264 r1989  
    6262  protected FunctionWidget controls; 
    6363 
    64  
    6564  // -- Constructors -- 
    6665 
     
    7473    initState(null); 
    7574  } 
    76  
    7775 
    7876  // -- ExternalFunction API methods -- 
     
    137135  public String[] getParameters() { return params; } 
    138136 
    139  
    140137  // -- ImageTransform API methods -- 
    141138 
     
    148145  /** Gets number of range components at each pixel. */ 
    149146  public int getRangeCount() { return numRange; } 
    150  
    151147 
    152148  // -- DataTransform API methods -- 
     
    190186  public JComponent getControls() { return controls; } 
    191187 
    192  
    193188  // -- Dynamic API methods -- 
    194189 
     
    239234  } 
    240235 
    241  
    242236  // -- Saveable API methods -- 
    243237 
     
    257251    function = el.getAttribute("function"); 
    258252  } 
    259  
    260253 
    261254  // -- Helper methods -- 
  • trunk/loci/visbio/ext/ExternalProgram.java

    r1264 r1989  
    4141  protected static Runtime rt = Runtime.getRuntime(); 
    4242 
    43  
    4443  // -- Constructors -- 
    4544 
     
    5150    super(parent, name, function); 
    5251  } 
    53  
    5452 
    5553  // -- ExternalFunction API methods -- 
     
    247245  } 
    248246 
    249  
    250247  // -- Static DataTransform API methods -- 
    251248 
  • trunk/loci/visbio/ext/FunctionParam.java

    r1264 r1989  
    3535  protected String value; 
    3636 
    37  
    3837  // -- Constructor -- 
    3938 
     
    4746  } 
    4847 
    49  
    5048  // -- FunctionParam API methods -- 
    5149 
  • trunk/loci/visbio/ext/FunctionWidget.java

    r1264 r1989  
    4848  protected JTextField[] paramFields; 
    4949 
    50  
    5150  // -- Constructor -- 
    5251 
     
    8988  } 
    9089 
    91  
    9290  // -- ActionListener API methods -- 
    9391 
  • trunk/loci/visbio/ext/MatlabFunction.java

    r1264 r1989  
    4141  } 
    4242 
    43  
    4443  // -- ExternalFunction API methods -- 
    4544 
     
    6867    return MatlabUtil.evaluate(function, input, p, getRangeTypes()); 
    6968  } 
    70  
    7169 
    7270  // -- Static DataTransform API methods -- 
  • trunk/loci/visbio/ext/MatlabUtil.java

    r1746 r1989  
    4040  /** Reflected universe containing singleton MATLAB instance. */ 
    4141  private static ReflectedUniverse r; 
    42  
    4342 
    4443  // -- MatlabUtil API methods -- 
  • trunk/loci/visbio/help/HelpManager.java

    r1727 r1989  
    4444    "Ask about displaying new data objects"; 
    4545 
    46  
    4746  // -- Fields -- 
    4847 
     
    5049  protected HelpWindow helpWindow; 
    5150 
    52  
    5351  // -- Constructor -- 
    5452 
    5553  /** Constructs an exit manager. */ 
    5654  public HelpManager(VisBioFrame bio) { super(bio); } 
    57  
    5855 
    5956  // -- HelpManager API methods -- 
     
    121118  } 
    122119 
    123  
    124120  // -- LogicManager API methods -- 
    125121 
     
    148144  public int getTasks() { return 4; } 
    149145 
    150  
    151146  // -- Helper methods -- 
    152147 
     
    189184  private void makeVisPanel() { 
    190185  } 
    191  
    192186 
    193187  // -- Menu commands -- 
  • trunk/loci/visbio/help/HelpTopic.java

    r1264 r1989  
    3434  private String source; 
    3535 
    36  
    3736  // -- Constructor -- 
    3837 
     
    4241    this.source = source; 
    4342  } 
    44  
    4543 
    4644  // -- HelpWindow API methods -- 
  • trunk/loci/visbio/help/HelpWindow.java

    r1264 r1989  
    5252  private static final int MIN_TREE_WIDTH = 300; 
    5353 
    54  
    5554  // -- Fields -- 
    5655 
     
    6362  /** Pane containing the current help topic. */ 
    6463  private JEditorPane pane; 
    65  
    6664 
    6765  // -- Constructor -- 
     
    9997  } 
    10098 
    101  
    10299  // -- HelpWindow API methods -- 
    103100 
     
    106103    addTopic(root, topic, source); 
    107104  } 
    108  
    109105 
    110106  // -- JFrame API methods -- 
     
    128124  } 
    129125 
    130  
    131126  // -- HyperlinkListener API methods -- 
    132127 
     
    155150    } 
    156151  } 
    157  
    158152 
    159153  // -- TreeSelectionListener API methods -- 
  • trunk/loci/visbio/ome/ImageDownloader.java

    r1390 r1989  
    4444  protected Vector listeners; 
    4545 
    46  
    4746  // -- Constructor -- 
    4847 
    4948  /** Constructs a new OME image downloader. */ 
    5049  public ImageDownloader() { listeners = new Vector(); } 
    51  
    5250 
    5351  // -- ImageDownloader API methods -- 
     
    191189    } 
    192190  } 
    193  
    194191 
    195192  // -- Helper methods -- 
  • trunk/loci/visbio/ome/ImageUploader.java

    r1284 r1989  
    4848  protected Vector listeners; 
    4949 
    50  
    5150  // -- Constructor -- 
    5251 
    5352  /** Constructs a new OME image uploader. */ 
    5453  public ImageUploader() { listeners = new Vector(); } 
    55  
    5654 
    5755  // -- ImageUploader API methods -- 
     
    346344  } 
    347345 
    348  
    349346  // -- Main method -- 
    350347 
  • trunk/loci/visbio/ome/OMEImage.java

    r1264 r1989  
    5353  protected static OMELoginPane login; 
    5454 
    55  
    5655  // -- Data fields -- 
    5756 
     
    7473  protected BioTask task; 
    7574 
    76  
    7775  // -- Computed fields -- 
    7876 
     
    115113  /** Index for Time dimension. */ 
    116114  protected int indexT; 
    117  
    118115 
    119116  // -- Constructors -- 
     
    153150  } 
    154151 
    155  
    156152  // -- OMEImage API methods -- 
    157153 
     
    183179  public int getImageId() { return imageId; } 
    184180 
    185  
    186181  // -- ImageTransform API methods -- 
    187182 
     
    194189  /** Gets number of range components at each pixel. */ 
    195190  public int getRangeCount() { return sizeC; } 
    196  
    197191 
    198192  // -- Static DataTransform API methods -- 
     
    275269  public static boolean isParentRequired() { return false; } 
    276270 
    277  
    278271  // -- DataTransform API methods -- 
    279272 
     
    326319    return sb.toString(); 
    327320  } 
    328  
    329321 
    330322  // -- Dynamic API methods -- 
  • trunk/loci/visbio/ome/OMELoginPane.java

    r1264 r1989  
    4747  protected JPasswordField pass; 
    4848 
    49  
    5049  // -- Constructor -- 
    5150 
     
    8382  } 
    8483 
    85  
    8684  // -- OMELoginPane API methods -- 
    8785 
  • trunk/loci/visbio/ome/OMEManager.java

    r1264 r1989  
    4141  private OMELoginPane loginPane; 
    4242 
    43  
    4443  // -- Constructor -- 
    4544 
    4645  /** Constructs an OME manager. */ 
    4746  public OMEManager(VisBioFrame bio) { super(bio); } 
    48  
    4947 
    5048  // -- OMEManager API methods -- 
     
    115113  public OMELoginPane getLoginPane() { return loginPane; } 
    116114 
    117  
    118115  // -- Static OMEManager API methods -- 
    119116 
     
    132129  } 
    133130 
    134  
    135131  // -- LogicManager API methods -- 
    136132 
     
    146142  /** Gets the number of tasks required to initialize this logic manager. */ 
    147143  public int getTasks() { return 3; } 
    148  
    149144 
    150145  // -- Helper methods -- 
  • trunk/loci/visbio/overlays/ArrowTool.java

    r1472 r1989  
    4141  } 
    4242 
    43  
    4443  // -- OverlayTool API methods -- 
    4544 
  • trunk/loci/visbio/overlays/BoxTool.java

    r1592 r1989  
    3434  protected OverlayBox box; 
    3535 
    36  
    3736  // -- Constructor -- 
    3837 
     
    4140    super(overlay, "Box", "Box", "box.png"); 
    4241  } 
    43  
    4442 
    4543  // -- OverlayTool API methods -- 
     
    5149    configureOverlay(box); 
    5250    OverlayWidget panel = (OverlayWidget) overlay.getControls(); 
    53     box.setFilled(panel.isFilled());  
     51    box.setFilled(panel.isFilled()); 
    5452    overlay.addObject(box, pos); 
    5553  } 
  • trunk/loci/visbio/overlays/FreeformTool.java

    r1918 r1989  
    3131/** FreeformTool is the tool for creating freeform objects. */ 
    3232public class FreeformTool extends OverlayTool { 
    33     
     33 
    3434  // -- Constants -- 
    3535 
    3636  /** When drawing or editing, how far mouse must be dragged before new node is added */ 
    37   protected static final double DRAW_THRESH = 2.0;  
     37  protected static final double DRAW_THRESH = 2.0; 
    3838  /** Threshhold within which click must occur to invoke edit mode */ 
    39   protected static final double EDIT_THRESH = 5.0;  
     39  protected static final double EDIT_THRESH = 5.0; 
    4040  /** Threshhold within which click must occur to invoke extend mode or reconnect a tendril */ 
    41   protected static final double RECONNECT_THRESH = 0.5;  
     41  protected static final double RECONNECT_THRESH = 0.5; 
    4242 
    4343  /** 4 constants describing edit modes */ 
    4444  // There are four edit modes.  The method setMode(int) is called to change the mode, in order to 
    45   // properties related to the current mode; e.g., whether a freeform is selected in the list of  
     45  // properties related to the current mode; e.g., whether a freeform is selected in the list of 
    4646  // overlays 
    4747  protected static final int ERASE = -1; 
     
    5353 
    5454  /** Curve currently being drawn or modified. */ 
    55   protected OverlayFreeform freeform;  
    56    
     55  protected OverlayFreeform freeform; 
     56 
    5757  /** Other freeforms on the canvas */ 
    5858  protected Vector otherFreefs; 
    59    
     59 
    6060  /** Tendril wraps info about an edit to a curve */ 
    6161  protected Tendril tendril; 
    6262  protected int mode; 
    6363 
    64   protected float[][] pre, post; // chunks of curve tracked in redrawing  
     64  protected float[][] pre, post; // chunks of curve tracked in redrawing 
    6565 
    6666  // -- Constructor -- 
     
    7878  /** Instructs this tool to respond to a mouse press. */ 
    7979  public void mouseDown(float x, float y, int[] pos, int mods) { 
    80     boolean ctl = (mods & InputEvent.CTRL_MASK) != 0;  
     80    boolean ctl = (mods & InputEvent.CTRL_MASK) != 0; 
    8181    OverlayFreeform target = getClosestFreeform(x, y); 
    8282    if (target != null) { 
     
    9797        if (!(seg == 0 && weight == 0.0) && !(seg == freeform.getNumNodes()-2 && weight == 1.0)) { 
    9898          // if interior node 
    99           // project click onto curve and insert a new node there,  
     99          // project click onto curve and insert a new node there, 
    100100          // unless nearest point on curve is a node itself 
    101101          // because of the way getDistSegWt() works, weight can never be 0.0 except if seg = 0. 
     
    108108          } else { 
    109109            float[] a = freeform.getNodeCoords(seg); // determine projection on seg. 
    110             float[] b = freeform.getNodeCoords(seg + 1);         
     110            float[] b = freeform.getNodeCoords(seg + 1); 
    111111            float[] newXY = computePtOnSegment(a, b, (float) weight); 
    112112            freeform.insertNode(seg + 1, newXY[0], newXY[1]); 
     
    114114            tendril = new Tendril(seg+1, seg+2, false); 
    115115            splitNodes (seg+1, seg+3); 
    116           }  
     116          } 
    117117          setMode(EDIT); 
    118118        } else { 
     
    121121        } 
    122122      }// end else 
    123     } else {  
     123    } else { 
    124124      if (!ctl) { 
    125125        deselectAll(); 
     
    129129        setMode(DRAW); 
    130130      } 
    131     }  
     131    } 
    132132 
    133133    overlay.notifyListeners(new TransformEvent(overlay)); 
     
    144144    f2Start = seg + 1; 
    145145    f2Stop = freef.getNumNodes() - 1; 
    146          
     146 
    147147    if (weight == 0.0) f1Stop = seg - 1; 
    148     else if (weight == 1.0) f2Start = seg + 2;  
    149      
     148    else if (weight == 1.0) f2Start = seg + 2; 
     149 
    150150    float[][] oldNodes = freef.getNodes(); 
    151151    float[][] f1Nodes = new float[2][f1Stop+1]; 
     
    158158    f1 = new OverlayFreeform(overlay, f1Nodes); 
    159159    f2 = new OverlayFreeform(overlay, f2Nodes); 
    160      
     160 
    161161    configureOverlay(f1); 
    162162    configureOverlay(f2); 
     
    167167    f1.setDrawing(false); 
    168168    f2.setDrawing(false); 
    169      
     169 
    170170    //TODO element at exception caused by this 
    171171    overlay.removeObject(freef); 
     
    182182      this.stop = stop; 
    183183      this.nodal = nodal; 
    184       // initial value of tip is nonsensical.  Use as a check.  
     184      // initial value of tip is nonsensical.  Use as a check. 
    185185      this.tip = -1; 
    186186    } 
     
    257257  /** Instructs this tool to respond to a mouse drag. */ 
    258258  public void mouseDrag(float x, float y, int[] pos, int mods) { 
    259     boolean shift = (mods & InputEvent.SHIFT_MASK) != 0;  
    260     boolean ctl = (mods & InputEvent.CTRL_MASK) != 0;  
     259    boolean shift = (mods & InputEvent.SHIFT_MASK) != 0; 
     260    boolean ctl = (mods & InputEvent.CTRL_MASK) != 0; 
    261261 
    262262    if (ctl && mode == DRAW) { 
     
    266266 
    267267    if (mode == DRAW) { 
    268        
     268 
    269269      // compute distance to endpoints of nearby freeforms 
    270270      int index = -1; 
     
    297297        connectFreeforms (freeform, (OverlayFreeform) otherFreefs.get(index), closerToHead); 
    298298        setMode(CHILL); 
    299       } else {  
     299      } else { 
    300300        // compute distance from last node 
    301301        float lastX = freeform.getLastNodeX(); 
    302302        float lastY = freeform.getLastNodeY(); 
    303         float dx = x - lastX;  
    304         float dy = y - lastY;  
     303        float dx = x - lastX; 
     304        float dy = y - lastY; 
    305305        double dist = Math.sqrt (dx*dx + dy*dy); 
    306        
     306 
    307307        if (dist > DRAW_THRESH) { 
    308308          freeform.setNextNode(x, y); 
    309309          double len = freeform.getCurveLength(); 
    310310          freeform.setCurveLength(len + dist); 
    311           freeform.setBoundaries(x,y); // I debated whether to update this realtime.  This is an efficient method,  
     311          freeform.setBoundaries(x,y); // I debated whether to update this realtime.  This is an efficient method, 
    312312          // buy updating realtime for erasing requires an O(n) operation every time a node is deleted. 
    313313        } 
     
    327327      double[] begd = {(double) beg[0], (double) beg[1]}; 
    328328      double[] endd = {(double) end[0], (double) end[1]}; 
    329        
     329 
    330330      double bdist = MathUtil.getDistance (drag, begd); 
    331331      double edist = MathUtil.getDistance (drag, endd); 
    332        
     332 
    333333      boolean closerToEnd = edist < bdist ? true : false; 
    334334      double mdist = closerToEnd ? edist : bdist; 
    335        
     335 
    336336      if (mdist < DRAW_THRESH) { 
    337337        if (!closerToEnd) freeform.reverseNodes(); 
     
    343343          if (closerToEnd) nearest = endd; 
    344344          else nearest = begd; 
    345          
     345 
    346346          // adjust curve length 
    347347          index = freeform.getNumNodes()-1; // last node in freef 
     
    379379      double[] thiscoords = {(double) x, (double) y}; // coords of this mouseDrag event 
    380380      double dragDist = MathUtil.getDistance(pcoordsd, thiscoords); 
    381        
     381 
    382382      // compute distance to pre, post chunks of curve 
    383383      double[] distSegWtPre = MathUtil.getDistSegWt(pre, x, y); 
    384384      double[] distSegWtPost = MathUtil.getDistSegWt(post, x, y); 
    385              
     385 
    386386      boolean equalsCase = false; 
    387387      if (distSegWtPre[0] == distSegWtPost[0]) equalsCase = true; 
     
    395395      double weight = distSegWt[2]; 
    396396      // ACS TODO what about equals case? wait for next drag? 
    397     
     397 
    398398      // if not close to curve insert node, else reconnect 
    399399      if (minDist > RECONNECT_THRESH) { 
    400400        // insert a node at the drag point if drag went far enough 
    401         if (dragDist > DRAW_THRESH) {  
     401        if (dragDist > DRAW_THRESH) { 
    402402          // first drag only 
    403403          if (tendril.tip < 0) { 
     
    406406            tendril.tip = tendril.start + 1; 
    407407          } else { // later drags 
    408             freeform.insertNode(tendril.tip+1, pcoordsf[0], pcoordsf[1]);   
     408            freeform.insertNode(tendril.tip+1, pcoordsf[0], pcoordsf[1]); 
    409409            freeform.insertNode(tendril.tip+1, x, y); 
    410410            tendril.tip++; 
     
    412412          } 
    413413        } 
    414         // tendril.tip always points to a lone node (except for before first drag, where it doesn't point to a  
     414        // tendril.tip always points to a lone node (except for before first drag, where it doesn't point to a 
    415415        // node at all 
    416416 
     
    422422            // insert a node first at drag point, then reconnect 
    423423            // skip this case:  There's the possibility that this drag point 
    424             // is across the curve from the previous drag point, which might  
     424            // is across the curve from the previous drag point, which might 
    425425            // result in a unintended zig-zag. 
    426426          //} 
     
    436436          } else { 
    437437            float[] a = freeform.getNodeCoords(seg + offset); // determine projection on seg. 
    438             float[] b = freeform.getNodeCoords(seg + 1 + offset);         
     438            float[] b = freeform.getNodeCoords(seg + 1 + offset); 
    439439            float[] newXY = computePtOnSegment (a, b, (float) weight); 
    440             int insertIndex = seg + 1 + offset;  
    441             freeform.insertNode(insertIndex, newXY[0], newXY[1]);  
     440            int insertIndex = seg + 1 + offset; 
     441            freeform.insertNode(insertIndex, newXY[0], newXY[1]); 
    442442            if (!closerToPost) { 
    443443              tendril.increment(); 
     
    445445            endIndex = insertIndex; 
    446446          } 
    447           
     447 
    448448          if (tendril.tip < endIndex) { 
    449             freeform.deleteBetween(tendril.tip, endIndex);  
     449            freeform.deleteBetween(tendril.tip, endIndex); 
    450450          } else { 
    451451            freeform.deleteBetween(endIndex, tendril.tip); 
     
    453453          freeform.computeLength(); 
    454454          setMode(CHILL); 
    455         }            
     455        } 
    456456      } // end reconnect logic 
    457    
     457 
    458458    } 
    459459    overlay.notifyListeners(new TransformEvent(overlay)); 
    460   } // end mouseDrag  
    461    
     460  } // end mouseDrag 
     461 
    462462  //-- Additional methods 
    463463 
     
    485485  } 
    486486 
    487   /** Returns the closest (subject to a threshhold) OverlayFreeform object to  
    488    *  the given point  
     487  /** Returns the closest (subject to a threshhold) OverlayFreeform object to 
     488   *  the given point 
    489489   */ 
    490490  private OverlayFreeform getClosestFreeform(float x, float y) { 
    491     OverlayObject[] objects = overlay.getObjects();  
     491    OverlayObject[] objects = overlay.getObjects(); 
    492492    //Q: Hey, are all of these OverlayFreeforms?  A: No, it returns OverlayObjects of all types 
    493493    OverlayFreeform closestFreeform = null; 
     
    509509          } // end (.. < EDIT_THRESH) 
    510510        } // end if 
    511       } // end for  
     511      } // end for 
    512512    } // end if 
    513513    return closestFreeform; 
     
    534534  /** Prints node array of current freeform; for debugging */ 
    535535  private void printNodes() { 
    536     if (freeform!=null){  
     536    if (freeform!=null){ 
    537537      float[][] nodes = freeform.getNodes(); 
    538538      printNodes(nodes); 
     
    541541 
    542542  /** Prints a message for debugging */ 
    543   public void print(String methodName, String message) {  
     543  public void print(String methodName, String message) { 
    544544    boolean toggle = true; 
    545545    if (toggle) { 
     
    548548      System.out.println(out); 
    549549    } 
    550   }  
    551 } // end class FreeformTool  
     550  } 
     551} // end class FreeformTool 
  • trunk/loci/visbio/overlays/LineTool.java

    r1264 r1989  
    3434  protected OverlayLine line; 
    3535 
    36  
    3736  // -- Constructor -- 
    3837 
     
    4140    super(overlay, "Line", "Line", "line.png"); 
    4241  } 
    43  
    4442 
    4543  // -- OverlayTool API methods -- 
  • trunk/loci/visbio/overlays/MarkerTool.java

    r1264 r1989  
    3434  protected OverlayMarker marker; 
    3535 
    36  
    3736  // -- Constructor -- 
    3837 
     
    4140    super(overlay, "Marker", "Marker", "marker.png"); 
    4241  } 
    43  
    4442 
    4543  // -- OverlayTool API methods -- 
  • trunk/loci/visbio/overlays/OvalTool.java

    r1264 r1989  
    3434  protected OverlayOval oval; 
    3535 
    36  
    3736  // -- Constructor -- 
    3837 
     
    4140    super(overlay, "Oval", "Oval", "oval.png"); 
    4241  } 
    43  
    4442 
    4543  // -- OverlayTool API methods -- 
  • trunk/loci/visbio/overlays/OverlayArrow.java

    r1284 r1989  
    4848    computeGridParameters(); 
    4949  } 
    50  
    5150 
    5251  // -- OverlayObject API methods -- 
     
    136135  public boolean canBeFilled() { return true; } 
    137136 
    138  
    139137  // -- Internal OverlayObject API methods -- 
    140138 
     
    152150  } 
    153151 
    154  
    155152  // -- Object API methods -- 
    156153 
  • trunk/loci/visbio/overlays/OverlayFreeform.java

    r1847 r1989  
    5959    computeLength(); 
    6060  } 
    61    
     61 
    6262  public OverlayFreeform(OverlayTransform overlay, float[][] nodes) { 
    6363    super(overlay); 
     
    119119    return Math.sqrt(xdist * xdist + ydist * ydist); 
    120120  } 
    121    
     121 
    122122  /** Compute the shortest distance from this object to the given point */ 
    123123  public double getDistance (double x, double y) { 
  • trunk/loci/visbio/overlays/OverlayIO.java

    r1974 r1989  
    3838 
    3939  // -- Constants -- 
    40    
     40 
    4141  // file parsing state machine states and events 
    4242  // states 
     
    5959 
    6060  // -- OverlayIO API methods -- 
    61    
     61 
    6262  /** Reads the overlays from the given reader. */ 
    6363  public static Vector[] loadOverlays(BufferedReader in, 
     
    6969 
    7070    // stores all overlays 
    71     Vector[] loadedOverlays = null;  
     71    Vector[] loadedOverlays = null; 
    7272    boolean foundOverlays = false; 
    73      
     73 
    7474    // tracks addresses of stored freeforms 
    75     Vector loadedFreeforms = new Vector();  
     75    Vector loadedFreeforms = new Vector(); 
    7676    boolean nodesChanged = false; // used in event INIT, state NODES 
    7777    int numberOfFreeformsRead = 0; 
     
    7979 
    8080    // tracks line number for error messages 
    81     int lineNum = 0;  
     81    int lineNum = 0; 
    8282 
    8383    // stores freeform nodes as they're read from file 
     
    118118          // parse table header from first valid line 
    119119          int numDims = count - 10; // 12: number of non-dim. fields in overlay description 
    120            
     120 
    121121          if (numDims < 0) { 
    122122            displayErrorMsg(owner, lineNum, "insufficient column headings"); 
     
    139139            catch (NumberFormatException exc) { } 
    140140          } 
    141            
     141 
    142142          if (!ObjectUtil.arraysEqual(dims, theDims)) { 
    143143            displayErrorMsg(owner, lineNum, "dimensional axis types do not match"); 
     
    148148            return null; 
    149149          } 
    150            
     150 
    151151          // initialize replacement overlay lists 
    152152          loadedOverlays = new Vector[MathUtil.getRasterLength(lengths)]; 
     
    154154            loadedOverlays[i] = new Vector(); 
    155155          } 
    156            
     156 
    157157        } else if (state == NODES) { 
    158158          if (numberOfFreeformsRead == loadedFreeforms.size()) { 
    159             String s = "more Freeform node lists than Freeforms (" + numberOfFreeformsRead  
     159            String s = "more Freeform node lists than Freeforms (" + numberOfFreeformsRead 
    160160              + ") specified in table"; 
    161161            displayErrorMsg(owner, lineNum, s); 
     
    163163          } 
    164164 
    165           // store nodes of previously read freeform  
     165          // store nodes of previously read freeform 
    166166          if (nodesChanged) { 
    167167            OverlayFreeform of = (OverlayFreeform) loadedFreeforms.elementAt(numFreeformsRestored++); 
     
    182182          String type = st.nextToken().substring(1); // remove initial # 
    183183          int tok = 0; 
    184            
     184 
    185185          if (count != lengths.length + 10) { // 10 == number of non-dim. fields in the overlay description 
    186186            String s = "line in data table has an insufficient number of fields (" + count + " instead of " 
    187187              + (lengths.length + 10) + ")"; 
    188             displayErrorMsg(owner, lineNum, s);  
     188            displayErrorMsg(owner, lineNum, s); 
    189189            return null; 
    190190          } 
     
    192192          int[] pos = new int[lengths.length]; 
    193193          for (int i=0; i<pos.length; i++) { 
    194             try {  
     194            try { 
    195195              int p = Integer.parseInt(st.nextToken()); 
    196196              if (p >= 0 && p < lengths[i]) { // is coordinate within range? 
    197                 pos[i] = p;  
     197                pos[i] = p; 
    198198                tok++; 
    199199              } else { 
     
    212212            return null; 
    213213          } 
    214            
     214 
    215215          String sx1, sx2, sy1, sy2; 
    216216 
    217           sx1 = st.nextToken();  
     217          sx1 = st.nextToken(); 
    218218          sy1 = st.nextToken(); 
    219           sx2 = st.nextToken();  
     219          sx2 = st.nextToken(); 
    220220          sy2 = st.nextToken(); 
    221              
     221 
    222222          float x1, y1, x2, y2; 
    223223 
     
    233233            return null; 
    234234          } 
    235            
     235 
    236236          String text = st.nextToken(); 
    237237 
     
    245245 
    246246          boolean filled = false; 
    247           filled = st.nextToken().equalsIgnoreCase("true");  
    248    
     247          filled = st.nextToken().equalsIgnoreCase("true"); 
     248 
    249249          String group = st.nextToken(); 
    250250 
    251251          String notes = ""; 
    252           notes = st.nextToken();  
     252          notes = st.nextToken(); 
    253253          notes = notes.substring(0, notes.length() - 1); // remove trailing # 
    254254 
     
    256256          OverlayObject obj = createOverlay(className, trans, lineNum); 
    257257          if (obj == null) continue; 
    258            
     258 
    259259          boolean hasNodes = false; 
    260260          if (obj instanceof OverlayFreeform) { 
     
    271271          } 
    272272          */ 
    273            
     273 
    274274          // assign overlay parameters 
    275275          obj.x1 = x1; 
     
    293293 
    294294          String[] toks = trim.split("\\s");// split on whitespace 
    295            
     295 
    296296          float x, y; 
    297297          try { 
    298298            x = Float.parseFloat(toks[0]); 
    299299            y = Float.parseFloat(toks[1]); 
    300           }  
    301           catch (NumberFormatException exc) {  
     300          } 
     301          catch (NumberFormatException exc) { 
    302302            // this error message won't fire: covered by regular expressions in getEventAndState 
    303             displayErrorMsg(owner, lineNum, "error parsing node coordinates");  
     303            displayErrorMsg(owner, lineNum, "error parsing node coordinates"); 
    304304            return null; 
    305305          } 
     
    318318    } // end while(true) 
    319319 
    320     // after parsing all lines:  
     320    // after parsing all lines: 
    321321    if (!foundOverlays) { 
    322322      displayErrorMsg(owner, lineNum, "no overlays found"); 
     
    324324    } else if (loadedFreeforms != null) { 
    325325      if (numFreeformsRestored + 1 < loadedFreeforms.size()) { 
    326         displayErrorMsg(owner, lineNum, "missing node lists for one or more Freeforms");  
     326        displayErrorMsg(owner, lineNum, "missing node lists for one or more Freeforms"); 
    327327        return null; 
    328328      } else { 
     
    338338    return loadedOverlays; 
    339339  } 
    340    
     340 
    341341  /** Writes the overlays to the given writer. */ 
    342342  public static void saveOverlays(PrintWriter out, OverlayTransform trans) { 
     
    406406        out.println(nodes[0][j]+"\t"+nodes[1][j]); 
    407407      } 
    408     }  
     408    } 
    409409  } 
    410410 
     
    462462  } 
    463463 
    464  
    465464  // -- Private helper methods -- 
    466    
     465 
    467466  /** Method for determining how to handle next line read from input file */ 
    468467  private static int[] getEventTypeAndNewState(String input, int current) { 
    469468    // logic for parsing overlays file --ACS 12/06 
    470     //  
     469    // 
    471470    // I visualized the process of parsing an overlay file as a 'state machine': 
    472471    // at each input (a line of text), the machine changes state and spits out an event 
    473472    // telling the method loadOverlays to parse the line, display an error message, etc. 
    474     // This method getEventTypeAndNewState describes the state machine's behavior: each  
     473    // This method getEventTypeAndNewState describes the state machine's behavior: each 
    475474    // top-level if/elseif clause corresponds to a different state, and the interior 
    476475    // if/elseif/else clauses describe possible transitions from that state. 
     
    490489      if (input.equals("")) {state = TABLE; event = IGNORE;} 
    491490      else if (input.matches("^\\s*#\\s*[Ff][Rr][Ee][Ee][Ff][Oo][Rr][Mm].*")) {state = NODES; event = INIT;} 
    492       else if (input.startsWith("Line") || input.startsWith("Freeform")  
     491      else if (input.startsWith("Line") || input.startsWith("Freeform") 
    493492          || input.startsWith("Marker") || input.startsWith("Text") || input.startsWith("Oval") 
    494493          || input.startsWith("Box") || input.startsWith("Arrow")) { 
    495494        state = TABLE; 
    496495        event = PARSE; 
    497       }  
     496      } 
    498497      else if (input.startsWith("#")) {state = TABLE; event = IGNORE;} // must check for freeform header first 
    499498      else { 
     
    505504      else if (input.matches("^\\s*#\\s*[Ff][Rr][Ee][Ee][Ff][Oo][Rr][Mm].*")) {state = NODES; event = INIT;} 
    506505      else if (input.startsWith("#") || input.matches("^[Xx]\t[Yy]")) {state = NODES; event = IGNORE;} 
    507       else if (input.matches("^[0-9]+\\.[0-9]+\\s[0-9]+\\.[0-9]+$")) {state = NODES; event = PARSE;}  
     506      else if (input.matches("^[0-9]+\\.[0-9]+\\s[0-9]+\\.[0-9]+$")) {state = NODES; event = PARSE;} 
    508507      else { 
    509508        state = NODES; 
     
    518517  /** Displays an alarm box */ 
    519518  private static void displayErrorMsg(JComponent owner, int line, String msg) { 
    520     JOptionPane.showMessageDialog(owner, "Invalid overlay file: "  
     519    JOptionPane.showMessageDialog(owner, "Invalid overlay file: " 
    521520      + msg + "\n" + "Error in line " + line , 
    522521      "Cannot load overlays", JOptionPane.ERROR_MESSAGE); 
  • trunk/loci/visbio/overlays/OverlayObject.java

    r1865 r1989  
    118118  /** True iff this overlay supports the filled parameter. */ 
    119119  public boolean canBeFilled() { return false; } 
    120    
     120 
    121121  /** True iff this overlay can be resized using X1, X2, Y1, Y2 entry boxes */ 
    122122  public boolean areBoundsEditable() { return !hasNodes; } 
     
    264264  public float[] getNodeCoords (int index) { 
    265265    float[] retvals = new float[2]; 
    266     if (index < numNodes && index >= 0) {  
     266    if (index < numNodes && index >= 0) { 
    267267      retvals[0] = nodes[0][index]; 
    268268      retvals[1] = nodes[1][index]; 
     
    276276  /** Returns the node array */ 
    277277  public float[][] getNodes() { return nodes; } 
    278    
     278 
    279279  /** Returns the number of real nodes in the array */ 
    280280  public int getNumNodes() { return numNodes; } 
    281    
     281 
    282282  /** Returns total number of nodes in array */ 
    283283  public int getMaxNodes() { return maxNodes; } 
    284    
     284 
    285285  /** Gets X coordinate of the overlay's first endpoint. */ 
    286286  public float getX() { return x1; } 
     
    402402    overlay.setTextDrawn(!drawing); 
    403403  } 
    404    
     404 
    405405  /** Gets whether this overlay is still being initially drawn. */ 
    406406  public boolean isDrawing() { return drawing; } 
     
    408408  /** Gets length of curve */ 
    409409  public double getCurveLength() { return curveLength; } 
    410    
     410 
    411411  /** Sets length of curve */ 
    412412  public void setCurveLength(double len) { curveLength = len; } 
     
    423423    this.curveLength = length; 
    424424  } 
    425   
     425 
    426426  // -- OverlayObject API Methods: node array mutators -- 
    427427  // note: call updateBoundingBox() after a series of changes to the node array 
    428    
    429   /** Sets coordinates of an existing node */  
     428 
     429  /** Sets coordinates of an existing node */ 
    430430  public void setNodeCoords(int nodeIndex, float newX, float newY) { 
    431431    if (nodeIndex >= 0 && nodeIndex < numNodes) { 
     
    435435      //System.out.println("Out of bounds error. Can't reset node coordinates"); // TEMP 
    436436    } 
    437   }  
     437  } 
    438438 
    439439  /** Prints node array of current freeform; for debugging */ 
     
    478478    } 
    479479  } 
    480    
     480 
    481481  /** Deletes a range of nodes from the node array */ 
    482482  public void deleteBetween (int i1, int i2) { 
    483483    //assumes i1 < i2, both in bounds (less than numNodes) 
    484484    //checks whether i1 + 1 < i2, i.e., is there a nonzero number of nodes to delete 
    485     if (0 <= i1 && i2 < numNodes && i1 + 1 < i2 ) {  
     485    if (0 <= i1 && i2 < numNodes && i1 + 1 < i2 ) { 
    486486      int victims = i2 - i1 - 1; 
    487487      float[][] newNodes = new float[2][maxNodes - victims]; 
     
    498498    } 
    499499  } 
    500     
     500 
    501501  /** Deletes a node from the node array */ 
    502502  public void deleteNode(int index) { 
     
    519519    } 
    520520  } 
    521      
     521 
    522522  /** Reverses the node array (and therefore its internal orientation) */ 
    523523  public void reverseNodes() { 
    524524    truncateNodeArray(); 
    525     // Q: Is the above call ever necessary?  
    526     // truncateNodeArray() is called at mouseUp in FreeformTool.   
    527     // Will there ever be an extension  
     525    // Q: Is the above call ever necessary? 
     526    // truncateNodeArray() is called at mouseUp in FreeformTool. 
     527    // Will there ever be an extension 
    528528    // of the node array s.t. maxNodes > numNodes during an interior edit before 
    529529    // an extension 
     
    554554      // case where newLength > a.length: 
    555555      // fills rest of new array with nodes co-locational with last node 
    556       for (int i=loopMax; i < a2[0].length; i++) {  
     556      for (int i=loopMax; i < a2[0].length; i++) { 
    557557        a2[j][i] = a[j][loopMax-1]; 
    558558      } 
     
    568568  protected abstract void computeGridParameters(); 
    569569 
    570    
    571570  /** Sets value of largest and smallest x, y values. */ 
    572571  protected void setBoundaries(float x, float y) { 
  • trunk/loci/visbio/state/BioOption.java

    r1264 r1989  
    3535  protected String text; 
    3636 
    37  
    3837  // -- Constructor -- 
    3938 
    4039  /** Constructs a new option. */ 
    4140  public BioOption(String text) { this.text = text; } 
    42  
    4341 
    4442  // -- BioOption API methods -- 
     
    4947  /** Gets a GUI component representing this option. */ 
    5048  public abstract Component getComponent(); 
    51  
    5249 
    5350  // -- Saveable API methods -- 
  • trunk/loci/visbio/state/BooleanOption.java

    r1264 r1989  
    3838  private JCheckBox box; 
    3939 
    40  
    4140  // -- Constructor -- 
    4241 
     
    4948  } 
    5049 
    51  
    5250  // -- BooleanOption API methods -- 
    5351 
     
    5553  public boolean getValue() { return box.isSelected(); } 
    5654 
    57  
    5855  // -- BioOption API methods -- 
    5956 
    6057  /** Gets a GUI component representing this option. */ 
    6158  public Component getComponent() { return box; } 
    62  
    6359 
    6460  // -- Saveable API methods -- 
  • trunk/loci/visbio/state/CustomOption.java

    r1264 r1989  
    3434  private Component c; 
    3535 
    36  
    3736  // -- Constructor -- 
    3837 
     
    4241    this.c = c; 
    4342  } 
    44  
    4543 
    4644  // -- BioOption API methods -- 
  • trunk/loci/visbio/state/ListOption.java

    r1264 r1989  
    4040  private BioComboBox box; 
    4141 
    42  
    4342  // -- Constructor -- 
    4443 
     
    5655  } 
    5756 
    58  
    5957  // -- ListOption API methods -- 
    6058 
     
    6260  public String getValue() { return (String) box.getSelectedItem(); } 
    6361 
    64  
    6562  // -- BioOption API methods -- 
    6663 
    6764  /** Gets a GUI component representing this option. */ 
    6865  public Component getComponent() { return panel; } 
    69  
    7066 
    7167  // -- Saveable API methods -- 
  • trunk/loci/visbio/state/NumericOption.java

    r1264 r1989  
    4242  private JTextField field; 
    4343 
    44  
    4544  // -- Constructor -- 
    4645 
     
    6968  } 
    7069 
    71  
    7270  // -- NumericOption API methods -- 
    7371 
     
    9189  } 
    9290 
    93  
    9491  // -- BioOption API methods -- 
    9592 
     
    9996  /** Sets the GUI component to reflect the given value. */ 
    10097  public void setValue(String value) { field.setText(value); } 
    101  
    10298 
    10399  // -- Saveable API methods -- 
  • trunk/loci/visbio/state/OptionManager.java

    r1264 r1989  
    4444  private static final File CONFIG_FILE = new File("visbio.ini"); 
    4545 
    46  
    4746  // -- Fields -- 
    4847 
     
    5251  /** List of options. */ 
    5352  private Vector list; 
    54  
    5553 
    5654  // -- Constructor -- 
     
    6866    options.addTab("Debug"); 
    6967  } 
    70  
    7168 
    7269  // -- OptionManager API methods -- 
     
    200197  } 
    201198 
    202  
    203199  // -- LogicManager API methods -- 
    204200 
     
    226222  public int getTasks() { return 1; } 
    227223 
    228  
    229224  // -- Saveable API methods -- 
    230225 
     
    249244  } 
    250245 
    251  
    252246  // -- Helper methods -- 
    253247 
     
    257251    bio.setSplashStatus("Initializing options logic"); 
    258252  } 
    259  
    260253 
    261254  // -- Menu commands -- 
  • trunk/loci/visbio/state/OptionPane.java

    r1264 r1989  
    3737  protected static final boolean USE_TABS = false; 
    3838 
    39  
    4039  // -- Fields -- 
    4140 
     
    4847  /** Non-tabbed pane. */ 
    4948  protected JPanel noTabs; 
    50  
    5149 
    5250  // -- Constructor -- 
     
    6765  } 
    6866 
    69  
    7067  // -- OptionPane API methods -- 
    7168 
     
    8481  public void addTab(String tab) { if (USE_TABS) getTab(tab); } 
    8582 
    86  
    8783  // -- DialogPane API methods -- 
    8884 
    8985  /** Resets the dialog pane's components to their default states. */ 
    9086  public void resetComponents() { if (USE_TABS) tabs.setSelectedIndex(0); } 
    91  
    9287 
    9388  // -- Helper methods -- 
  • trunk/loci/visbio/state/ProgramState.java

    r1264 r1989  
    3636  public Document state; 
    3737 
    38  
    3938  // -- Constructor -- 
    4039 
  • trunk/loci/visbio/state/ResolutionOption.java

    r1264 r1989  
    4747  private JTextField resY; 
    4848 
    49  
    5049  // -- Constructor -- 
    5150 
     
    6968  } 
    7069 
    71  
    7270  // -- ResolutionOption API methods -- 
    7371 
     
    8886  } 
    8987 
    90  
    9188  // -- BioOption API methods -- 
    9289 
    9390  /** Gets a GUI component representing this option. */ 
    9491  public Component getComponent() { return panel; } 
    95  
    9692 
    9793  // -- Saveable API methods -- 
  • trunk/loci/visbio/state/ResolutionToggleOption.java

    r1264 r1989  
    5353  private JTextField resY; 
    5454 
    55  
    5655  // -- Constructor -- 
    5756 
     
    8382  } 
    8483 
    85  
    8684  // -- ResolutionToggleOption API methods -- 
    8785 
     
    105103  } 
    106104 
    107  
    108105  // -- BioOption API methods -- 
    109106 
    110107  /** Gets a GUI component representing this option. */ 
    111108  public Component getComponent() { return panel; } 
    112  
    113109 
    114110  // -- ActionListener API methods -- 
     
    120116    resY.setEnabled(b); 
    121117  } 
    122  
    123118 
    124119  // -- Saveable API methods -- 
  • trunk/loci/visbio/state/SaveException.java

    r1264 r1989  
    3232  private Exception exc; 
    3333 
    34  
    3534  // -- Constructors -- 
    3635 
     
    4140  public SaveException(Exception exc) { this.exc = exc; } 
    4241 
    43  
    4442  // -- SaveException API methods -- 
    4543 
    4644  /** Gets the exception upon which this save exception is based. */ 
    4745  public Exception getException() { return exc; } 
    48  
    4946 
    5047  // -- Exception API methods -- 
  • trunk/loci/visbio/state/StateManager.java

    r1264 r1989  
    4343  protected static final String STATE_EXTENSION = "xml"; 
    4444 
    45  
    4645  // -- Fields -- 
    4746 
     
    7574  /** Has the user saved the most recent state? */ 
    7675  private boolean saved = true; 
    77  
    7876 
    7977  // -- Constructors -- 
     
    8785    this.stateFile = new File(stateFile); 
    8886  } 
    89  
    9087 
    9188  // -- StateManager API methods -- 
     
    153150    } 
    154151  } 
    155  
    156152 
    157153  // -- Menu commands -- 
     
    219215  } 
    220216 
    221  
    222217  // -- Saveable API methods -- 
    223218 
     
    244239  } 
    245240 
    246  
    247241  // -- LogicManager API methods -- 
    248242 
     
    282276  /** Gets the number of tasks required to initialize this logic manager. */ 
    283277  public int getTasks() { return 3; } 
    284  
    285278 
    286279  // -- Helper methods -- 
     
    368361    } 
    369362  } 
    370  
    371363 
    372364  // -- Utility methods -- 
  • trunk/loci/visbio/util/BioArrowButton.java

    r1264 r1989  
    3535  protected static final int BUTTON_SIZE = 24; 
    3636 
    37  
    3837  // -- Fields -- 
    3938 
    4039  /** Size of the arrow button in pixels. */ 
    4140  protected Dimension size; 
    42  
    4341 
    4442  // -- Constructors -- 
  • trunk/loci/visbio/util/BioComboBox.java

    r1492 r1989  
    4242  public BioComboBox(String[] s) { super(s); } 
    4343 
    44  
    4544  // -- Component API methods -- 
    4645 
  • trunk/loci/visbio/util/ColorUtil.java

    r1975 r1989  
    538538  } 
    539539 
    540  
    541540  // -- Color table I/O -- 
    542541 
     
    630629      float b = Integer.parseInt(hex.substring(2 * len3), 16) / max; 
    631630      color = new Color(r, g, b); 
    632     } catch (NumberFormatException exc) { throw exc; }  
     631    } catch (NumberFormatException exc) { throw exc; } 
    633632    return color; 
    634633  } 
  • trunk/loci/visbio/util/DataUtil.java

    r1432 r1989  
    172172    return ff; 
    173173  } 
    174  
    175174 
    176175  /** 
  • trunk/loci/visbio/util/DialogPane.java

    r1264 r1989  
    4848  public static final int CANCEL_OPTION = 2; 
    4949 
    50  
    5150  // -- GUI components -- 
    5251 
     
    6362  protected JPanel pane; 
    6463 
    65  
    6664  // -- Other fields -- 
    6765 
     
    7169  /** Return value of dialog. */ 
    7270  protected int rval; 
    73  
    7471 
    7572  // -- Constructors -- 
     
    9491    pane = builder.getPanel(); 
    9592  } 
    96  
    9793 
    9894  // -- DialogPane API methods -- 
     
    147143  } 
    148144 
    149  
    150145  // -- ActionListener API methods -- 
    151146 
     
    162157    } 
    163158  } 
    164  
    165159 
    166160  // -- Helper methods -- 
  • trunk/loci/visbio/util/Docker.java

    r1390 r1989  
    5252  public static final int HIGH_PRIORITY = 10; 
    5353 
    54  
    5554  // -- Fields -- 
    5655 
     
    7574  /** Whether to snap to the edges of the screen. */ 
    7675  protected boolean edges = true; 
    77  
    7876 
    7977  // -- Docker API methods -- 
     
    125123  /** Sets whether windows should snap to the screen edges when close. */ 
    126124  public void setSnapToScreenEdges(boolean snap) { edges = snap; } 
    127  
    128125 
    129126  // -- ComponentListener API methods -- 
     
    204201  } 
    205202 
    206  
    207203  // -- Internal methods - get window characteristics from an index -- 
    208204 
     
    227223  } 
    228224 
    229  
    230225  // -- Internal methods - get window characteristics from a window -- 
    231226 
     
    242237  protected int getPriority(Window w) { return getPriority(getIndex(w)); } 
    243238 
    244  
    245239  // -- Internal methods - dock/undock windows to/from each other -- 
    246240 
     
    250244  /** Undocks window A from window B. */ 
    251245  protected void undock(Window a, Window b) { getDockSet(b).remove(a); } 
    252  
    253246 
    254247  // -- Internal methods - edge comparison/snapping -- 
     
    331324  } 
    332325 
    333  
    334326  // -- Helper methods -- 
    335327 
     
    344336    } 
    345337  } 
    346  
    347338 
    348339  // -- Main method -- 
  • trunk/loci/visbio/util/FontChooserPane.java

    r1264 r1989  
    5252    "--H. L. Mencken"; 
    5353 
    54  
    5554  // -- Fields -- 
    5655 
     
    6968  /** Text area containing preview text with the chosen font settings. */ 
    7069  protected JTextArea previewText; 
    71  
    7270 
    7371  // -- Constructors -- 
     
    106104      fontNames = filteredNames; 
    107105    } 
    108  
    109106 
    110107    int ndx = -1; 
     
    166163  } 
    167164 
    168  
    169165  // -- FontChooserPane API methods -- 
    170166 
    171167  /** Gets the font indicated by the font chooser. */ 
    172168  public Font getSelectedFont() { return previewText.getFont(); } 
    173  
    174169 
    175170  // -- ActionListener API methods -- 
     
    182177  } 
    183178 
    184  
    185179  // -- ChangeListener API methods -- 
    186180 
    187181  /** Handles GUI events. */ 
    188182  public void stateChanged(ChangeEvent e) { refreshFont(); } 
    189  
    190183 
    191184  // -- Helper methods -- 
  • trunk/loci/visbio/util/InstanceServer.java

    r1432 r1989  
    5353  protected boolean alive = true; 
    5454 
    55  
    5655  // -- Static InstanceServer API methods -- 
    5756 
     
    7675  } 
    7776 
    78  
    7977  // -- Constructor -- 
    8078 
     
    8583    new Thread(this, "InstanceServer").start(); 
    8684  } 
    87  
    8885 
    8986  // -- InstanceServer API methods -- 
     
    110107    catch (IOException exc) { exc.printStackTrace(); } 
    111108  } 
    112  
    113109 
    114110  // -- Runnable API methods -- 
     
    142138  } 
    143139 
    144  
    145140  // -- Helper methods -- 
    146141 
  • trunk/loci/visbio/util/MathUtil.java

    r1795 r1989  
    6868    return getDistance(p, v); 
    6969  } 
    70    
     70 
    7171  /** 
    7272   * Computes the minimum distance between the point p and the point v. 
     
    8080    double sum = 0; 
    8181    for (int i=0; i<len; i++) { 
    82       double dist = p[i] - v[i];  
     82      double dist = p[i] - v[i]; 
    8383      sum += dist * dist; 
    8484    } 
     
    9191   * @param a Coordinates of the segment's first endpoint 
    9292   * @param b Coordinates of the segment's second endpoint 
    93    * @param v Coordinates of the point to be projected  
    94    * @param segment Whether the projection should be constrained to the given line segment  
    95    * 
    96    */ 
    97  
    98   public static double[] getProjection (double[] a, double[] b, double[] v, boolean segment)  
     93   * @param v Coordinates of the point to be projected 
     94   * @param segment Whether the projection should be constrained to the given line segment 
     95   * 
     96   */ 
     97 
     98  public static double[] getProjection (double[] a, double[] b, double[] v, boolean segment) 
    9999  { 
    100100    int len = a.length; 
     
    117117    double[] p = new double[len]; 
    118118    for (int i=0; i<len; i++) p[i] = c * ab[i] + a[i]; 
    119      
     119 
    120120    int flag = 0; 
    121121    if (segment) { 
     
    132132    else return b; 
    133133  } 
    134    
    135    /**  Gets distance to curve: finds out if the nearest point is a node or a segment;  
    136    *  
     134 
     135   /**  Gets distance to curve: finds out if the nearest point is a node or a segment; 
     136   * 
    137137   *  @param x x coordinate of point in question 
    138138   *  @param y y coordinate of point in question 
    139    *  @return an array double[3], with element 0 being node index i of one end of  
    140    *  closest line segment (the other end being i+1), and the third being the weight  
     139   *  @return an array double[3], with element 0 being node index i of one end of 
     140   *  closest line segment (the other end being i+1), and the third being the weight 
    141141   *  between zero and one for interpolation along the segment (i, i+1) 
    142    */  
     142   */ 
    143143  public static double[] getDistSegWt(float[][] nodes, float x, float y) { 
    144144    // assumes a non-ragged array of float[2][numNodes] 
    145145    double minDist = Double.MAX_VALUE; 
    146146    int seg = 0; 
    147     double weight = 0;    
     147    double weight = 0; 
    148148 
    149149    int numNodes = nodes[0].length; 
     
    171171           weight = fracDist / segDist; 
    172172         } 
    173        }  
     173       } 
    174174    } 
    175175    double[] retvals = {minDist, (double) seg, weight}; 
  • trunk/loci/visbio/util/MessagePane.java

    r1264 r1989  
    4141  protected JCheckBox always; 
    4242 
    43  
    4443  // -- Constructor -- 
    4544 
     
    6160  } 
    6261 
    63  
    6462  // -- MessagePane API methods -- 
    6563 
  • trunk/loci/visbio/util/ObjectUtil.java

    r1432 r1989  
    175175  } 
    176176 
    177  
    178177  // -- String-to-array conversions -- 
    179178 
     
    267266    return a; 
    268267  } 
    269  
    270268 
    271269  // -- String-to-object conversions -- 
     
    295293  } 
    296294 
    297  
    298295  // -- Array-to-string conversions -- 
    299296 
     
    414411    return sb.toString(); 
    415412  } 
    416  
    417413 
    418414  // -- Object-to-string conversions -- 
     
    435431  } 
    436432 
    437  
    438433  // -- Array copying -- 
    439434 
  • trunk/loci/visbio/util/OutputConsole.java

    r1762 r1989  
    4444  private static final Font MONO = new Font("Monospaced", Font.PLAIN, 11); 
    4545 
    46  
    4746  // -- Fields -- 
    4847 
     
    5251  private String log; 
    5352  private Vector listeners; 
    54  
    5553 
    5654  // -- Constructors -- 
     
    9795  } 
    9896 
    99  
    10097  // -- OutputConsole API methods -- 
    10198 
     
    128125    } 
    129126  } 
    130  
    131127 
    132128  // -- OutputStream API methods -- 
  • trunk/loci/visbio/util/SpawnEvent.java

    r1264 r1989  
    3232  protected String[] args; 
    3333 
    34  
    3534  // -- Constructor -- 
    3635 
    3736  /** Constructs an application instance spawn event. */ 
    3837  public SpawnEvent(String[] args) { this.args = args; } 
    39  
    4038 
    4139  // -- SpawnEvent API methods -- 
  • trunk/loci/visbio/util/SplashScreen.java

    r1390 r1989  
    4949  /** Total number of tasks. */ 
    5050  private int tasks = 0; 
    51  
    5251 
    5352  // -- Constructor -- 
  • trunk/loci/visbio/util/SwingUtil.java