Changeset 6247


Ignore:
Timestamp:
05/07/10 14:17:45 (10 years ago)
Author:
curtis
Message:

Progress on Bio-Formats Importer refactoring.

Location:
trunk/components/loci-plugins
Files:
1 added
15 edited
1 copied

Legend:

Unmodified
Added
Removed
  • trunk/components/loci-plugins/src/loci/plugins/BF.java

    r6246 r6247  
    3434import loci.plugins.in.ImagePlusReader; 
    3535import loci.plugins.in.ImporterOptions; 
     36import loci.plugins.in.ImporterPrompter; 
    3637 
    3738/** 
     
    6667  { 
    6768    options.setQuiet(true); 
    68     options.showDialogs(); 
     69    options.setWindowless(true); 
     70    new ImporterPrompter(options).showDialogs(); 
    6971    ImagePlusReader reader = new ImagePlusReader(options); 
    7072    return reader.openImagePlus(); 
  • trunk/components/loci-plugins/src/loci/plugins/in/CropDialog.java

    r6246 r6247  
    3030import loci.common.Region; 
    3131import loci.formats.IFormatReader; 
    32 import loci.plugins.prefs.OptionsDialog; 
    3332import loci.plugins.util.WindowTools; 
    3433 
     
    4039 * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/loci-plugins/src/loci/plugins/in/CropDialog.java">SVN</a></dd></dl> 
    4140 */ 
    42 public class CropDialog extends OptionsDialog { 
    43  
    44   // -- Fields -- 
    45  
    46   /** LOCI plugins configuration. */ 
    47   protected ImporterOptions options; 
    48  
    49   protected IFormatReader r; 
    50   protected String[] labels; 
     41public class CropDialog extends ImporterDialog { 
    5142 
    5243  // -- Constructor -- 
    5344 
    5445  /** Creates a crop options dialog for the Bio-Formats Importer. */ 
    55   public CropDialog(ImporterOptions options, IFormatReader r, String[] labels) { 
     46  public CropDialog(ImporterOptions options) { 
    5647    super(options); 
    57     this.options = options; 
    58     this.r = r; 
    59     this.labels = labels; 
    6048  } 
     49   
     50  // -- ImporterDialog methods -- 
    6151 
    62   // -- OptionsDialog methods -- 
     52  @Override 
     53  protected boolean needPrompt() { 
     54    return !options.isWindowless() && options.doCrop(); 
     55  } 
     56   
     57  @Override 
     58  protected GenericDialog constructDialog() { 
     59    // -- CTR TODO - refactor crop-related options into CropOptions class 
     60    // has a normalize(IFormatReader) method 
     61    // call both before and after the dialog here... 
    6362 
    64   /** 
    65    * Gets crop settings from macro options, or user prompt if necessary. 
    66    * 
    67    * @return status of operation 
    68    */ 
    69   public int showDialog() { 
     63    int seriesCount = options.getSeriesCount(); 
     64    IFormatReader r = options.getReader(); 
     65     
     66    // construct dialog 
    7067    GenericDialog gd = new GenericDialog("Bio-Formats Crop Options"); 
    71     for (int s=0; s<options.getSeriesCount(); s++) { 
     68    for (int s=0; s<seriesCount; s++) { 
    7269      if (!options.isSeriesOn(s)) continue; 
    7370      r.setSeries(s); 
    74       gd.addMessage(labels[s].replaceAll("_", " ")); 
     71 
     72      Region region = options.getCropRegion(s); 
     73      if (region == null) 
     74 
     75      gd.addMessage(options.getSeriesLabel(s).replaceAll("_", " ")); 
    7576      gd.addNumericField("X_Coordinate_" + (s + 1), 0, 0); 
    7677      gd.addNumericField("Y_Coordinate_" + (s + 1), 0, 0); 
     
    7980    } 
    8081    WindowTools.addScrollBars(gd); 
    81     gd.showDialog(); 
    82     if (gd.wasCanceled()) return STATUS_CANCELED; 
     82  
     83    return gd; 
     84  } 
     85   
     86  @Override 
     87  protected void harvestResults(GenericDialog gd) { 
     88    int seriesCount = options.getSeriesCount(); 
     89    IFormatReader r = options.getReader(); 
    8390 
    84     for (int s=0; s<options.getSeriesCount(); s++) { 
     91    for (int s=0; s<seriesCount; s++) { 
    8592      if (!options.isSeriesOn(s)) continue; 
    8693      r.setSeries(s); 
    8794 
    88       Region box = options.getCropRegion(s); 
     95      Region region = options.getCropRegion(s); 
     96      if (region == null) region = new Region(); 
    8997 
    90       box.x = (int) gd.getNextNumber(); 
    91       box.y = (int) gd.getNextNumber(); 
    92       box.width = (int) gd.getNextNumber(); 
    93       box.height = (int) gd.getNextNumber(); 
     98      region.x = (int) gd.getNextNumber(); 
     99      region.y = (int) gd.getNextNumber(); 
     100      region.width = (int) gd.getNextNumber(); 
     101      region.height = (int) gd.getNextNumber(); 
    94102 
    95       if (box.x < 0) box.x = 0; 
    96       if (box.y < 0) box.y = 0; 
    97       if (box.x >= r.getSizeX()) box.x = r.getSizeX() - box.width - 1; 
    98       if (box.y >= r.getSizeY()) box.y = r.getSizeY() - box.height - 1; 
    99       if (box.width < 1) box.width = 1; 
    100       if (box.height < 1) box.height = 1; 
    101       if (box.width + box.x > r.getSizeX()) { 
    102         box.width = r.getSizeX() - box.x; 
     103      if (region.x < 0) region.x = 0; 
     104      if (region.y < 0) region.y = 0; 
     105      if (region.x >= r.getSizeX()) region.x = r.getSizeX() - region.width - 1; 
     106      if (region.y >= r.getSizeY()) region.y = r.getSizeY() - region.height - 1; 
     107      if (region.width < 1) region.width = 1; 
     108      if (region.height < 1) region.height = 1; 
     109      if (region.width + region.x > r.getSizeX()) { 
     110        region.width = r.getSizeX() - region.x; 
    103111      } 
    104       if (box.height + box.y > r.getSizeY()) { 
    105         box.height = r.getSizeY() - box.y; 
     112      if (region.height + region.y > r.getSizeY()) { 
     113        region.height = r.getSizeY() - region.y; 
    106114      } 
    107115 
    108       options.setCropRegion(s, box); // in case we got a copy 
     116      options.setCropRegion(s, region); // in case we got a copy 
    109117    } 
    110  
    111     return STATUS_OK; 
    112118  } 
    113  
     119   
    114120} 
  • trunk/components/loci-plugins/src/loci/plugins/in/FilePatternDialog.java

    r6229 r6247  
    2828import ij.IJ; 
    2929import ij.gui.GenericDialog; 
     30 
    3031import loci.common.Location; 
    3132import loci.formats.FilePattern; 
    32 import loci.plugins.prefs.OptionsDialog; 
    3333 
    3434/** 
     
    3939 * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/loci-plugins/src/loci/plugins/in/FilePatternDialog.java">SVN</a></dd></dl> 
    4040 */ 
    41 public class FilePatternDialog extends OptionsDialog { 
    42  
    43   // -- Fields -- 
    44  
    45   /** LOCI plugins configuration. */ 
    46   protected ImporterOptions options; 
     41public class FilePatternDialog extends ImporterDialog { 
    4742 
    4843  // -- Constructor -- 
     
    5146  public FilePatternDialog(ImporterOptions options) { 
    5247    super(options); 
    53     this.options = options; 
    5448  } 
     49   
     50  // -- ImporterDialog methods -- 
    5551 
    56   // -- OptionsDialog methods -- 
    57  
    58   /** 
    59    * Gets file pattern from macro options, or user prompt if necessary. 
    60    * 
    61    * @return status of operation 
    62    */ 
    63   public int showDialog() { 
    64     if (options.isWindowless()) return STATUS_OK; 
    65  
     52  @Override 
     53  protected boolean needPrompt() { 
     54    return !options.isWindowless() && options.isGroupFiles(); 
     55  } 
     56   
     57  @Override 
     58  protected GenericDialog constructDialog() { 
     59    // CTR - CHECK 
    6660    Location idLoc = new Location(options.getId()); 
    6761    String id = FilePattern.findPattern(idLoc); 
    68     if (id == null && !options.isQuiet()) { 
    69       IJ.showMessage("Bio-Formats", 
    70         "Warning: Bio-Formats was unable to determine a grouping that\n" + 
    71         "includes the file you chose. The most common reason for this\n" + 
    72         "situation is that the folder contains extraneous files with " + 
    73         "similar\n" + 
    74         "names and numbers that confuse the detection algorithm.\n" + 
    75         " \n" + 
    76         "For example, if you have multiple datasets in the same folder\n" + 
    77         "named series1_z*_c*.tif, series2_z*_c*.tif, etc., Bio-Formats\n" + 
    78         "may try to group all such files into a single series.\n" + 
    79         " \n" + 
    80         "For best results, put each image series's files in their own " + 
    81         "folder,\n" + 
    82         "or type in a file pattern manually.\n"); 
     62    if (id == null) { 
     63      if (!options.isQuiet()) { 
     64        IJ.showMessage("Bio-Formats", 
     65          "Warning: Bio-Formats was unable to determine a grouping that\n" + 
     66          "includes the file you chose. The most common reason for this\n" + 
     67          "situation is that the folder contains extraneous files with\n" + 
     68          "similar names and numbers that confuse the detection algorithm.\n" + 
     69          " \n" + 
     70          "For example, if you have multiple datasets in the same folder\n" + 
     71          "named series1_z*_c*.tif, series2_z*_c*.tif, etc., Bio-Formats\n" + 
     72          "may try to group all such files into a single series.\n" + 
     73          " \n" + 
     74          "For best results, put each image series's files in their own\n" + 
     75          "folder, or type in a file pattern manually.\n"); 
     76      } 
    8377      id = idLoc.getAbsolutePath(); 
    8478    } 
    8579 
    86     // prompt user to confirm file pattern (or grab from macro options) 
     80    // construct dialog 
    8781    GenericDialog gd = new GenericDialog("Bio-Formats File Stitching"); 
    8882    int len = id.length() + 1; 
    8983    if (len > 80) len = 80; 
    9084    gd.addStringField("Pattern: ", id, len); 
    91     gd.showDialog(); 
    92     if (gd.wasCanceled()) return STATUS_CANCELED; 
    93     id = gd.getNextString(); 
    9485 
     86    return gd; 
     87  } 
     88   
     89  @Override 
     90  protected void harvestResults(GenericDialog gd) { 
     91    String id = gd.getNextString(); 
    9592    options.setId(id); 
    96     return STATUS_OK; 
    9793  } 
    9894 
  • trunk/components/loci-plugins/src/loci/plugins/in/IdDialog.java

    r6229 r6247  
    3030import ij.io.OpenDialog; 
    3131import loci.common.Location; 
     32import loci.plugins.BF; 
    3233import loci.plugins.prefs.OptionsDialog; 
    3334 
     
    4344  // -- Fields -- 
    4445 
    45   /** LOCI plugins configuration. */ 
    4646  protected ImporterOptions options; 
    4747 
     
    5353    this.options = options; 
    5454  } 
    55  
     55   
    5656  // -- IdDialog methods -- 
    5757 
     
    8181      } 
    8282    } 
     83 
    8384    String id = options.getId(); 
    8485    if (id == null) { 
    85       // prompt user for the filename (or grab from macro options) 
     86      // construct and display dialog (or grab from macro options) 
    8687      String idLabel = options.getLabel(ImporterOptions.KEY_ID); 
    8788      OpenDialog od = new OpenDialog(idLabel, id); 
     89 
     90      // harvest results 
    8891      String dir = od.getDirectory(); 
    8992      String name = od.getFileName(); 
     
    9295    } 
    9396 
    94     // verify that id is valid 
     97    // verify validity 
    9598    Location idLoc = new Location(id); 
    9699    if (!idLoc.exists() && !id.toLowerCase().endsWith(".fake")) { 
     
    101104      return STATUS_FINISHED; 
    102105    } 
     106    options.setId(id); 
    103107 
    104     options.setId(id); 
    105108    return STATUS_OK; 
    106109  } 
     
    115118    String id = options.getId(); 
    116119    if (id == null) { 
    117       // prompt user for the URL (or grab from macro options) 
     120      // construct dialog 
    118121      GenericDialog gd = new GenericDialog("Bio-Formats URL"); 
    119122      gd.addStringField("URL: ", "http://", 30); 
     123 
     124      // display dialog (or grab from macro options) 
    120125      gd.showDialog(); 
    121126      if (gd.wasCanceled()) return STATUS_CANCELED; 
     127 
     128      // harvest results 
    122129      id = gd.getNextString(); 
    123130    } 
    124131 
    125     // verify that id is valid 
     132    // verify validity 
    126133    if (id == null) { 
    127134      if (!options.isQuiet()) IJ.error("Bio-Formats", "No URL was specified."); 
    128135      return STATUS_FINISHED; 
    129136    } 
    130  
    131137    options.setId(id); 
    132     return STATUS_OK; 
    133   } 
    134  
    135   /** 
    136    * Gets the OME server and image (id) to open from macro options, 
    137    * or user prompt if necessary. 
    138    * 
    139    * @return status of operation 
    140    */ 
    141   public int showDialogOME() { 
    142     String id = options.getId(); 
    143     if (id == null) { 
    144       // TODO: eliminate OMEPlugin kludge 
    145       IJ.runPlugIn("loci.plugins.ome.OMEPlugin", ""); 
    146       return STATUS_FINISHED; 
    147     } 
    148138 
    149139    return STATUS_OK; 
     
    158148   */ 
    159149  public int showDialog() { 
     150    // verify whether prompt is necessary 
     151    if (options.isWindowless()) { 
     152      BF.debug("IdDialog: skip"); 
     153      return STATUS_OK; 
     154    } 
     155    BF.debug("IdDialog: prompt"); 
     156 
    160157    if (options.isLocal()) return showDialogLocal(); 
    161     else if (options.isHTTP()) return showDialogHTTP(); 
    162     else return showDialogOME(); // options.isOME() 
     158    return showDialogHTTP(); // options.isHTTP() 
    163159  } 
    164160 
  • trunk/components/loci-plugins/src/loci/plugins/in/ImagePlusReader.java

    r6246 r6247  
    130130    throws FormatException, IOException 
    131131  { 
     132    List<ImagePlus> imps = new ArrayList<ImagePlus>(); 
     133 
    132134    // beginning timing 
    133135    long startTime = System.currentTimeMillis(); 
     
    135137 
    136138    ImageProcessorReader r = options.getReader(); 
    137     List<ImagePlus> imps = new ArrayList<ImagePlus>(); 
    138139    stackOrder = null; 
    139140    colorModels = null; 
     
    154155      int cBegin = options.getCBegin(s); 
    155156      int cEnd = options.getCEnd(s); 
     157      if (cEnd < 0) cEnd = r.getEffectiveSizeC() - 1; 
    156158      int cStep = options.getCStep(s); 
    157159      int zBegin = options.getZBegin(s); 
    158160      int zEnd = options.getZEnd(s); 
     161      if (zEnd < 0) zEnd = r.getSizeZ() - 1; 
    159162      int zStep = options.getZStep(s); 
    160163      int tBegin = options.getTBegin(s); 
    161164      int tEnd = options.getTEnd(s); 
     165      if (tEnd < 0) tEnd = r.getSizeT() - 1; 
    162166      int tStep = options.getTStep(s); 
    163167      for (int c=cBegin; c<=cEnd; c+=cStep) { 
  • trunk/components/loci-plugins/src/loci/plugins/in/Importer.java

    r6246 r6247  
    118118    throws FormatException, IOException 
    119119  { 
    120     boolean success = options.showDialogs(); 
     120    boolean success = new ImporterPrompter(options).showDialogs(); 
    121121    if (!success) plugin.canceled = true; 
    122122  } 
  • trunk/components/loci-plugins/src/loci/plugins/in/ImporterDialog.java

    r6229 r6247  
    11// 
    2 // ImporterDialog.java 
     2// FilePatternDialog.java 
    33// 
    44 
     
    2727 
    2828import ij.gui.GenericDialog; 
    29  
    30 import java.awt.Checkbox; 
    31 import java.awt.Choice; 
    32 import java.awt.Color; 
    33 import java.awt.Component; 
    34 import java.awt.KeyboardFocusManager; 
    35 import java.awt.Label; 
    36 import java.awt.event.FocusEvent; 
    37 import java.awt.event.FocusListener; 
    38 import java.awt.event.ItemEvent; 
    39 import java.awt.event.ItemListener; 
    40 import java.awt.event.MouseEvent; 
    41 import java.awt.event.MouseListener; 
    42 import java.util.HashMap; 
    43 import java.util.Vector; 
    44  
    45 import javax.swing.JEditorPane; 
    46 import javax.swing.JScrollPane; 
    47  
     29import loci.plugins.BF; 
    4830import loci.plugins.prefs.OptionsDialog; 
    49 import loci.plugins.util.WindowTools; 
    50  
    51 import com.jgoodies.forms.builder.PanelBuilder; 
    52 import com.jgoodies.forms.layout.CellConstraints; 
    53 import com.jgoodies.forms.layout.FormLayout; 
    5431 
    5532/** 
    56  * Bio-Formats Importer general options dialog box. 
     33 * Abstract superclass of importer dialogs. 
    5734 * 
    5835 * <dl><dt><b>Source code:</b></dt> 
    59  * <dd><a href="https://skyking.microscopy.wisc.edu/trac/java/browser/trunk/components/loci-plugins/src/loci/plugins/in/ImporterDialog.java">Trac</a>, 
    60  * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/loci-plugins/src/loci/plugins/in/ImporterDialog.java">SVN</a></dd></dl> 
     36 * <dd><a href="https://skyking.microscopy.wisc.edu/trac/java/browser/trunk/components/loci-plugins/src/loci/plugins/in/FilePatternDialog.java">Trac</a>, 
     37 * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/loci-plugins/src/loci/plugins/in/FilePatternDialog.java">SVN</a></dd></dl> 
    6138 */ 
    62 public class ImporterDialog extends OptionsDialog 
    63   implements FocusListener, ItemListener, MouseListener 
    64 { 
    65  
    66   // -- Constants -- 
    67  
    68   /** Initial message to display in help text box. */ 
    69   public static final String INFO_DEFAULT = 
    70     "<i>Select an option for a detailed explanation. " + 
    71     "Documentation written by Glen MacDonald and Curtis Rueden.</i>"; 
     39public abstract class ImporterDialog extends OptionsDialog { 
    7240 
    7341  // -- Fields -- 
    7442 
    75   /** LOCI plugins configuration. */ 
    7643  protected ImporterOptions options; 
    77  
    78   protected Checkbox autoscaleBox; 
    79   protected Checkbox colorizeBox; 
    80   protected Checkbox concatenateBox; 
    81   protected Checkbox cropBox; 
    82   protected Checkbox customColorizeBox; 
    83   protected Checkbox groupFilesBox; 
    84   protected Checkbox ungroupFilesBox; 
    85   protected Checkbox mergeChannelsBox; 
    86   protected Checkbox openAllSeriesBox; 
    87   protected Checkbox recordBox; 
    88   protected Checkbox showMetadataBox; 
    89   protected Checkbox showOMEXMLBox; 
    90   protected Checkbox showROIsBox; 
    91   protected Checkbox specifyRangesBox; 
    92   protected Checkbox splitZBox; 
    93   protected Checkbox splitTBox; 
    94   protected Checkbox splitCBox; 
    95   protected Choice stackFormatChoice; 
    96   protected Choice stackOrderChoice; 
    97   protected Checkbox swapDimsBox; 
    98   protected Checkbox virtualBox; 
    99  
    100   protected HashMap<Component, String> infoTable; 
    101   protected JEditorPane infoPane; 
    10244 
    10345  // -- Constructor -- 
    10446 
    105   /** Creates a general options dialog for the Bio-Formats Importer. */ 
    10647  public ImporterDialog(ImporterOptions options) { 
    10748    super(options); 
     
    10950  } 
    11051 
     52  // -- ImporterDialog methods -- 
     53 
     54  protected abstract boolean needPrompt(); 
     55 
     56  protected abstract GenericDialog constructDialog(); 
     57 
     58  /** Displays the dialog, or grabs values from macro options. */ 
     59  protected boolean displayDialog(GenericDialog gd) { 
     60    gd.showDialog(); 
     61    return !gd.wasCanceled(); 
     62  } 
     63 
     64  protected abstract void harvestResults(GenericDialog gd); 
     65 
    11166  // -- OptionsDialog methods -- 
    11267 
    113   /** 
    114    * Gets importer settings from macro options, or user prompt if necessary. 
    115    * 
    116    * @return status of operation 
    117    */ 
     68  @Override 
    11869  public int showDialog() { 
    119     // prompt user for parameters (or grab from macro options) 
    120     GenericDialog gd = new GenericDialog("Bio-Formats Import Options"); 
    121     addCheckbox(gd, ImporterOptions.KEY_AUTOSCALE); 
    122     addCheckbox(gd, ImporterOptions.KEY_COLORIZE); 
    123     addCheckbox(gd, ImporterOptions.KEY_CONCATENATE); 
    124     addCheckbox(gd, ImporterOptions.KEY_CROP); 
    125     addCheckbox(gd, ImporterOptions.KEY_CUSTOM_COLORIZE); 
    126     addCheckbox(gd, ImporterOptions.KEY_GROUP_FILES); 
    127     addCheckbox(gd, ImporterOptions.KEY_UNGROUP_FILES); 
    128     addCheckbox(gd, ImporterOptions.KEY_MERGE_CHANNELS); 
    129     addCheckbox(gd, ImporterOptions.KEY_OPEN_ALL_SERIES); 
    130     addCheckbox(gd, ImporterOptions.KEY_QUIET); // NB: invisible 
    131     addCheckbox(gd, ImporterOptions.KEY_RECORD); 
    132     addCheckbox(gd, ImporterOptions.KEY_SHOW_METADATA); 
    133     addCheckbox(gd, ImporterOptions.KEY_SHOW_OME_XML); 
    134     addCheckbox(gd, ImporterOptions.KEY_SHOW_ROIS); 
    135     addCheckbox(gd, ImporterOptions.KEY_SPECIFY_RANGES); 
    136     addCheckbox(gd, ImporterOptions.KEY_SPLIT_Z); 
    137     addCheckbox(gd, ImporterOptions.KEY_SPLIT_T); 
    138     addCheckbox(gd, ImporterOptions.KEY_SPLIT_C); 
    139     addChoice(gd, ImporterOptions.KEY_STACK_FORMAT); 
    140     addChoice(gd, ImporterOptions.KEY_STACK_ORDER); 
    141     addCheckbox(gd, ImporterOptions.KEY_SWAP_DIMS); 
    142     addCheckbox(gd, ImporterOptions.KEY_VIRTUAL); 
     70    // verify whether prompt is necessary 
     71    if (!needPrompt()) { 
     72      BF.debug(getClass().getName() + ": skip"); 
     73      return STATUS_OK; 
     74    } 
     75    BF.debug(getClass().getName() + ": prompt"); 
    14376 
    144     // extract GUI components from dialog and add listeners 
    145     Vector<Checkbox> boxes = null; 
    146     Vector<Choice> choices = null; 
    147     Vector<Label> labels = null; 
    148     Label stackFormatLabel = null, stackOrderLabel = null; 
    149     Component[] c = gd.getComponents(); 
    150     if (c != null) { 
    151       boxes = new Vector<Checkbox>(); 
    152       choices = new Vector<Choice>(); 
    153       labels = new Vector<Label>(); 
    154       for (int i=0; i<c.length; i++) { 
    155         if (c[i] instanceof Checkbox) { 
    156           Checkbox item = (Checkbox) c[i]; 
    157           item.addFocusListener(this); 
    158           item.addItemListener(this); 
    159           item.addMouseListener(this); 
    160           boxes.add(item); 
    161         } 
    162         else if (c[i] instanceof Choice) { 
    163           Choice item = (Choice) c[i]; 
    164           item.addFocusListener(this); 
    165           item.addItemListener(this); 
    166           item.addMouseListener(this); 
    167           choices.add(item); 
    168         } 
    169         else if (c[i] instanceof Label) labels.add((Label) c[i]); 
    170       } 
    171       autoscaleBox      = boxes.get(0); 
    172       colorizeBox       = boxes.get(1); 
    173       concatenateBox    = boxes.get(2); 
    174       cropBox           = boxes.get(3); 
    175       customColorizeBox = boxes.get(4); 
    176       groupFilesBox     = boxes.get(5); 
    177       ungroupFilesBox   = boxes.get(6); 
    178       mergeChannelsBox  = boxes.get(7); 
    179       openAllSeriesBox  = boxes.get(8); 
    180       //quietBox        = boxes.get(9); 
    181       recordBox         = boxes.get(10); 
    182       showMetadataBox   = boxes.get(11); 
    183       showOMEXMLBox     = boxes.get(12); 
    184       showROIsBox       = boxes.get(13); 
    185       specifyRangesBox  = boxes.get(14); 
    186       splitZBox         = boxes.get(15); 
    187       splitTBox         = boxes.get(16); 
    188       splitCBox         = boxes.get(17); 
    189       stackFormatChoice = choices.get(0); 
    190       stackFormatLabel  = labels.get(0); 
    191       stackOrderChoice  = choices.get(1); 
    192       stackOrderLabel   = labels.get(1); 
    193       swapDimsBox       = boxes.get(18); 
    194       virtualBox        = boxes.get(19); 
    195     } 
    196     verifyOptions(null); 
    197  
    198     // associate information for each option 
    199     infoTable = new HashMap<Component, String>(); 
    200     infoTable.put(autoscaleBox, options.getAutoscaleInfo()); 
    201     infoTable.put(colorizeBox, options.getColorizeInfo()); 
    202     infoTable.put(concatenateBox, options.getConcatenateInfo()); 
    203     infoTable.put(cropBox, options.getCropInfo()); 
    204     infoTable.put(customColorizeBox, options.getCustomColorizeInfo()); 
    205     infoTable.put(groupFilesBox, options.getGroupFilesInfo()); 
    206     infoTable.put(ungroupFilesBox, options.getUngroupFilesInfo()); 
    207     infoTable.put(mergeChannelsBox, options.getMergeChannelsInfo()); 
    208     infoTable.put(openAllSeriesBox, options.getOpenAllSeriesInfo()); 
    209     infoTable.put(recordBox, options.getRecordInfo()); 
    210     infoTable.put(showMetadataBox, options.getShowMetadataInfo()); 
    211     infoTable.put(showOMEXMLBox, options.getShowOMEXMLInfo()); 
    212     infoTable.put(showROIsBox, options.getShowROIsInfo()); 
    213     infoTable.put(specifyRangesBox, options.getSpecifyRangesInfo()); 
    214     infoTable.put(splitZBox, options.getSplitFocalPlanesInfo()); 
    215     infoTable.put(splitTBox, options.getSplitTimepointsInfo()); 
    216     infoTable.put(splitCBox, options.getSplitChannelsInfo()); 
    217     infoTable.put(stackFormatChoice, options.getStackFormatInfo()); 
    218     infoTable.put(stackFormatLabel, options.getStackFormatInfo()); 
    219     infoTable.put(stackOrderChoice, options.getStackOrderInfo()); 
    220     infoTable.put(stackOrderLabel, options.getStackOrderInfo()); 
    221     infoTable.put(swapDimsBox, options.getSwapDimensionsInfo()); 
    222     infoTable.put(virtualBox, options.getVirtualInfo()); 
    223  
    224     // rebuild dialog using FormLayout to organize things more nicely 
    225  
    226     String cols = 
    227       // first column 
    228       "pref, 3dlu, pref:grow, " + 
    229       // second column 
    230       "10dlu, pref"; 
    231  
    232     String rows = 
    233       // Stack viewing        | Metadata viewing 
    234       "pref, 3dlu, pref, 3dlu, pref, 3dlu, pref, " + 
    235       // Dataset organization | Memory management 
    236       "9dlu, pref, 3dlu, pref, 3dlu, pref, 3dlu, pref, 3dlu, pref, " + 
    237       "3dlu, pref, " + 
    238       // Color options        | Split into separate windows 
    239       "9dlu, pref, 3dlu, pref, 3dlu, pref, 3dlu, pref, 3dlu, pref, " + 
    240       // Information 
    241       "9dlu, pref, 3dlu, fill:100dlu"; 
    242  
    243     // TODO: change "Merge channels into RGB" checkbox to 
    244     // "Channel merging" choice with options: 
    245     //   "Default", "Merge channels" or "Separate channels" 
    246  
    247     // TODO: change "Use virtual stack" and "Record modifications to virtual 
    248     // stack" checkboxes to "Stack type" choice with options: 
    249     //   "Normal", "Virtual" or "Smart virtual" 
    250  
    251     PanelBuilder builder = new PanelBuilder(new FormLayout(cols, rows)); 
    252     CellConstraints cc = new CellConstraints(); 
    253  
    254     // populate 1st column 
    255     int row = 1; 
    256     builder.addSeparator("Stack viewing", cc.xyw(1, row, 3)); 
    257     row += 2; 
    258     builder.add(stackFormatLabel, cc.xy(1, row)); 
    259     builder.add(stackFormatChoice, cc.xy(3, row)); 
    260     row += 2; 
    261     builder.add(stackOrderLabel, cc.xy(1, row)); 
    262     builder.add(stackOrderChoice, cc.xy(3, row)); 
    263     row += 4; 
    264     builder.addSeparator("Dataset organization", cc.xyw(1, row, 3)); 
    265     row += 2; 
    266     builder.add(groupFilesBox, xyw(cc, 1, row, 3)); 
    267     row += 2; 
    268     builder.add(ungroupFilesBox, xyw(cc, 1, row, 3)); 
    269     row += 2; 
    270     builder.add(swapDimsBox, xyw(cc, 1, row, 3)); 
    271     row += 2; 
    272     builder.add(openAllSeriesBox, xyw(cc, 1, row, 3)); 
    273     row += 2; 
    274     builder.add(concatenateBox, xyw(cc, 1, row, 3)); 
    275     row += 2; 
    276     builder.addSeparator("Color options", cc.xyw(1, row, 3)); 
    277     row += 2; 
    278     builder.add(mergeChannelsBox, xyw(cc, 1, row, 3)); 
    279     row += 2; 
    280     builder.add(colorizeBox, xyw(cc, 1, row, 3)); 
    281     row += 2; 
    282     builder.add(customColorizeBox, xyw(cc, 1, row, 3)); 
    283     row += 2; 
    284     builder.add(autoscaleBox, xyw(cc, 1, row, 3)); 
    285     row += 2; 
    286  
    287     // populate 2nd column 
    288     row = 1; 
    289     builder.addSeparator("Metadata viewing", cc.xy(5, row)); 
    290     row += 2; 
    291     builder.add(showMetadataBox, xyw(cc, 5, row, 1)); 
    292     row += 2; 
    293     builder.add(showOMEXMLBox, xyw(cc, 5, row, 1)); 
    294     row += 2; 
    295     builder.add(showROIsBox, xyw(cc, 5, row, 1)); 
    296     row += 2; 
    297     builder.addSeparator("Memory management", cc.xy(5, row)); 
    298     row += 2; 
    299     builder.add(virtualBox, xyw(cc, 5, row, 1)); 
    300     row += 2; 
    301     builder.add(recordBox, xyw(cc, 5, row, 1)); 
    302     row += 2; 
    303     builder.add(specifyRangesBox, xyw(cc, 5, row, 1)); 
    304     row += 2; 
    305     builder.add(cropBox, xyw(cc, 5, row, 1)); 
    306     row += 4; 
    307     builder.addSeparator("Split into separate windows", cc.xy(5, row)); 
    308     row += 2; 
    309     builder.add(splitCBox, xyw(cc, 5, row, 1)); 
    310     row += 2; 
    311     builder.add(splitZBox, xyw(cc, 5, row, 1)); 
    312     row += 2; 
    313     builder.add(splitTBox, xyw(cc, 5, row, 1)); 
    314     row += 4; 
    315  
    316     // information section 
    317     builder.addSeparator("Information", cc.xyw(1, row, 5)); 
    318     row += 2; 
    319     infoPane = new JEditorPane(); 
    320     infoPane.setContentType("text/html"); 
    321     infoPane.setEditable(false); 
    322     infoPane.setText("<html>" + INFO_DEFAULT); 
    323     builder.add(new JScrollPane(infoPane), cc.xyw(1, row, 5)); 
    324     row += 2; 
    325  
    326     gd.removeAll(); 
    327     gd.add(builder.getPanel()); 
    328  
    329     // display dialog to user and harvest results 
    330     WindowTools.addScrollBars(gd); 
    331     gd.setBackground(Color.white); // HACK: workaround for JPanel in a Dialog 
    332     gd.showDialog(); 
    333     if (gd.wasCanceled()) return STATUS_CANCELED; 
    334     options.setAutoscale(gd.getNextBoolean()); 
    335     options.setColorize(gd.getNextBoolean()); 
    336     options.setConcatenate(gd.getNextBoolean()); 
    337     options.setCrop(gd.getNextBoolean()); 
    338     options.setCustomColorize(gd.getNextBoolean()); 
    339     options.setGroupFiles(gd.getNextBoolean()); 
    340     options.setUngroupFiles(gd.getNextBoolean()); 
    341     options.setMergeChannels(gd.getNextBoolean()); 
    342     options.setOpenAllSeries(gd.getNextBoolean()); 
    343     options.setQuiet(gd.getNextBoolean()); // NB: invisible 
    344     options.setRecord(gd.getNextBoolean()); 
    345     options.setShowMetadata(gd.getNextBoolean()); 
    346     options.setShowOMEXML(gd.getNextBoolean()); 
    347     options.setShowROIs(gd.getNextBoolean()); 
    348     options.setSpecifyRanges(gd.getNextBoolean()); 
    349     options.setSplitFocalPlanes(gd.getNextBoolean()); 
    350     options.setSplitTimepoints(gd.getNextBoolean()); 
    351     options.setSplitChannels(gd.getNextBoolean()); 
    352     options.setStackFormat(options.getStackFormats()[gd.getNextChoiceIndex()]); 
    353     options.setStackOrder(options.getStackOrders()[gd.getNextChoiceIndex()]); 
    354     options.setSwapDimensions(gd.getNextBoolean()); 
    355     options.setVirtual(gd.getNextBoolean()); 
     77    GenericDialog gd = constructDialog(); 
     78    if (!displayDialog(gd)) return STATUS_CANCELED; 
     79    harvestResults(gd); 
    35680 
    35781    return STATUS_OK; 
    35882  } 
    35983 
    360   // -- FocusListener methods -- 
    361  
    362   /** Handles information pane updates when component focus changes. */ 
    363   public void focusGained(FocusEvent e) { 
    364     Object src = e.getSource(); 
    365     String text = infoTable.get(src); 
    366     infoPane.setText("<html>" + text); 
    367     infoPane.setCaretPosition(0); 
    368   } 
    369  
    370   public void focusLost(FocusEvent e) { } 
    371  
    372   // -- ItemListener methods -- 
    373  
    374   /** Handles toggling of mutually exclusive options. */ 
    375   public void itemStateChanged(ItemEvent e) { 
    376     verifyOptions(e.getSource()); 
    377   } 
    378  
    379   // -- MouseListener methods -- 
    380  
    381   /** Focuses the component upon mouseover. */ 
    382   public void mouseEntered(MouseEvent e) { 
    383     Object src = e.getSource(); 
    384     if (src instanceof Component) { 
    385       ((Component) src).requestFocusInWindow(); 
    386     } 
    387   } 
    388  
    389   public void mouseClicked(MouseEvent e) { } 
    390   public void mouseExited(MouseEvent e) { } 
    391   public void mousePressed(MouseEvent e) { } 
    392   public void mouseReleased(MouseEvent e) { } 
    393  
    394   // -- Helper methods -- 
    395  
    396   /** 
    397    * Convenience method for creating a left-aligned, 
    398    * vertically centered cell constraints object. 
    399    */ 
    400   private CellConstraints xyw(CellConstraints cc, int x, int y, int w) { 
    401     return cc.xyw(x, y, w, CellConstraints.LEFT, CellConstraints.CENTER); 
    402   } 
    403  
    404   /** Ensures that the options dialog has no mutually exclusive options. */ 
    405   private void verifyOptions(Object src) { 
    406     // record GUI state 
    407  
    408     boolean autoscaleEnabled = autoscaleBox.isEnabled(); 
    409     boolean colorizeEnabled = colorizeBox.isEnabled(); 
    410     boolean concatenateEnabled = concatenateBox.isEnabled(); 
    411     boolean cropEnabled = cropBox.isEnabled(); 
    412     boolean customColorizeEnabled = customColorizeBox.isEnabled(); 
    413     boolean groupFilesEnabled = groupFilesBox.isEnabled(); 
    414     boolean ungroupFilesEnabled = ungroupFilesBox.isEnabled(); 
    415     boolean mergeChannelsEnabled = mergeChannelsBox.isEnabled(); 
    416     boolean openAllSeriesEnabled = openAllSeriesBox.isEnabled(); 
    417     boolean recordEnabled = recordBox.isEnabled(); 
    418     boolean showMetadataEnabled = showMetadataBox.isEnabled(); 
    419     boolean showOMEXMLEnabled = showOMEXMLBox.isEnabled(); 
    420     boolean specifyRangesEnabled = specifyRangesBox.isEnabled(); 
    421     boolean splitZEnabled = splitZBox.isEnabled(); 
    422     boolean splitTEnabled = splitTBox.isEnabled(); 
    423     boolean splitCEnabled = splitCBox.isEnabled(); 
    424     //boolean stackFormatEnabled = stackFormatChoice.isEnabled(); 
    425     boolean stackOrderEnabled = stackOrderChoice.isEnabled(); 
    426     boolean swapDimsEnabled = swapDimsBox.isEnabled(); 
    427     boolean virtualEnabled = virtualBox.isEnabled(); 
    428  
    429     boolean isAutoscale = autoscaleBox.getState(); 
    430     boolean isColorize = colorizeBox.getState(); 
    431     boolean isConcatenate = concatenateBox.getState(); 
    432     boolean isCrop = cropBox.getState(); 
    433     boolean isCustomColorize = customColorizeBox.getState(); 
    434     boolean isGroupFiles = groupFilesBox.getState(); 
    435     boolean isUngroupFiles = ungroupFilesBox.getState(); 
    436     boolean isMergeChannels = mergeChannelsBox.getState(); 
    437     boolean isOpenAllSeries = openAllSeriesBox.getState(); 
    438     boolean isRecord = recordBox.getState(); 
    439     boolean isShowMetadata = showMetadataBox.getState(); 
    440     boolean isShowOMEXML = showOMEXMLBox.getState(); 
    441     boolean isSpecifyRanges = specifyRangesBox.getState(); 
    442     boolean isSplitZ = splitZBox.getState(); 
    443     boolean isSplitT = splitTBox.getState(); 
    444     boolean isSplitC = splitCBox.getState(); 
    445     String stackFormatValue = stackFormatChoice.getSelectedItem(); 
    446     boolean isStackNone = stackFormatValue.equals(ImporterOptions.VIEW_NONE); 
    447     boolean isStackStandard = 
    448       stackFormatValue.equals(ImporterOptions.VIEW_STANDARD); 
    449     boolean isStackHyperstack = 
    450       stackFormatValue.equals(ImporterOptions.VIEW_HYPERSTACK); 
    451     boolean isStackBrowser = 
    452       stackFormatValue.equals(ImporterOptions.VIEW_BROWSER); 
    453     boolean isStackVisBio = 
    454       stackFormatValue.equals(ImporterOptions.VIEW_VISBIO); 
    455     boolean isStackImage5D = 
    456       stackFormatValue.equals(ImporterOptions.VIEW_IMAGE_5D); 
    457     boolean isStackView5D = 
    458       stackFormatValue.equals(ImporterOptions.VIEW_VIEW_5D); 
    459     String stackOrderValue = stackOrderChoice.getSelectedItem(); 
    460     boolean isSwap = swapDimsBox.getState(); 
    461     boolean isVirtual = virtualBox.getState(); 
    462  
    463     // toggle availability of each option based on state of earlier options 
    464  
    465     // NB: The order the options are examined here defines their order of 
    466     // precedence. This ordering is necessary because it affects which 
    467     // component states are capable of graying out other components. 
    468  
    469     // For example, we want to disable autoscaleBox when virtualBox is checked, 
    470     // so the virtualBox logic must appear before the autoscaleBox logic. 
    471  
    472     // To make it more intuitive for the user, the order of precedence should 
    473     // match the component layout from left to right, top to bottom, according 
    474     // to subsection. 
    475  
    476     // == Stack viewing == 
    477  
    478     // stackOrderChoice 
    479     stackOrderEnabled = isStackStandard || isStackVisBio; 
    480     if (src == stackFormatChoice) { 
    481       if (isStackHyperstack || isStackBrowser || isStackImage5D) { 
    482         stackOrderValue = ImporterOptions.ORDER_XYCZT; 
    483       } 
    484       else if (isStackView5D) stackOrderValue = ImporterOptions.ORDER_XYZCT; 
    485       else stackOrderValue = ImporterOptions.ORDER_DEFAULT; 
    486     } 
    487  
    488     // == Metadata viewing == 
    489  
    490     // showMetadataBox 
    491     showMetadataEnabled = !isStackNone; 
    492     if (!showMetadataEnabled) isShowMetadata = true; 
    493  
    494     // showOMEXMLBox 
    495     // NB: no other options affect showOMEXMLBox 
    496  
    497     // == Dataset organization == 
    498  
    499     // groupFilesBox 
    500     groupFilesEnabled = !options.isOME() && !options.isOMERO(); 
    501     if (!groupFilesEnabled) isGroupFiles = false; 
    502     else if (src == stackFormatChoice && isStackBrowser) isGroupFiles = true; 
    503  
    504     // ungroupFilesBox 
    505     // NB: no other options affect ungroupFilesBox 
    506  
    507     // swapDimsBox 
    508     // NB: no other options affect swapDimsBox 
    509  
    510     // openAllSeriesBox 
    511     // NB: no other options affect openAllSeriesBox 
    512  
    513     // concatenateBox 
    514     // NB: no other options affect concatenateBox 
    515  
    516     // == Memory management == 
    517  
    518     // virtualBox 
    519     virtualEnabled = !isStackNone && !isStackImage5D && !isStackView5D; 
    520     if (!virtualEnabled) isVirtual = false; 
    521     else if (src == stackFormatChoice && isStackBrowser) isVirtual = true; 
    522  
    523     // recordBox 
    524     recordEnabled = isVirtual; 
    525     if (!recordEnabled) isRecord = false; 
    526  
    527     // specifyRangesBox 
    528     specifyRangesEnabled = !isStackNone && !isVirtual; 
    529     if (!specifyRangesEnabled) isSpecifyRanges = false; 
    530  
    531     // cropBox 
    532     cropEnabled = !isStackNone && !isVirtual; 
    533     if (!cropEnabled) isCrop = false; 
    534  
    535     // == Color options == 
    536  
    537     // mergeChannelsBox 
    538     mergeChannelsEnabled = !isStackImage5D; 
    539     if (!mergeChannelsEnabled) isMergeChannels = false; 
    540  
    541     // colorizeBox 
    542     colorizeEnabled = !isMergeChannels && !isStackBrowser && 
    543       !isStackImage5D && !isStackView5D && !isCustomColorize; 
    544     if (!colorizeEnabled) isColorize = false; 
    545  
    546     // customColorizeBox 
    547     customColorizeEnabled = !isMergeChannels && !isStackBrowser && 
    548       !isStackImage5D && !isStackView5D && !isColorize; 
    549     if (!customColorizeEnabled) isCustomColorize = false; 
    550  
    551     // autoscaleBox 
    552     autoscaleEnabled = !isVirtual; 
    553     if (!autoscaleEnabled) isAutoscale = false; 
    554  
    555     // == Split into separate windows == 
    556  
    557     boolean splitEnabled = !isStackNone && !isStackBrowser && 
    558       !isStackVisBio && !isStackImage5D && !isStackView5D && !isVirtual; 
    559     // TODO: make splitting work with Data Browser & virtual stacks 
    560  
    561     // splitCBox 
    562     splitCEnabled = splitEnabled && !isMergeChannels; 
    563     if (!splitCEnabled) isSplitC = false; 
    564  
    565     // splitZBox 
    566     splitZEnabled = splitEnabled; 
    567     if (!splitZEnabled) isSplitZ = false; 
    568  
    569     // splitTBox 
    570     splitTEnabled = splitEnabled; 
    571     if (!splitTEnabled) isSplitT = false; 
    572  
    573     // update state of each option, in case anything changed 
    574  
    575     autoscaleBox.setEnabled(autoscaleEnabled); 
    576     colorizeBox.setEnabled(colorizeEnabled); 
    577     concatenateBox.setEnabled(concatenateEnabled); 
    578     cropBox.setEnabled(cropEnabled); 
    579     customColorizeBox.setEnabled(customColorizeEnabled); 
    580     groupFilesBox.setEnabled(groupFilesEnabled); 
    581     ungroupFilesBox.setEnabled(ungroupFilesEnabled); 
    582     mergeChannelsBox.setEnabled(mergeChannelsEnabled); 
    583     openAllSeriesBox.setEnabled(openAllSeriesEnabled); 
    584     recordBox.setEnabled(recordEnabled); 
    585     showMetadataBox.setEnabled(showMetadataEnabled); 
    586     showOMEXMLBox.setEnabled(showOMEXMLEnabled); 
    587     specifyRangesBox.setEnabled(specifyRangesEnabled); 
    588     splitZBox.setEnabled(splitZEnabled); 
    589     splitTBox.setEnabled(splitTEnabled); 
    590     splitCBox.setEnabled(splitCEnabled); 
    591     //stackFormatChoice.setEnabled(stackFormatEnabled); 
    592     stackOrderChoice.setEnabled(stackOrderEnabled); 
    593     swapDimsBox.setEnabled(swapDimsEnabled); 
    594     virtualBox.setEnabled(virtualEnabled); 
    595  
    596     autoscaleBox.setState(isAutoscale); 
    597     colorizeBox.setState(isColorize); 
    598     concatenateBox.setState(isConcatenate); 
    599     cropBox.setState(isCrop); 
    600     customColorizeBox.setState(isCustomColorize); 
    601     groupFilesBox.setState(isGroupFiles); 
    602     ungroupFilesBox.setState(isUngroupFiles); 
    603     mergeChannelsBox.setState(isMergeChannels); 
    604     openAllSeriesBox.setState(isOpenAllSeries); 
    605     recordBox.setState(isRecord); 
    606     showMetadataBox.setState(isShowMetadata); 
    607     showOMEXMLBox.setState(isShowOMEXML); 
    608     specifyRangesBox.setState(isSpecifyRanges); 
    609     splitZBox.setState(isSplitZ); 
    610     splitTBox.setState(isSplitT); 
    611     splitCBox.setState(isSplitC); 
    612     //stackFormatChoice.select(stackFormatValue); 
    613     stackOrderChoice.select(stackOrderValue); 
    614     swapDimsBox.setState(isSwap); 
    615     virtualBox.setState(isVirtual); 
    616  
    617     if (IS_GLITCHED) { 
    618       // HACK - work around a Mac OS X bug where GUI components do not update 
    619  
    620       // list of affected components 
    621       Component[] c = { 
    622         autoscaleBox, 
    623         colorizeBox, 
    624         concatenateBox, 
    625         cropBox, 
    626         customColorizeBox, 
    627         groupFilesBox, 
    628         ungroupFilesBox, 
    629         mergeChannelsBox, 
    630         openAllSeriesBox, 
    631         recordBox, 
    632         showMetadataBox, 
    633         showOMEXMLBox, 
    634         specifyRangesBox, 
    635         splitZBox, 
    636         splitTBox, 
    637         splitCBox, 
    638         stackFormatChoice, 
    639         stackOrderChoice, 
    640         swapDimsBox, 
    641         virtualBox 
    642       }; 
    643  
    644       // identify currently focused component 
    645       Component focused = null; 
    646       for (int i=0; i<c.length; i++) { 
    647         if (c[i].isFocusOwner()) focused = c[i]; 
    648       } 
    649  
    650       // temporarily disable focus events 
    651       for (int i=0; i<c.length; i++) c[i].removeFocusListener(this); 
    652  
    653       // cycle through focus on all components 
    654       for (int i=0; i<c.length; i++) c[i].requestFocusInWindow(); 
    655  
    656       // clear the focus globally 
    657       KeyboardFocusManager kfm = 
    658         KeyboardFocusManager.getCurrentKeyboardFocusManager(); 
    659       kfm.clearGlobalFocusOwner(); 
    660       sleep(100); // doesn't work if this value is too small 
    661  
    662       // refocus the originally focused component 
    663       if (focused != null) focused.requestFocusInWindow(); 
    664  
    665       // reenable focus events 
    666       for (int i=0; i<c.length; i++) c[i].addFocusListener(this); 
    667     } 
    668   } 
    669  
    67084} 
  • trunk/components/loci-plugins/src/loci/plugins/in/ImporterOptions.java

    r6246 r6247  
    3737import loci.formats.FormatException; 
    3838import loci.formats.meta.IMetadata; 
    39 import loci.plugins.BF; 
    40 import loci.plugins.prefs.OptionsDialog; 
    4139import loci.plugins.prefs.OptionsList; 
    4240import loci.plugins.prefs.StringOption; 
     
    4644/** 
    4745 * Helper class for managing Bio-Formats Importer options. 
    48  * Gets parameter values through a variety of means, including 
    49  * preferences from IJ_Prefs.txt, plugin argument string, macro options, 
    50  * and user input from dialog boxes. 
     46 * Gets default parameter values from IJ_Prefs.txt. 
    5147 * 
    5248 * <dl><dt><b>Source code:</b></dt> 
     
    9389  public static final String LOCATION_LOCAL = "Local machine"; 
    9490  public static final String LOCATION_HTTP  = "Internet"; 
    95   public static final String LOCATION_OME   = "OME server"; 
    96   public static final String LOCATION_OMERO = "OMERO server"; 
     91  //public static final String LOCATION_OMERO = "OMERO server"; 
    9792 
    9893  // possible values for stackFormat 
     
    119114  public static final String ORDER_XYTZC   = "XYTZC"; 
    120115 
     116  // -- Fields -- secondary values -- 
     117 
     118  // series options 
     119  private List<Boolean> seriesOn = new ArrayList<Boolean>(); 
     120 
     121  // TODO - swap options need to be programmatically settable 
     122 
     123  // range options 
     124  private List<Integer> cBegin = new ArrayList<Integer>(); 
     125  private List<Integer> cEnd = new ArrayList<Integer>(); 
     126  private List<Integer> cStep = new ArrayList<Integer>(); 
     127  private List<Integer> zBegin = new ArrayList<Integer>(); 
     128  private List<Integer> zEnd = new ArrayList<Integer>(); 
     129  private List<Integer> zStep = new ArrayList<Integer>(); 
     130  private List<Integer> tBegin = new ArrayList<Integer>(); 
     131  private List<Integer> tEnd = new ArrayList<Integer>(); 
     132  private List<Integer> tStep = new ArrayList<Integer>(); 
     133 
     134  // crop options 
     135  private List<Region> cropRegion = new ArrayList<Region>(); 
     136 
    121137  // -- Fields - derived values -- 
    122138 
    123   protected ImporterReader reader; 
    124   protected ImporterMetadata metadata; 
    125   protected int[] cCount, zCount, tCount; 
    126  
    127   // -- Fields -- secondary values -- 
    128  
    129   // series options 
    130   protected List<Boolean> seriesOn = new ArrayList<Boolean>(); 
    131  
    132   // TODO - swap options need to be programmatically settable 
    133  
    134   // range options 
    135   protected List<Integer> cBegin = new ArrayList<Integer>(); 
    136   protected List<Integer> cEnd = new ArrayList<Integer>(); 
    137   protected List<Integer> cStep = new ArrayList<Integer>(); 
    138   protected List<Integer> zBegin = new ArrayList<Integer>(); 
    139   protected List<Integer> zEnd = new ArrayList<Integer>(); 
    140   protected List<Integer> zStep = new ArrayList<Integer>(); 
    141   protected List<Integer> tBegin = new ArrayList<Integer>(); 
    142   protected List<Integer> tEnd = new ArrayList<Integer>(); 
    143   protected List<Integer> tStep = new ArrayList<Integer>(); 
    144  
    145   // crop options 
    146   protected List<Region> cropRegion = new ArrayList<Region>(); 
    147  
    148   // -- Fields - internal -- 
    149  
     139  private ImporterReader reader; 
     140  private ImporterMetadata metadata; 
     141 
     142  /** A descriptive label for each series. */ 
    150143  private String[] seriesLabels; 
    151144 
     
    154147  public ImporterOptions() throws IOException { 
    155148    super("importer-options.txt", ImporterOptions.class); 
     149 
    156150    // remove unavailable stack formats 
    157151    StringOption stackFormat = getStringOption(KEY_STACK_FORMAT); 
     
    196190      parseOptions(arg); 
    197191    } 
    198   } 
    199  
    200   /** 
    201    * Displays dialog boxes prompting for additional configuration details. 
    202    * 
    203    * Which dialogs are shown depends on a variety of factors, including the 
    204    * current configuration (i.e., which options are enabled), whether quiet or 
    205    * windowless mode is set, and whether the method is being called from within 
    206    * a macro. 
    207    * 
    208    * After calling this method, derived field values will also be populated. 
    209    * 
    210    * @return true if harvesting went OK, or false if something went wrong 
    211    *   (e.g., the user canceled a dialog box) 
    212    * 
    213    * @see ij.gui.GenericDialog 
    214    */ 
    215   public boolean showDialogs() throws FormatException, IOException { 
    216     reader = null; 
    217  
    218     if (!promptUpgrade()) return false; 
    219  
    220     if (!promptLocation()) return false; 
    221     if (!promptId()) return false; 
    222  
    223     reader = new ImporterReader(this); 
    224  
    225     if (!promptOptions()) return false; 
    226  
    227     // save options as new defaults 
    228     if (!isQuiet()) setFirstTime(false); 
    229     saveOptions(); 
    230  
    231     IJ.showStatus("Analyzing " + getIdName()); 
    232  
    233     reader.prepareStuff(); 
    234  
    235     if (!promptFilePattern()) return false; 
    236  
    237     reader.initializeReader(); 
    238  
    239     if (!promptSeries()) return false; 
    240     if (!promptSwap()) return false; 
    241     if (!promptRange()) return false; 
    242     if (!promptCrop()) return false; 
    243  
    244     initializeMetadata(); 
    245     computeRangeCounts(); 
    246  
    247     return true; 
    248192  } 
    249193 
     
    306250  public boolean isLocal() { return LOCATION_LOCAL.equals(getLocation()); } 
    307251  public boolean isHTTP() { return LOCATION_HTTP.equals(getLocation()); } 
    308   public boolean isOME() { return LOCATION_OME.equals(getLocation()); } 
    309   public boolean isOMERO() { return LOCATION_OMERO.equals(getLocation()); } 
     252  //public boolean isOMERO() { return LOCATION_OMERO.equals(getLocation()); } 
    310253  public void setLocation(String s) { setValue(KEY_LOCATION, s); } 
    311254 
     
    430373 
    431374  // series options 
    432   public boolean isSeriesOn(int s) { return get(seriesOn, s); } 
     375  public boolean isSeriesOn(int s) { 
     376    if (openAllSeries() || isViewNone()) return true; 
     377    return get(seriesOn, s, s == 0); 
     378  } 
    433379  public void setSeriesOn(int s, boolean value) { 
    434380    set(seriesOn, s, value, false); 
     
    438384 
    439385  // range options 
    440   public int getCBegin(int s) { return get(cBegin, s); } 
     386  public int getCBegin(int s) { return get(cBegin, s, 0); } 
    441387  public void setCBegin(int s, int value) { set(cBegin, s, value, 0); } 
    442   public int getCEnd(int s) { return get(cEnd, s); } 
     388  public int getCEnd(int s) { return get(cEnd, s, -1); } 
    443389  public void setCEnd(int s, int value) { set(cEnd, s, value, 0); } 
    444   public int getCStep(int s) { return get(cStep, s); } 
     390  public int getCStep(int s) { return get(cStep, s, 1); } 
    445391  public void setCStep(int s, int value) { set(cStep, s, value, 0); } 
    446392 
    447   public int getZBegin(int s) { return get(zBegin, s); } 
     393  public int getZBegin(int s) { return get(zBegin, s, 0); } 
    448394  public void setZBegin(int s, int value) { set(zBegin, s, value, 0); } 
    449   public int getZEnd(int s) { return get(zEnd, s); } 
     395  public int getZEnd(int s) { return get(zEnd, s, -1); } 
    450396  public void setZEnd(int s, int value) { set(zEnd, s, value, 0); } 
    451   public int getZStep(int s) { return get(zStep, s); } 
     397  public int getZStep(int s) { return get(zStep, s, 1); } 
    452398  public void setZStep(int s, int value) { set(zStep, s, value, 0); } 
    453399 
    454   public int getTBegin(int s) { return get(tBegin, s); } 
     400  public int getTBegin(int s) { return get(tBegin, s, 0); } 
    455401  public void setTBegin(int s, int value) { set(tBegin, s, value, 0); } 
    456   public int getTEnd(int s) { return get(tEnd, s); } 
     402  public int getTEnd(int s) { return get(tEnd, s, -1); } 
    457403  public void setTEnd(int s, int value) { set(tEnd, s, value, 0); } 
    458   public int getTStep(int s) { return get(tStep, s); } 
     404  public int getTStep(int s) { return get(tStep, s, 1); } 
    459405  public void setTStep(int s, int value) { set(tStep, s, value, 0); } 
    460406 
    461407  // crop options 
    462   public Region getCropRegion(int s) { return get(cropRegion, s); } 
     408  public Region getCropRegion(int s) { return get(cropRegion, s, null); } 
    463409  public void setCropRegion(int s, Region r) { set(cropRegion, s, r, null); } 
    464410 
     
    474420 
    475421  // series options 
    476   public int getCCount(int s) { return cCount[s]; } 
    477   public int getZCount(int s) { return zCount[s]; } 
    478   public int getTCount(int s) { return tCount[s]; } 
    479  
    480   // -- Helper methods - dialog prompts -- 
    481  
    482   private boolean promptUpgrade() { 
    483     UpgradeDialog dialog = new UpgradeDialog(this); 
    484     return dialog.showDialog() == OptionsDialog.STATUS_OK; 
    485   } 
    486  
    487   private boolean promptLocation() { 
    488     LocationDialog dialog = new LocationDialog(this); 
    489     return dialog.showDialog() == OptionsDialog.STATUS_OK; 
    490   } 
    491  
    492   private boolean promptId() { 
    493     IdDialog dialog = new IdDialog(this); 
    494     return dialog.showDialog() == OptionsDialog.STATUS_OK; 
    495   } 
    496  
    497   private boolean promptOptions() { 
    498     if (isWindowless()) return true; 
    499  
    500     ImporterDialog dialog = new ImporterDialog(this); 
    501     return dialog.showDialog() == OptionsDialog.STATUS_OK; 
    502   } 
    503  
    504   /** Prompts for the file pattern, if necessary. May override id value. */ 
    505   private boolean promptFilePattern() { 
    506     if (!isGroupFiles()) { 
    507       BF.debug("no need to prompt for file pattern"); 
    508       return true; 
    509     } 
    510     BF.debug("prompt for the file pattern"); 
    511  
    512     FilePatternDialog dialog = new FilePatternDialog(this); 
    513     if (dialog.showDialog() != OptionsDialog.STATUS_OK) return false; 
    514  
    515     String id = getId(); 
    516     if (id == null) id = reader.currentFile; 
    517     FilePattern fp = new FilePattern(id); 
    518     if (!fp.isValid()) id = reader.currentFile; 
    519     setId(id); // overwrite base filename with file pattern 
    520     return true; 
    521   } 
    522  
    523   /** Prompts for which series to import, if necessary. */ 
    524   private boolean promptSeries() { 
    525     // initialize series-related derived values 
    526     setSeriesOn(0, true); 
    527  
    528     // build descriptive label for each series 
     422  public int getCCount(int s) { 
     423    if (!isSeriesOn(s)) return 0; 
     424    if (isMergeChannels()) return 1; 
     425    return (getCEnd(s) - getCBegin(s) + getCStep(s)) / getCStep(s); 
     426  } 
     427  public int getZCount(int s) { 
     428    if (!isSeriesOn(s)) return 0; 
     429    return (getZEnd(s) - getZBegin(s) + getZStep(s)) / getZStep(s); 
     430  } 
     431  public int getTCount(int s) { 
     432    if (!isSeriesOn(s)) return 0; 
     433    return (getTEnd(s) - getTBegin(s) + getTStep(s)) / getTStep(s); 
     434  } 
     435 
     436  public String getSeriesLabel(int s) { 
     437    if (seriesLabels == null) computeSeriesLabels(); 
     438    return seriesLabels[s]; 
     439  } 
     440 
     441  // -- Helper methods - derived value computation -- 
     442 
     443  /** Initializes the ImporterMetadata derived value. */ 
     444  protected void initializeMetadata() { 
     445    // only prepend a series name prefix to the metadata keys if multiple 
     446    // series are being opened 
     447    int seriesCount = getSeriesCount(); 
     448    int numEnabled = 0; 
     449    for (int s=0; s<seriesCount; s++) { 
     450      if (isSeriesOn(s)) numEnabled++; 
     451    } 
     452    metadata = new ImporterMetadata(reader.r, this, numEnabled > 1); 
     453  } 
     454 
     455  /** Initializes the seriesLabels derived value. */ 
     456  private void computeSeriesLabels() { 
    529457    int seriesCount = getSeriesCount(); 
    530458    seriesLabels = new String[seriesCount]; 
     
    574502      //seriesLabels[i] = seriesLabels[i].replaceAll(" ", "_"); 
    575503    } 
    576  
    577     if (seriesCount > 1 && !openAllSeries() && !isViewNone()) { 
    578       BF.debug("prompt for which series to import"); 
    579       SeriesDialog dialog = new SeriesDialog(this, 
    580         reader.r, seriesLabels); 
    581       if (dialog.showDialog() != OptionsDialog.STATUS_OK) return false; 
    582     } 
    583     else BF.debug("no need to prompt for series"); 
    584  
    585     if (openAllSeries() || isViewNone()) { 
    586       for (int s=0; s<getSeriesCount(); s++) setSeriesOn(s, true); 
    587     } 
    588     return true; 
    589   } 
    590  
    591   /** Prompts for dimension swapping parameters, if necessary. */ 
    592   private boolean promptSwap() { 
    593     if (!isSwapDimensions()) { 
    594       BF.debug("no need to prompt for dimension swapping"); 
    595       return true; 
    596     } 
    597     BF.debug("prompt for dimension swapping parameters"); 
    598  
    599     SwapDialog dialog = new SwapDialog(this, reader.virtualReader); 
    600     return dialog.showDialog() == OptionsDialog.STATUS_OK; 
    601   } 
    602  
    603   /** Prompts for the range of planes to import, if necessary. */ 
    604   private boolean promptRange() { 
    605     // initialize range-related secondary values 
    606     int seriesCount = getSeriesCount(); 
    607  
    608     for (int s=0; s<seriesCount; s++) { 
    609       reader.r.setSeries(s); 
    610       setCBegin(s, 0); 
    611       setZBegin(s, 0); 
    612       setTBegin(s, 0); 
    613       setCEnd(s, reader.r.getEffectiveSizeC() - 1); 
    614       setZEnd(s, reader.r.getSizeZ() - 1); 
    615       setTEnd(s, reader.r.getSizeT() - 1); 
    616       setCStep(s, 1); 
    617       setZStep(s, 1); 
    618       setTStep(s, 1); 
    619     } 
    620  
    621     if (!isSpecifyRanges()) { 
    622       BF.debug("open all planes"); 
    623       return true; 
    624     } 
    625     boolean needRange = false; 
    626     for (int s=0; s<seriesCount; s++) { 
    627       if (isSeriesOn(s) && reader.r.getImageCount() > 1) needRange = true; 
    628     } 
    629     if (!needRange) { 
    630       BF.debug("no need to prompt for planar ranges"); 
    631       return true; 
    632     } 
    633     BF.debug("prompt for planar ranges"); 
    634     IJ.showStatus(""); 
    635  
    636     RangeDialog dialog = new RangeDialog(this, reader.r, seriesLabels); 
    637     return dialog.showDialog() == OptionsDialog.STATUS_OK; 
    638   } 
    639  
    640   /** Prompts for cropping details, if necessary. */ 
    641   private boolean promptCrop() { 
    642     // initialize crop-related secondary values 
    643     int seriesCount = getSeriesCount(); 
    644     for (int s=0; s<seriesCount; s++) { 
    645       setCropRegion(s, new Region()); 
    646     } 
    647  
    648     if (!doCrop()) { 
    649       BF.debug("no need to prompt for cropping region"); 
    650       return true; 
    651     } 
    652     BF.debug("prompt for cropping region"); 
    653  
    654     CropDialog dialog = new CropDialog(this, reader.r, seriesLabels); 
    655     return dialog.showDialog() == OptionsDialog.STATUS_OK; 
    656   } 
    657  
    658   // -- Helper methods - derived value computation -- 
    659  
    660   /** Initializes the ImporterMetadata derived value. */ 
    661   private void initializeMetadata() { 
    662     // only prepend a series name prefix to the metadata keys if multiple 
    663     // series are being opened 
    664     int seriesCount = getSeriesCount(); 
    665     int numEnabled = 0; 
    666     for (int s=0; s<seriesCount; s++) { 
    667       if (isSeriesOn(s)) numEnabled++; 
    668     } 
    669     metadata = new ImporterMetadata(reader.r, this, numEnabled > 1); 
    670   } 
    671  
    672   /** Initializes the cCount, zCount and tCount derived values. */ 
    673   private void computeRangeCounts() { 
    674     int seriesCount = getSeriesCount(); 
    675     cCount = new int[seriesCount]; 
    676     zCount = new int[seriesCount]; 
    677     tCount = new int[seriesCount]; 
    678     for (int s=0; s<seriesCount; s++) { 
    679       if (!isSeriesOn(s)) cCount[s] = zCount[s] = tCount[s] = 0; 
    680       else { 
    681         if (isMergeChannels()) cCount[s] = 1; 
    682         else { 
    683           cCount[s] = (getCEnd(s) - getCBegin(s) + getCStep(s)) / getCStep(s); 
    684         } 
    685         zCount[s] = (getZEnd(s) - getZBegin(s) + getZStep(s)) / getZStep(s); 
    686         tCount[s] = (getTEnd(s) - getTBegin(s) + getTStep(s)) / getTStep(s); 
    687       } 
    688     } 
    689   } 
    690    
     504  } 
     505 
    691506  // -- Helper methods - miscellaneous -- 
    692    
     507 
    693508  private <T extends Object> void set(List<T> list, 
    694     int index, T value, T defaultValue) 
     509    int index, T value, T fillValue) 
    695510  { 
    696     while (list.size() <= index) list.add(defaultValue); 
     511    while (list.size() <= index) list.add(fillValue); 
    697512    list.set(index, value); 
    698513  } 
    699514 
    700   private <T extends Object> T get(List<T> list, int index) { 
    701     if (list.size() <= index) return null; 
     515  private <T extends Object> T get(List<T> list, int index, T defaultValue) { 
     516    if (list.size() <= index) return defaultValue; 
    702517    return list.get(index); 
    703518  } 
    704519 
     520  // -- CTR TEMP - methods to munge around with state -- 
     521 
     522  public void createReader() { 
     523    reader = new ImporterReader(this); 
     524  } 
     525 
     526  public void saveDefaults() { 
     527    // save options as new defaults 
     528    if (!isQuiet()) setFirstTime(false); 
     529    saveOptions(); 
     530  } 
     531 
     532  public void prepareStuff() throws FormatException, IOException { 
     533    IJ.showStatus("Analyzing " + getIdName()); 
     534    reader.prepareStuff(); 
     535  } 
     536 
     537  public void initializeReader() throws FormatException, IOException { 
     538    if (isGroupFiles()) { 
     539      // overwrite base filename with file pattern 
     540      String id = getId(); 
     541      if (id == null) id = reader.currentFile; 
     542      FilePattern fp = new FilePattern(id); 
     543      if (!fp.isValid()) id = reader.currentFile; 
     544      setId(id); 
     545    } 
     546    reader.initializeReader(); 
     547  } 
     548 
    705549} 
  • trunk/components/loci-plugins/src/loci/plugins/in/ImporterReader.java

    r6229 r6247  
    2929 
    3030import java.io.IOException; 
    31 import java.util.StringTokenizer; 
    3231 
    3332import loci.common.Location; 
     
    4241import loci.formats.ImageReader; 
    4342import loci.formats.meta.IMetadata; 
    44 import loci.formats.services.OMEReaderWriterService; 
    4543import loci.formats.services.OMEXMLService; 
    4644import loci.plugins.util.IJStatusEchoer; 
     
    133131      idName = idLoc.getName(); 
    134132    } 
    135     else if (options.isOME() || options.isOMERO()) { 
    136       // NB: strip out username and password when opening from OME/OMERO 
    137       StringTokenizer st = new StringTokenizer(id, "?&"); 
    138       StringBuffer idBuf = new StringBuffer(); 
    139       int tokenCount = 0; 
    140       while (st.hasMoreTokens()) { 
    141         String token = st.nextToken(); 
    142         if (token.startsWith("username=") || token.startsWith("password=")) { 
    143           continue; 
    144         } 
    145         if (tokenCount == 1) idBuf.append("?"); 
    146         else if (tokenCount > 1) idBuf.append("&"); 
    147         idBuf.append(token); 
    148         tokenCount++; 
    149       } 
    150       idName = idBuf.toString(); 
    151     } 
     133//    else if (options.isOMERO()) { 
     134//      // NB: strip out username and password when opening from OMERO 
     135//      StringTokenizer st = new StringTokenizer(id, "?&"); 
     136//      StringBuffer idBuf = new StringBuffer(); 
     137//      int tokenCount = 0; 
     138//      while (st.hasMoreTokens()) { 
     139//        String token = st.nextToken(); 
     140//        if (token.startsWith("username=") || token.startsWith("password=")) { 
     141//          continue; 
     142//        } 
     143//        if (tokenCount == 1) idBuf.append("?"); 
     144//        else if (tokenCount > 1) idBuf.append("&"); 
     145//        idBuf.append(token); 
     146//        tokenCount++; 
     147//      } 
     148//      idName = idBuf.toString(); 
     149//    } 
    152150  } 
    153151 
     
    172170      } 
    173171    } 
    174     else if (options.isOMERO()) { 
    175       // NB: avoid dependencies on optional loci.ome.io package 
    176       try { 
    177         ServiceFactory factory = new ServiceFactory(); 
    178         OMEReaderWriterService service = 
    179           factory.getInstance(OMEReaderWriterService.class); 
    180         baseReader = service.newOMEROReader(); 
    181       } 
    182       catch (DependencyException exc) { 
    183         WindowTools.reportException(exc, options.isQuiet(), 
    184           "Sorry, there was a problem constructing the OMERO I/O engine"); 
    185       } 
    186       if (baseReader == null) return; 
    187     } 
    188     else if (options.isOME()) { 
    189       // NB: avoid dependencies on optional loci.ome.io package 
    190       try { 
    191         ServiceFactory factory = new ServiceFactory(); 
    192         OMEReaderWriterService service = 
    193           factory.getInstance(OMEReaderWriterService.class); 
    194         baseReader = service.newOMEReader(); 
    195       } 
    196       catch (DependencyException de) { 
    197         WindowTools.reportException(de, options.isQuiet(), 
    198           "Sorry, there was a problem constructing the OME I/O engine"); 
    199       } 
    200       if (baseReader == null) return; 
    201     } 
     172//    else if (options.isOMERO()) { 
     173//      // NB: avoid dependencies on optional loci.ome.io package 
     174//      try { 
     175//        ServiceFactory factory = new ServiceFactory(); 
     176//        OMEReaderWriterService service = 
     177//          factory.getInstance(OMEReaderWriterService.class); 
     178//        baseReader = service.newOMEROReader(); 
     179//      } 
     180//      catch (DependencyException exc) { 
     181//        WindowTools.reportException(exc, options.isQuiet(), 
     182//          "Sorry, there was a problem constructing the OMERO I/O engine"); 
     183//      } 
     184//      if (baseReader == null) return; 
     185//    } 
    202186    else { 
    203187      WindowTools.reportException(null, options.isQuiet(), 
  • trunk/components/loci-plugins/src/loci/plugins/in/LocationDialog.java

    r6229 r6247  
    2727 
    2828import ij.gui.GenericDialog; 
    29 import loci.plugins.prefs.OptionsDialog; 
    3029 
    3130/** 
     
    3635 * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/loci-plugins/src/loci/plugins/in/LocationDialog.java">SVN</a></dd></dl> 
    3736 */ 
    38 public class LocationDialog extends OptionsDialog { 
    39  
    40   // -- Fields -- 
    41  
    42   /** LOCI plugins configuration. */ 
    43   protected ImporterOptions options; 
     37public class LocationDialog extends ImporterDialog { 
    4438 
    4539  // -- Constructor -- 
     
    4842  public LocationDialog(ImporterOptions options) { 
    4943    super(options); 
    50     this.options = options; 
    5144  } 
    52  
    53   // -- OptionsDialog methods -- 
    54  
    55   /** 
    56    * Gets the location (type of data source) from macro options, 
    57    * or user prompt if necessary. 
    58    * 
    59    * @return status of operation 
    60    */ 
    61   public int showDialog() { 
    62     if (options.getLocation() == null) { 
    63       // Open a dialog asking the user what kind of dataset to handle. 
    64       // Ask only if the location was not already specified somehow. 
    65       // ImageJ will grab the value from the macro options, when possible. 
    66       GenericDialog gd = new GenericDialog("Bio-Formats Dataset Location"); 
    67       addChoice(gd, ImporterOptions.KEY_LOCATION); 
    68       gd.showDialog(); 
    69       if (gd.wasCanceled()) return STATUS_CANCELED; 
    70       options.setLocation(gd.getNextChoice()); 
    71     } 
    72     return STATUS_OK; 
     45   
     46  // -- ImporterDialog methods -- 
     47   
     48  @Override 
     49  protected boolean needPrompt() { 
     50    // NB: Prompt only if location wasn't already specified. 
     51    return !options.isWindowless() && options.getLocation() == null; 
     52  } 
     53   
     54  @Override 
     55  protected GenericDialog constructDialog() { 
     56    GenericDialog gd = new GenericDialog("Bio-Formats Dataset Location"); 
     57    addChoice(gd, ImporterOptions.KEY_LOCATION); 
     58    return gd; 
     59  } 
     60   
     61  @Override 
     62  protected void harvestResults(GenericDialog gd) { 
     63    String location = gd.getNextChoice(); 
     64    options.setLocation(location); 
    7365  } 
    7466 
  • trunk/components/loci-plugins/src/loci/plugins/in/MainDialog.java

    r6229 r6247  
    4646import javax.swing.JScrollPane; 
    4747 
    48 import loci.plugins.prefs.OptionsDialog; 
    4948import loci.plugins.util.WindowTools; 
    5049 
     
    5756 * 
    5857 * <dl><dt><b>Source code:</b></dt> 
    59  * <dd><a href="https://skyking.microscopy.wisc.edu/trac/java/browser/trunk/components/loci-plugins/src/loci/plugins/in/ImporterDialog.java">Trac</a>, 
    60  * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/loci-plugins/src/loci/plugins/in/ImporterDialog.java">SVN</a></dd></dl> 
     58 * <dd><a href="https://skyking.microscopy.wisc.edu/trac/java/browser/trunk/components/loci-plugins/src/loci/plugins/in/MainDialog.java">Trac</a>, 
     59 * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/loci-plugins/src/loci/plugins/in/MainDialog.java">SVN</a></dd></dl> 
    6160 */ 
    62 public class ImporterDialog extends OptionsDialog 
     61public class MainDialog extends ImporterDialog 
    6362  implements FocusListener, ItemListener, MouseListener 
    6463{ 
     
    104103 
    105104  /** Creates a general options dialog for the Bio-Formats Importer. */ 
    106   public ImporterDialog(ImporterOptions options) { 
     105  public MainDialog(ImporterOptions options) { 
    107106    super(options); 
    108107    this.options = options; 
    109108  } 
    110  
    111   // -- OptionsDialog methods -- 
    112  
    113   /** 
    114    * Gets importer settings from macro options, or user prompt if necessary. 
    115    * 
    116    * @return status of operation 
    117    */ 
    118   public int showDialog() { 
    119     // prompt user for parameters (or grab from macro options) 
     109   
     110  // -- ImporterDialog methods -- 
     111 
     112  @Override 
     113  protected boolean needPrompt() { 
     114    return !options.isWindowless(); 
     115  } 
     116   
     117  @Override 
     118  protected GenericDialog constructDialog() { 
    120119    GenericDialog gd = new GenericDialog("Bio-Formats Import Options"); 
    121120    addCheckbox(gd, ImporterOptions.KEY_AUTOSCALE); 
     
    141140    addCheckbox(gd, ImporterOptions.KEY_SWAP_DIMS); 
    142141    addCheckbox(gd, ImporterOptions.KEY_VIRTUAL); 
    143  
     142    rebuildDialog(gd); 
     143    return gd; 
     144  } 
     145   
     146  @Override 
     147  protected void harvestResults(GenericDialog gd) { 
     148    options.setAutoscale(gd.getNextBoolean()); 
     149    options.setColorize(gd.getNextBoolean()); 
     150    options.setConcatenate(gd.getNextBoolean()); 
     151    options.setCrop(gd.getNextBoolean()); 
     152    options.setCustomColorize(gd.getNextBoolean()); 
     153    options.setGroupFiles(gd.getNextBoolean()); 
     154    options.setUngroupFiles(gd.getNextBoolean()); 
     155    options.setMergeChannels(gd.getNextBoolean()); 
     156    options.setOpenAllSeries(gd.getNextBoolean()); 
     157    options.setQuiet(gd.getNextBoolean()); // NB: invisible 
     158    options.setRecord(gd.getNextBoolean()); 
     159    options.setShowMetadata(gd.getNextBoolean()); 
     160    options.setShowOMEXML(gd.getNextBoolean()); 
     161    options.setShowROIs(gd.getNextBoolean()); 
     162    options.setSpecifyRanges(gd.getNextBoolean()); 
     163    options.setSplitFocalPlanes(gd.getNextBoolean()); 
     164    options.setSplitTimepoints(gd.getNextBoolean()); 
     165    options.setSplitChannels(gd.getNextBoolean()); 
     166    options.setStackFormat(options.getStackFormats()[gd.getNextChoiceIndex()]); 
     167    options.setStackOrder(options.getStackOrders()[gd.getNextChoiceIndex()]); 
     168    options.setSwapDimensions(gd.getNextBoolean()); 
     169    options.setVirtual(gd.getNextBoolean()); 
     170  } 
     171   
     172  // -- FocusListener methods -- 
     173 
     174  /** Handles information pane updates when component focus changes. */ 
     175  public void focusGained(FocusEvent e) { 
     176    Object src = e.getSource(); 
     177    String text = infoTable.get(src); 
     178    infoPane.setText("<html>" + text); 
     179    infoPane.setCaretPosition(0); 
     180  } 
     181 
     182  public void focusLost(FocusEvent e) { } 
     183 
     184  // -- ItemListener methods -- 
     185 
     186  /** Handles toggling of mutually exclusive options. */ 
     187  public void itemStateChanged(ItemEvent e) { 
     188    verifyOptions(e.getSource()); 
     189  } 
     190 
     191  // -- MouseListener methods -- 
     192 
     193  /** Focuses the component upon mouseover. */ 
     194  public void mouseEntered(MouseEvent e) { 
     195    Object src = e.getSource(); 
     196    if (src instanceof Component) { 
     197      ((Component) src).requestFocusInWindow(); 
     198    } 
     199  } 
     200 
     201  public void mouseClicked(MouseEvent e) { } 
     202  public void mouseExited(MouseEvent e) { } 
     203  public void mousePressed(MouseEvent e) { } 
     204  public void mouseReleased(MouseEvent e) { } 
     205 
     206  // -- Helper methods -- 
     207 
     208  /** Fancies up the importer dialog to look much nicer. */ 
     209  private void rebuildDialog(GenericDialog gd) { 
    144210    // extract GUI components from dialog and add listeners 
    145211    Vector<Checkbox> boxes = null; 
     
    327393    gd.add(builder.getPanel()); 
    328394 
    329     // display dialog to user and harvest results 
    330395    WindowTools.addScrollBars(gd); 
    331396    gd.setBackground(Color.white); // HACK: workaround for JPanel in a Dialog 
    332     gd.showDialog(); 
    333     if (gd.wasCanceled()) return STATUS_CANCELED; 
    334     options.setAutoscale(gd.getNextBoolean()); 
    335     options.setColorize(gd.getNextBoolean()); 
    336     options.setConcatenate(gd.getNextBoolean()); 
    337     options.setCrop(gd.getNextBoolean()); 
    338     options.setCustomColorize(gd.getNextBoolean()); 
    339     options.setGroupFiles(gd.getNextBoolean()); 
    340     options.setUngroupFiles(gd.getNextBoolean()); 
    341     options.setMergeChannels(gd.getNextBoolean()); 
    342     options.setOpenAllSeries(gd.getNextBoolean()); 
    343     options.setQuiet(gd.getNextBoolean()); // NB: invisible 
    344     options.setRecord(gd.getNextBoolean()); 
    345     options.setShowMetadata(gd.getNextBoolean()); 
    346     options.setShowOMEXML(gd.getNextBoolean()); 
    347     options.setShowROIs(gd.getNextBoolean()); 
    348     options.setSpecifyRanges(gd.getNextBoolean()); 
    349     options.setSplitFocalPlanes(gd.getNextBoolean()); 
    350     options.setSplitTimepoints(gd.getNextBoolean()); 
    351     options.setSplitChannels(gd.getNextBoolean()); 
    352     options.setStackFormat(options.getStackFormats()[gd.getNextChoiceIndex()]); 
    353     options.setStackOrder(options.getStackOrders()[gd.getNextChoiceIndex()]); 
    354     options.setSwapDimensions(gd.getNextBoolean()); 
    355     options.setVirtual(gd.getNextBoolean()); 
    356  
    357     return STATUS_OK; 
    358   } 
    359  
    360   // -- FocusListener methods -- 
    361  
    362   /** Handles information pane updates when component focus changes. */ 
    363   public void focusGained(FocusEvent e) { 
    364     Object src = e.getSource(); 
    365     String text = infoTable.get(src); 
    366     infoPane.setText("<html>" + text); 
    367     infoPane.setCaretPosition(0); 
    368   } 
    369  
    370   public void focusLost(FocusEvent e) { } 
    371  
    372   // -- ItemListener methods -- 
    373  
    374   /** Handles toggling of mutually exclusive options. */ 
    375   public void itemStateChanged(ItemEvent e) { 
    376     verifyOptions(e.getSource()); 
    377   } 
    378  
    379   // -- MouseListener methods -- 
    380  
    381   /** Focuses the component upon mouseover. */ 
    382   public void mouseEntered(MouseEvent e) { 
    383     Object src = e.getSource(); 
    384     if (src instanceof Component) { 
    385       ((Component) src).requestFocusInWindow(); 
    386     } 
    387   } 
    388  
    389   public void mouseClicked(MouseEvent e) { } 
    390   public void mouseExited(MouseEvent e) { } 
    391   public void mousePressed(MouseEvent e) { } 
    392   public void mouseReleased(MouseEvent e) { } 
    393  
    394   // -- Helper methods -- 
     397  } 
    395398 
    396399  /** 
     
    498501 
    499502    // groupFilesBox 
    500     groupFilesEnabled = !options.isOME() && !options.isOMERO(); 
    501     if (!groupFilesEnabled) isGroupFiles = false; 
    502     else if (src == stackFormatChoice && isStackBrowser) isGroupFiles = true; 
     503    //groupFilesEnabled = !options.isOMERO(); 
     504    //if (!groupFilesEnabled) isGroupFiles = false; 
     505    //else 
     506    if (src == stackFormatChoice && isStackBrowser) isGroupFiles = true; 
    503507 
    504508    // ungroupFilesBox 
  • trunk/components/loci-plugins/src/loci/plugins/in/RangeDialog.java

    r6246 r6247  
    2828import ij.gui.GenericDialog; 
    2929import loci.formats.IFormatReader; 
    30 import loci.plugins.prefs.OptionsDialog; 
    3130import loci.plugins.util.WindowTools; 
    3231 
     
    3837 * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/loci-plugins/src/loci/plugins/in/RangeDialog.java">SVN</a></dd></dl> 
    3938 */ 
    40 public class RangeDialog extends OptionsDialog { 
    41  
    42   // -- Fields -- 
    43  
    44   /** LOCI plugins configuration. */ 
    45   protected ImporterOptions options; 
    46  
    47   protected IFormatReader r; 
    48   protected String[] seriesLabels; 
     39public class RangeDialog extends ImporterDialog { 
    4940 
    5041  // -- Constructor -- 
     
    5344   * Creates a range chooser dialog for the Bio-Formats Importer. 
    5445   * 
    55    * @param r The reader to use for extracting details of each series. 
    56    * @param seriesLabels Label to display to user identifying each series 
     46   * @param dimSwap The reader to use for extracting details of each series. 
    5747   */ 
    58   public RangeDialog(ImporterOptions options, 
    59     IFormatReader r, String[] seriesLabels) 
    60   { 
     48  public RangeDialog(ImporterOptions options) { 
    6149    super(options); 
    62     this.options = options; 
    63     this.r = r; 
    64     this.seriesLabels = seriesLabels; 
    6550  } 
     51   
     52  // -- ImporterDialog methods -- 
    6653 
    67   // -- OptionsDialog methods -- 
     54  protected boolean needPrompt() { 
     55    if (options.isWindowless() || !options.isSpecifyRanges()) return false; 
     56     
     57    int seriesCount = options.getSeriesCount(); 
     58    IFormatReader r = options.getReader(); 
    6859 
    69   /** 
    70    * Gets the range of image planes to open from macro options, 
    71    * or user prompt if necessary. 
    72    * 
    73    * @return status of operation 
    74    */ 
    75   public int showDialog() { 
    76     int seriesCount = r.getSeriesCount(); 
     60    boolean needRange = false; 
     61    for (int s=0; s<seriesCount; s++) { 
     62      if (options.isSeriesOn(s) && r.getImageCount() > 1) { 
     63        needRange = true; 
     64        break; 
     65      } 
     66    } 
     67    return needRange; 
     68  } 
     69   
     70  protected GenericDialog constructDialog() { 
     71    int seriesCount = options.getSeriesCount(); 
     72    IFormatReader r = options.getReader(); 
    7773 
    78     // prompt user to specify series ranges (or grab from macro options) 
     74    // -- CTR TODO - refactor range-related options into RangeOptions class 
     75    // has a normalize(IFormatReader) method 
     76    // call both before and after the dialog here... 
     77 
     78    for (int s=0; s<seriesCount; s++) { 
     79      r.setSeries(s); 
     80      options.setCBegin(s, 0); 
     81      options.setZBegin(s, 0); 
     82      options.setTBegin(s, 0); 
     83      options.setCEnd(s, r.getEffectiveSizeC() - 1); 
     84      options.setZEnd(s, r.getSizeZ() - 1); 
     85      options.setTEnd(s, r.getSizeT() - 1); 
     86      options.setCStep(s, 1); 
     87      options.setZStep(s, 1); 
     88      options.setTStep(s, 1); 
     89    } 
     90 
     91    // construct dialog 
    7992    GenericDialog gd = new GenericDialog("Bio-Formats Range Options"); 
    8093    for (int s=0; s<seriesCount; s++) { 
    8194      if (!options.isSeriesOn(s)) continue; 
    8295      r.setSeries(s); 
    83       gd.addMessage(seriesLabels[s].replaceAll("_", " ")); 
     96      gd.addMessage(options.getSeriesLabel(s).replaceAll("_", " ")); 
    8497      String suffix = seriesCount > 1 ? "_" + (s + 1) : ""; 
    8598      //if (r.isOrderCertain()) { 
     
    107120    } 
    108121    WindowTools.addScrollBars(gd); 
    109     gd.showDialog(); 
    110     if (gd.wasCanceled()) return STATUS_CANCELED; 
     122 
     123    return gd; 
     124  } 
     125   
     126  protected void harvestResults(GenericDialog gd) { 
     127    int seriesCount = options.getSeriesCount(); 
     128    IFormatReader r = options.getReader(); 
    111129 
    112130    for (int s=0; s<seriesCount; s++) { 
     
    117135      int sizeT = r.getSizeT(); 
    118136      boolean certain = r.isOrderCertain(); 
    119        
     137 
    120138      int cBegin = options.getCBegin(s); 
    121139      int cEnd = options.getCEnd(s); 
     
    166184      if (tEnd >= sizeT) tEnd = sizeT - 1; 
    167185      if (tStep < 1) tStep = 1; 
    168        
     186 
    169187      options.setCBegin(s, cBegin); 
    170188      options.setCEnd(s, cEnd); 
     
    177195      options.setTStep(s, tStep); 
    178196    } 
    179  
    180     return STATUS_OK; 
    181197  } 
    182  
     198   
    183199} 
  • trunk/components/loci-plugins/src/loci/plugins/in/SeriesDialog.java

    r6246 r6247  
    5151import loci.formats.gui.AWTImageTools; 
    5252import loci.formats.gui.BufferedImageReader; 
    53 import loci.plugins.prefs.OptionsDialog; 
    5453import loci.plugins.util.WindowTools; 
    5554 
     
    6160 * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/loci-plugins/src/loci/plugins/in/SeriesDialog.java">SVN</a></dd></dl> 
    6261 */ 
    63 public class SeriesDialog extends OptionsDialog implements ActionListener { 
     62public class SeriesDialog extends ImporterDialog implements ActionListener { 
    6463 
    6564  // -- Constants -- 
     
    6968  // -- Fields -- 
    7069 
    71   /** LOCI plugins configuration. */ 
    72   protected ImporterOptions options; 
    73  
    74   protected BufferedImageReader r; 
    75   protected String[] seriesLabels; 
    76  
    77   protected Checkbox[] boxes; 
     70  private BufferedImageReader thumbReader; 
     71  private Panel[] p; 
     72  private Checkbox[] boxes; 
    7873 
    7974  // -- Constructor -- 
     
    8378   * 
    8479   * @param r The reader to use for extracting details of each series. 
    85    * @param seriesLabels Label to display to user identifying each series. 
    8680   * @param series Boolean array indicating which series to include 
    8781   *   (populated by this method). 
    8882   */ 
    89   public SeriesDialog(ImporterOptions options, 
    90     IFormatReader r, String[] seriesLabels) 
    91   { 
     83  public SeriesDialog(ImporterOptions options) { 
    9284    super(options); 
    93     this.options = options; 
    94     this.r = r instanceof BufferedImageReader ? 
    95       (BufferedImageReader) r : new BufferedImageReader(r); 
    96     this.seriesLabels = seriesLabels; 
    97   } 
    98  
    99   // -- OptionsDialog methods -- 
    100  
    101   /** 
    102    * Gets which image series to open from macro options, 
    103    * or user prompt if necessary. 
    104    * 
    105    * @return status of operation 
    106    */ 
    107   public int showDialog() { 
     85  } 
     86   
     87  // -- ImporterDialog methods -- 
     88   
     89  @Override 
     90  protected boolean needPrompt() { 
     91    // CTR TODO - eliminate weird handling of series string here 
    10892    String seriesString = options.getSeries(); 
    109  
    11093    if (options.isWindowless()) { 
    11194      if (seriesString != null) { 
     
    127110      } 
    128111      options.setSeries(seriesString); 
    129       return STATUS_OK; 
    130     } 
    131     int seriesCount = r.getSeriesCount(); 
    132  
    133     // prompt user to specify series inclusion (or grab from macro options) 
     112      return false; 
     113    } 
     114 
     115    return options.getSeriesCount() > 1 && 
     116      !options.openAllSeries() && !options.isViewNone(); 
     117  } 
     118   
     119  @Override 
     120  protected GenericDialog constructDialog() { 
     121    // -- CTR TODO - refactor series-related options into SeriesOptions class 
     122    // has a normalize(IFormatReader) method 
     123    // call both before and after the dialog here... 
     124 
    134125    GenericDialog gd = new GenericDialog("Bio-Formats Series Options"); 
    135126 
    136     GridBagLayout gdl = (GridBagLayout) gd.getLayout(); 
    137     GridBagConstraints gbc = new GridBagConstraints(); 
    138     gbc.gridx = 2; 
    139  
    140127    // set up the thumbnail panels 
    141  
    142     Panel[] p = new Panel[seriesCount]; 
     128    thumbReader = new BufferedImageReader(options.getReader()); 
     129    int seriesCount = thumbReader.getSeriesCount(); 
     130    p = new Panel[seriesCount]; 
    143131    for (int i=0; i<seriesCount; i++) { 
    144       r.setSeries(i); 
    145       int sx = r.getThumbSizeX() + 10; // a little extra padding 
    146       int sy = r.getThumbSizeY(); 
     132      thumbReader.setSeries(i); 
     133      int sx = thumbReader.getThumbSizeX() + 10; // a little extra padding 
     134      int sy = thumbReader.getThumbSizeY(); 
    147135      p[i] = new Panel(); 
    148136      p[i].add(Box.createRigidArea(new Dimension(sx, sy))); 
    149137      if (options.isForceThumbnails()) { 
    150138        IJ.showStatus("Reading thumbnail for series #" + (i + 1)); 
    151         int z = r.getSizeZ() / 2; 
    152         int t = r.getSizeT() / 2; 
    153         int ndx = r.getIndex(z, 0, t); 
     139        int z = thumbReader.getSizeZ() / 2; 
     140        int t = thumbReader.getSizeT() / 2; 
     141        int ndx = thumbReader.getIndex(z, 0, t); 
    154142        try { 
    155           BufferedImage img = r.openThumbImage(ndx); 
    156           if (options.isAutoscale() && r.getPixelType() != FormatTools.FLOAT) { 
     143          BufferedImage img = thumbReader.openThumbImage(ndx); 
     144          boolean isFloat = thumbReader.getPixelType() != FormatTools.FLOAT; 
     145          if (options.isAutoscale() && isFloat) { 
    157146            img = AWTImageTools.autoscale(img); 
    158147          } 
     
    181170      boolean[] defaultValues = new boolean[nRows]; 
    182171      for (int row=0; row<nRows; row++) { 
    183         labels[row] = seriesLabels[nextSeries]; 
     172        labels[row] = options.getSeriesLabel(nextSeries); 
    184173        defaultValues[row] = options.isSeriesOn(nextSeries++); 
    185174      } 
     
    192181    // checkboxes line up correctly 
    193182 
     183    rebuildDialog(gd, nPanels); 
     184 
     185    return gd; 
     186  } 
     187   
     188  @Override 
     189  protected boolean displayDialog(GenericDialog gd) { 
     190    ThumbLoader loader = null; 
     191    if (!options.isForceThumbnails()) { 
     192      // spawn background thumbnail loader 
     193      loader = new ThumbLoader(thumbReader, p, gd, options.isAutoscale()); 
     194    } 
     195    gd.showDialog(); 
     196    if (loader != null) loader.stop(); 
     197    return !gd.wasCanceled(); 
     198  } 
     199   
     200  @Override 
     201  protected void harvestResults(GenericDialog gd) { 
     202    String seriesString = "["; 
     203    int seriesCount = options.getSeriesCount(); 
     204    for (int i=0; i<seriesCount; i++) { 
     205      boolean on = gd.getNextBoolean(); 
     206      options.setSeriesOn(i, on); 
     207      if (on) seriesString += i + " "; 
     208    } 
     209    seriesString += "]"; 
     210    options.setSeries(seriesString); 
     211  } 
     212 
     213  // -- ActionListener methods -- 
     214 
     215  public void actionPerformed(ActionEvent e) { 
     216    String cmd = e.getActionCommand(); 
     217    if ("select".equals(cmd)) { 
     218      for (int i=0; i<boxes.length; i++) boxes[i].setState(true); 
     219      updateIfGlitched(); 
     220    } 
     221    else if ("deselect".equals(cmd)) { 
     222      for (int i=0; i<boxes.length; i++) boxes[i].setState(false); 
     223      updateIfGlitched(); 
     224    } 
     225  } 
     226 
     227  // -- Helper methods -- 
     228 
     229  private void updateIfGlitched() { 
     230    if (IS_GLITCHED) { 
     231      // HACK - work around for Mac OS X AWT bug 
     232      sleep(200); 
     233      for (int i=0; i<boxes.length; i++) boxes[i].repaint(); 
     234    } 
     235  } 
     236 
     237  private void rebuildDialog(GenericDialog gd, int nPanels) { 
    194238    gd.removeAll(); 
    195239 
     
    199243      protected void dispatchEventImpl(AWTEvent e) { } 
    200244    }; 
     245    int seriesCount = options.getSeriesCount(); 
    201246    masterPanel.setLayout(new GridLayout(seriesCount, 2)); 
    202247 
     
    205250      masterPanel.add(p[i]); 
    206251    } 
     252     
     253    GridBagLayout gdl = (GridBagLayout) gd.getLayout(); 
     254    GridBagConstraints gbc = new GridBagConstraints(); 
    207255    gbc.gridx = 0; 
    208256    gbc.gridy = 0; 
     
    232280    gdl.setConstraints(buttons, gbc); 
    233281    gd.add(buttons); 
    234  
    235     if (options.isForceThumbnails()) gd.showDialog(); 
    236     else { 
    237       ThumbLoader loader = new ThumbLoader(r, p, gd, options.isAutoscale()); 
    238       gd.showDialog(); 
    239       loader.stop(); 
    240     } 
    241     if (gd.wasCanceled()) return STATUS_CANCELED; 
    242  
    243     seriesString = "["; 
    244     for (int i=0; i<seriesCount; i++) { 
    245       boolean on = gd.getNextBoolean(); 
    246       options.setSeriesOn(i, on); 
    247       if (on) seriesString += i + " "; 
    248     } 
    249     seriesString += "]"; 
    250  
    251     options.setSeries(seriesString); 
    252     return STATUS_OK; 
    253   } 
    254  
    255   // -- ActionListener methods -- 
    256  
    257   public void actionPerformed(ActionEvent e) { 
    258     String cmd = e.getActionCommand(); 
    259     if ("select".equals(cmd)) { 
    260       for (int i=0; i<boxes.length; i++) boxes[i].setState(true); 
    261       updateIfGlitched(); 
    262     } 
    263     else if ("deselect".equals(cmd)) { 
    264       for (int i=0; i<boxes.length; i++) boxes[i].setState(false); 
    265       updateIfGlitched(); 
    266     } 
    267   } 
    268  
    269   // -- Helper methods -- 
    270  
    271   private void updateIfGlitched() { 
    272     if (IS_GLITCHED) { 
    273       // HACK - work around for Mac OS X AWT bug 
    274       sleep(200); 
    275       for (int i=0; i<boxes.length; i++) boxes[i].repaint(); 
    276     } 
    277282  } 
    278283 
  • trunk/components/loci-plugins/src/loci/plugins/in/SwapDialog.java

    r6246 r6247  
    2626package loci.plugins.in; 
    2727 
     28import java.io.IOException; 
     29 
    2830import ij.IJ; 
    2931import ij.gui.GenericDialog; 
    3032import loci.formats.DimensionSwapper; 
    31 import loci.plugins.prefs.OptionsDialog; 
     33import loci.formats.FormatException; 
    3234import loci.plugins.util.WindowTools; 
    3335 
     
    3941 * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/loci-plugins/src/loci/plugins/in/SwapDialog.java">SVN</a></dd></dl> 
    4042 */ 
    41 public class SwapDialog extends OptionsDialog { 
     43public class SwapDialog extends ImporterDialog { 
    4244 
    4345  // -- Fields -- 
    4446 
    45   /** LOCI plugins configuration. */ 
    46   protected ImporterOptions options; 
    47  
    48   protected DimensionSwapper r; 
     47  protected DimensionSwapper dimSwap; 
    4948 
    5049  // -- Constructor -- 
    5150 
    5251  /** Creates a dimension swapper dialog for the Bio-Formats Importer. */ 
    53   public SwapDialog(ImporterOptions options, DimensionSwapper r) { 
     52  public SwapDialog(ImporterOptions options) { 
    5453    super(options); 
    55     this.options = options; 
    56     this.r = r; 
     54    try { 
     55      dimSwap = (DimensionSwapper) 
     56        options.getReader().unwrap(DimensionSwapper.class, null); 
     57    } 
     58    catch (FormatException e) { 
     59      // TODO Auto-generated catch block 
     60      e.printStackTrace(); 
     61    } 
     62    catch (IOException e) { 
     63      // TODO Auto-generated catch block 
     64      e.printStackTrace(); 
     65    } 
    5766  } 
    5867 
    59   // -- OptionsDialog methods -- 
    60  
    61   /** 
    62    * Gets dimension order from macro options, or user prompt if necessary. 
    63    * 
    64    * @return status of operation 
    65    */ 
    66   public int showDialog() { 
     68  // -- ImporterDialog methods -- 
     69   
     70  @Override 
     71  protected boolean needPrompt() { 
     72    return !options.isWindowless() && options.isSwapDimensions(); 
     73  } 
     74   
     75  @Override 
     76  protected GenericDialog constructDialog() { 
    6777    GenericDialog gd = new GenericDialog("Dimension swapping options"); 
    6878 
    69     int oldSeries = r.getSeries(); 
    7079    String[] labels = {"Z", "C", "T"}; 
    71     int[] sizes = new int[] {r.getSizeZ(), r.getSizeC(), r.getSizeT()}; 
    72     for (int s=0; s<r.getSeriesCount(); s++) { 
     80    int[] sizes = new int[] { 
     81      dimSwap.getSizeZ(), dimSwap.getSizeC(), dimSwap.getSizeT() 
     82    }; 
     83    for (int s=0; s<dimSwap.getSeriesCount(); s++) { 
    7384      if (!options.isSeriesOn(s)) continue; 
    74       r.setSeries(s); 
     85      dimSwap.setSeries(s); 
    7586 
    7687      gd.addMessage("Series " + (s + 1) + ":\n"); 
     
    8192    } 
    8293    WindowTools.addScrollBars(gd); 
    83     gd.showDialog(); 
    84     if (gd.wasCanceled()) return STATUS_CANCELED; 
    85  
    86     for (int s=0; s<r.getSeriesCount(); s++) { 
     94     
     95    return gd; 
     96  } 
     97   
     98  @Override 
     99  protected void harvestResults(GenericDialog gd) { 
     100    for (int s=0; s<dimSwap.getSeriesCount(); s++) { 
    87101      if (!options.isSeriesOn(s)) continue; 
    88       r.setSeries(s); 
     102      dimSwap.setSeries(s); 
    89103      String z = gd.getNextChoice(); 
    90104      String c = gd.getNextChoice(); 
     
    93107      if (z.equals(t) || z.equals(c) || c.equals(t)) { 
    94108        IJ.error("Invalid swapping options - each axis can be used only once."); 
    95         return showDialog(); // TODO: fix bad recursion 
     109        throw new IllegalStateException(); // CTR FIXME 
    96110      } 
    97111 
    98       String originalOrder = r.getDimensionOrder(); 
     112      String originalOrder = dimSwap.getDimensionOrder(); 
    99113      StringBuffer sb = new StringBuffer(); 
    100114      sb.append("XY"); 
     
    105119      } 
    106120 
    107       r.swapDimensions(sb.toString()); 
     121      dimSwap.swapDimensions(sb.toString()); 
    108122    } 
    109     r.setSeries(oldSeries); 
    110  
    111     return STATUS_OK; 
    112123  } 
    113124 
  • trunk/components/loci-plugins/src/loci/plugins/in/UpgradeDialog.java

    r6229 r6247  
    2828import ij.IJ; 
    2929import ij.gui.GenericDialog; 
     30import loci.plugins.BF; 
    3031import loci.plugins.Updater; 
    3132import loci.plugins.prefs.OptionsDialog; 
     
    6263   */ 
    6364  public int showDialog() { 
    64     if (options.isQuiet()) return STATUS_OK; 
     65    // verify whether prompt is necessary 
     66    if (options.isQuiet() || options.isWindowless()) { 
     67      BF.debug("UpgradeDialog: skip"); 
     68      return STATUS_OK; 
     69    } 
     70    BF.debug("UpgradeDialog: prompt"); 
    6571 
    66     if (options.isFirstTime()) { 
     72    if (!options.isQuiet() && options.isFirstTime()) { 
    6773      // present user with one-time dialog box 
    6874      GenericDialog gd = new GenericDialog("Bio-Formats Upgrade Checker"); 
  • trunk/components/loci-plugins/test/loci/plugins/in/ImporterTest.java

    r6246 r6247  
    4141    assertTrue(imps[0].getWidth() == sizeX); 
    4242    assertTrue(imps[0].getHeight() == sizeY); 
    43     System.out.println("It worked!");//TEMP 
     43 
     44    System.out.println("Basic worked!");//TEMP 
    4445  } 
    4546 
     
    7071    assertTrue(imps[0].getWidth() == cropSizeX); 
    7172    assertTrue(imps[0].getHeight() == cropSizeY); 
     73 
     74    System.out.println("Crop worked!");//TEMP 
    7275  } 
    7376   
Note: See TracChangeset for help on using the changeset viewer.