Changeset 7904


Ignore:
Timestamp:
03/01/12 19:12:24 (8 years ago)
Author:
aivar
Message:

SLIM Plugin: Rewrite of cursor code, tidy up UI and code. In progress.

Location:
trunk/projects/slim-plugin/src/main/java/loci/slim
Files:
4 deleted
8 edited
2 moved

Legend:

Unmodified
Added
Removed
  • trunk/projects/slim-plugin/src/main/java/loci/slim/SLIMProcessor.java

    r7903 r7904  
    9191import loci.slim.fitting.config.Configuration; 
    9292import loci.slim.fitting.cursor.FittingCursor; 
     93import loci.slim.fitting.cursor.FittingCursorHelper; 
    9394import loci.slim.fitting.cursor.IFittingCursorListener; 
    9495import loci.slim.fitting.engine.IFittingEngine; 
     
    135136    private static final String LIFETIME = "Lifetime"; 
    136137    private static final String CHANNELS = "Channels"; 
     138    private static final boolean TABBED = true; 
    137139    private static final boolean USE_TAU = true; 
    138140    private static final boolean USE_LAMBDA = false; 
     
    278280         
    279281        // cursor support 
    280         _fittingCursor = new FittingCursor(m_timeRange); 
     282        _fittingCursor = new FittingCursor(m_timeRange, m_bins); 
     283        _fittingCursor.addListener(new FittingCursorListener()); 
    281284         
    282285        // show the UI; do fits 
    283         final IUserInterfacePanel uiPanel = new UserInterfacePanel(USE_TAU, m_analysis.getChoices(), m_binning.getChoices()); 
    284         uiPanel.setFittingCursor(_fittingCursor); 
     286        final IUserInterfacePanel uiPanel = new UserInterfacePanel(TABBED, 
     287                USE_TAU, m_analysis.getChoices(), m_binning.getChoices()); 
     288        FittingCursorHelper fittingCursorHelper = new FittingCursorHelper(); 
     289        fittingCursorHelper.setFittingCursor(_fittingCursor); 
     290        uiPanel.setFittingCursorHelper(fittingCursorHelper); 
    285291        uiPanel.setX(0); 
    286292        uiPanel.setY(0); 
     
    450456     */ 
    451457    private void updateDecayCursors(IUserInterfacePanel uiPanel) { 
    452         //TODO ARG the way this is working now, each channel has it's own 
    453         // start/stop cursors. 
     458        double[] decay = getSummedDecay(); 
     459        int[] results = CursorHelper.estimateDecayCursors(m_timeRange, decay); 
     460        int dataStart = results[CursorHelper.DECAY_START]; 
     461        int transientStop = results[CursorHelper.DECAY_STOP]; 
     462         
     463        _fittingCursor.setDataStartBin(dataStart); 
     464        _fittingCursor.setTransientStopBin(transientStop); 
     465    } 
     466     
     467    private double[] getSummedDecay() { 
    454468        double[] decay = new double[m_bins]; 
    455469        for (int i = 0; i < decay.length; ++i) { 
     
    465479            } 
    466480        } 
    467  
    468         int[] results = CursorHelper.estimateDecayCursors(m_timeRange, decay); 
    469         int start = results[CursorHelper.DECAY_START]; 
    470         int stop = results[CursorHelper.DECAY_STOP]; 
    471          
    472         System.out.println("updateDecayCursors gets start " + start + " stop " + stop); 
    473         _fittingCursor.setDataStartBin(start); 
    474         _fittingCursor.setTransientStopBin(stop); 
    475         //TODO ARGuiPanel.setStart(start); 
    476        // uiPanel.setStop(stop); 
    477 //TODO ARG I bet not here:        DecayGraph.getInstance().setStartStop(start, stop); 
    478         // uiPanel and DecayGraph will get changes from the FittingCursor listener 
     481        return decay; 
    479482    } 
    480483 
     
    511514            _fittingCursor.setTransientStopBin ((int) results[CursorHelper.TRANSIENT_STOP]); 
    512515 
    513             m_excitationPanel = new ExcitationPanel(excitation); 
     516            m_excitationPanel = new ExcitationPanel(excitation, _fittingCursor); 
    514517 
    515518            success = true; 
     
    18411844        decayGraph.setData(irf, data); 
    18421845    } 
     1846     
     1847    /** 
     1848     * Inner class that listens for changes in the cursor that should trigger 
     1849     * a refit. 
     1850     */    
     1851    private class FittingCursorListener implements IFittingCursorListener { 
     1852        private Integer _transStart    = null; 
     1853        private Integer _dataStart     = null; 
     1854        private Integer _transStop     = null; 
     1855        private Integer _promptStart   = null; 
     1856        private Integer _promptStop    = null; 
     1857        private Double _promptBaseline = null; 
     1858         
     1859        public void cursorChanged(FittingCursor cursor) { 
     1860            boolean refit = false; 
     1861             
     1862            // get current cursor values 
     1863            int transStart  = cursor.getTransientStartBin(); 
     1864            int dataStart   = cursor.getDataStartBin(); 
     1865            int transStop   = cursor.getTransientStopBin(); 
     1866            int promptStart = cursor.getPromptStartBin(); 
     1867            int promptStop  = cursor.getPromptStopBin(); 
     1868            double promptBaseline = cursor.getPromptBaselineValue(); 
     1869             
     1870            // look for changes vs. saved cursor values 
     1871            if (null != _transStart && transStart != _transStart) { 
     1872                refit = true; 
     1873            } 
     1874            if (null != _dataStart && dataStart != _dataStart) { 
     1875                refit = true; 
     1876            } 
     1877            if (null != _transStop && transStop != _transStop) { 
     1878                refit = true; 
     1879            } 
     1880            if (null != _promptStart && promptStart != _promptStart) { 
     1881                refit = true; 
     1882            } 
     1883            if (null != _promptStop && promptStop != _promptStop) { 
     1884                refit = true; 
     1885            } 
     1886            if (null != _promptBaseline && promptBaseline != _promptBaseline) { 
     1887                refit = true; 
     1888            } 
     1889             
     1890            // update saved cursor values 
     1891            _transStart = transStart; 
     1892            _dataStart = dataStart; 
     1893            _transStop = transStop; 
     1894            _promptStart = promptStart; 
     1895            _promptStop = promptStop; 
     1896            _promptBaseline = promptBaseline; 
     1897             
     1898            // trigger refit 
     1899            if (refit) { 
     1900                System.out.println("REFIT"); 
     1901            } 
     1902        } 
     1903    } 
     1904 
    18431905} 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/fitting/cursor/FittingCursor.java

    r7903 r7904  
    11// 
    2 // Cursor.java 
     2// FittingCursor.java 
    33// 
    44 
     
    4848public class FittingCursor { 
    4949    private double _inc; 
     50    private int _bins; 
    5051    private Set<IFittingCursorListener> _listeners; 
    5152    private boolean _showBins; 
     
    5657    private double _dataStartValue; 
    5758    private double _transientStopValue; 
    58      
    59     public FittingCursor(double inc) { 
     59 
     60    /** 
     61     * Constructor 
     62     *  
     63     * @param inc time increment per bin 
     64     * @param bins total number of bins 
     65     */ 
     66    public FittingCursor(double inc, int bins) { 
    6067        _inc = inc; 
     68        _bins = bins; 
    6169        _listeners = Collections.synchronizedSet(new HashSet<IFittingCursorListener>()); 
    6270        _showBins = false; 
    6371    } 
    64      
     72 
     73    /** 
     74     * Adds a listener for cursor changes. 
     75     *  
     76     * @param listener  
     77     */ 
    6578    public void addListener(IFittingCursorListener listener) {  
    6679        _listeners.add(listener); 
    6780    } 
    68      
     81 
     82    /** 
     83     * Removes a listener for cursor changes. 
     84     *  
     85     * @param listener  
     86     */ 
    6987    public void removeListener(IFittingCursorListener listener) { 
    7088        _listeners.remove(listener); 
    7189    } 
    72      
     90 
     91    /** 
     92     * Sets whether the UI will display bins or time values. 
     93     *  
     94     * @param showBins  
     95     */ 
    7396    public void setShowBins(boolean showBins) { 
    7497        _showBins = showBins; 
    7598    } 
    76      
     99 
     100    /** 
     101     * Gets whether the UI will display bins or time values. 
     102     *  
     103     * @return  
     104     */ 
    77105    public boolean getShowBins() { 
    78106        return _showBins; 
    79107    } 
    80      
     108 
     109    /** 
     110     * Sets the start of the prompt based on a string.  Handles bins or time 
     111     * values. 
     112     *  
     113     * @param promptStart  
     114     */ 
    81115    public void setPromptStart(String promptStart) { 
    82          
    83     } 
    84      
     116        Double promptStartValue = null; 
     117        if (_showBins) { 
     118            Integer parsedInteger = getIntegerValue(promptStart); 
     119            if (null != parsedInteger) { 
     120                promptStartValue = _inc * parsedInteger; 
     121            } 
     122        } 
     123        else { 
     124            promptStartValue = getDoubleValue(promptStart); 
     125        } 
     126        if (null != promptStartValue) { 
     127            if (promptStartValue <= _promptStopValue && 
     128                    promptStartValue >= 0.0) { 
     129                _promptStartValue = promptStartValue; 
     130            } 
     131        } 
     132        // either update others with new valid value or undo our invalid value 
     133        notifyListeners(); 
     134    } 
     135  
     136    /** 
     137     * Gets the start of the prompt as a string.  Handles bins or time values. 
     138     *  
     139     * @return  
     140     */ 
    85141    public String getPromptStart() { 
    86142        StringBuffer returnValue = new StringBuffer(); 
     
    94150    } 
    95151 
     152    /** 
     153     * Sets the start of the prompt as a bin number. 
     154     *  
     155     * @param bin  
     156     */ 
    96157    public void setPromptStartBin(int bin) { 
    97158        _promptStartValue = _inc * bin; 
     
    99160    } 
    100161 
     162    /** 
     163     * Gets the start of the prompt as a bin number. 
     164     *  
     165     * @return  
     166     */ 
    101167    public int getPromptStartBin() { 
    102168        return (int) Math.floor(_promptStartValue / _inc); 
    103169    } 
    104      
     170 
     171    /** 
     172     * Sets the start of the prompt as a time value. 
     173     *  
     174     * @param value  
     175     */ 
    105176    public void setPromptStartValue(double value) { 
    106177        _promptStartValue = value; 
    107178        notifyListeners(); 
    108179    } 
    109      
     180 
     181    /** 
     182     * Gets the start of the prompt as a time value. 
     183     *  
     184     * @return  
     185     */ 
    110186    public double getPromptStartValue() { 
    111187        int bin = getPromptStartBin(); 
    112188        return bin * _inc; 
    113189    } 
    114      
     190  
     191    /** 
     192     * Sets the end of the prompt based on a string.  Handles bins or time 
     193     * values. 
     194     *  
     195     * @param promptStop  
     196     */ 
    115197    public void setPromptStop(String promptStop) { 
    116          
    117     } 
    118      
     198        Double promptStopValue = null; 
     199        if (_showBins) { 
     200            Integer parsedInteger = getIntegerValue(promptStop); 
     201            if (null != parsedInteger) { 
     202                promptStopValue = _inc * parsedInteger; 
     203            } 
     204        } 
     205        else { 
     206            promptStopValue = getDoubleValue(promptStop); 
     207        } 
     208        if (null != promptStopValue) { 
     209            if (promptStopValue >= _promptStartValue && 
     210                    promptStopValue <= _bins * _inc) { 
     211                _promptStopValue = promptStopValue; 
     212            } 
     213        } 
     214        // either update others with new valid value or undo our invalid value 
     215        notifyListeners(); 
     216    } 
     217 
     218    /** 
     219     * Gets the end of the prompt as a string.  Handles bins or time values. 
     220     *  
     221     * @return  
     222     */ 
    119223    public String getPromptStop() { 
    120224        StringBuffer returnValue = new StringBuffer(); 
     
    128232    } 
    129233 
     234    /** 
     235     * Sets the end of the prompt as a bin number. 
     236     *  
     237     * @param bin  
     238     */ 
    130239    public void setPromptStopBin(int bin) { 
    131240        _promptStopValue = _inc * bin; 
     
    133242    } 
    134243 
     244    /** 
     245     * Gets the end of the prompt as a bin number. 
     246     *  
     247     * @return  
     248     */ 
    135249    public int getPromptStopBin() { 
    136250        return (int) Math.ceil(_promptStopValue / _inc); 
    137251    } 
    138      
     252 
     253    /** 
     254     * Sets the end of the prompt as a time value. 
     255     *  
     256     * @param value  
     257     */ 
    139258    public void setPromptStopValue(double value) { 
    140259        _promptStopValue = value; 
    141260        notifyListeners(); 
    142261    } 
    143      
     262 
     263    /** 
     264     * Gets the end of the prompt as a time value. 
     265     *  
     266     * @return  
     267     */ 
    144268    public double getPromptStopValue() { 
    145269        return _promptStopValue; 
    146270    } 
    147      
     271 
     272    /** 
     273     * Sets the baseline of the prompt based on a string. 
     274     *  
     275     * @param promptBaseline  
     276     */ 
    148277    public void setPromptBaseline(String promptBaseline) { 
    149          
    150     } 
    151      
     278        Double promptBaselineValue = getDoubleValue(promptBaseline); 
     279        if (null != promptBaselineValue) { 
     280            _promptBaselineValue = promptBaselineValue; 
     281        } 
     282        // either update others with new valid value or undo our invalid value 
     283        notifyListeners(); 
     284    } 
     285  
     286    /** 
     287     * Gets the baseline of the prompt based on a string. 
     288     *  
     289     * @return  
     290     */ 
    152291    public String getPromptBaseline() { 
    153292        StringBuffer returnValue = new StringBuffer(); 
    154         if (_showBins) { 
    155             returnValue.append(getPromptBaselineBin()); 
    156         } 
    157         else { 
    158             returnValue.append(getPromptBaselineValue()); 
    159         } 
     293        returnValue.append(getPromptBaselineValue()); 
    160294        return returnValue.toString(); 
    161295    } 
    162  
    163     public void setPromptBaselineBin(int bin) { 
    164         _promptBaselineValue = _inc * bin; 
    165         notifyListeners(); 
    166     } 
    167      
    168     public int getPromptBaselineBin() { 
    169         return (int) Math.floor(_promptBaselineValue / _inc); 
    170     } 
    171      
     296  
     297    /** 
     298     * Sets the baseline of the prompt as a value. 
     299     *  
     300     * Note that this value is actually a photon count and not based on bins or 
     301     * time values. 
     302     *  
     303     * @param value  
     304     */ 
    172305    public void setPromptBaselineValue(double value) { 
    173306        _promptBaselineValue = value; 
    174307        notifyListeners(); 
    175308    } 
    176      
     309 
     310    /** 
     311     * Gets the baseline of the prompt as a value. 
     312     *  
     313     * @return 
     314     */ 
    177315    public double getPromptBaselineValue() { 
    178316        return _promptBaselineValue; 
    179317    } 
    180      
     318  
     319    /** 
     320     * Sets the start of the transient based on a string.  Handles bins or time 
     321     * values. 
     322     *  
     323     * @param transientStart  
     324     */ 
    181325    public void setTransientStart(String transientStart) { 
    182          
    183     } 
    184      
     326        Double transientStartValue = null; 
     327        if (_showBins) { 
     328            Integer parsedInteger = getIntegerValue(transientStart); 
     329            if (null != parsedInteger) { 
     330                transientStartValue = _inc * parsedInteger; 
     331            } 
     332        } 
     333        else { 
     334            transientStartValue = getDoubleValue(transientStart); 
     335        } 
     336        if (null != transientStartValue) { 
     337            if (transientStartValue <= _dataStartValue && 
     338                    transientStartValue >= 0.0) { 
     339                _transientStartValue = transientStartValue; 
     340            } 
     341        } 
     342        // either update others with new valid value or undo our invalid value 
     343        notifyListeners(); 
     344    } 
     345 
     346  
     347    /** 
     348     * Gets the start of the transient as a string.  Handles bins or time values. 
     349     *  
     350     * @return  
     351     */ 
    185352    public String getTransientStart() { 
    186353        StringBuffer returnValue = new StringBuffer(); 
     
    193360        return returnValue.toString(); 
    194361    } 
    195      
     362 
     363    /** 
     364     * Sets the start of the transient as a bin number. 
     365     *  
     366     * @param bin  
     367     */ 
    196368    public void setTransientStartBin(int bin) { 
    197369        _transientStartValue = _inc * bin; 
    198370        notifyListeners(); 
    199371    } 
    200      
     372 
     373    /** 
     374     * Gets the start of the transient as a bin number. 
     375     *  
     376     * @return  
     377     */ 
    201378    public int getTransientStartBin() { 
    202379        return (int) Math.floor(_transientStartValue / _inc); 
    203380    } 
    204      
     381 
     382    /** 
     383     * Sets the start of the transient as a time value. 
     384     *  
     385     * @param value  
     386     */ 
    205387    public void setTransientStartValue(double value) { 
    206388        _transientStartValue = value; 
    207389        notifyListeners(); 
    208390    } 
    209      
     391 
     392    /** 
     393     * Gets the start of the transient as a time value. 
     394     *  
     395     * @return  
     396     */ 
    210397    public double getTransientStartValue() { 
    211398        return _transientStartValue; 
    212399    } 
    213400     
     401    /** 
     402     * Sets the start of the data based on a string.  Handles bins or time 
     403     * values. 
     404     *  
     405     * @param dataStart  
     406     */     
    214407    public void setDataStart(String dataStart) { 
    215          
    216     } 
    217      
     408        Double dataStartValue = null; 
     409        if (_showBins) { 
     410            Integer parsedInteger = getIntegerValue(dataStart); 
     411            if (null != parsedInteger) { 
     412                dataStartValue = _inc * parsedInteger; 
     413            } 
     414        } 
     415        else { 
     416            dataStartValue = getDoubleValue(dataStart); 
     417        } 
     418        if (null != dataStartValue) { 
     419            if (dataStartValue <= _transientStopValue) { 
     420                _dataStartValue = dataStartValue; 
     421            } 
     422        } 
     423        // either update with new valid values or undo invalid values 
     424        notifyListeners(); 
     425    } 
     426 
     427    /** 
     428     * Gets the start of the data as a string.  Handles bins or time values. 
     429     *  
     430     * @return  
     431     */ 
    218432    public String getDataStart() { 
    219433        StringBuffer returnValue = new StringBuffer(); 
     
    226440        return returnValue.toString(); 
    227441    } 
    228      
     442 
     443    /** 
     444     * Sets the start of the data as a bin number. 
     445     *  
     446     * @param bin  
     447     */ 
    229448    public void setDataStartBin(int bin) { 
    230449        _dataStartValue = _inc * bin; 
    231450        notifyListeners(); 
    232451    } 
    233      
     452 
     453    /** 
     454     * Gets the start of the data as a bin number. 
     455     *  
     456     * @return  
     457     */ 
    234458    public int getDataStartBin() { 
    235459        return (int) Math.floor(_dataStartValue / _inc); 
    236460    } 
    237      
     461 
     462    /** 
     463     * Sets the start of the data as a time value. 
     464     *  
     465     * @param value  
     466     */ 
    238467    public void setDataStartValue(double value) { 
    239468        _dataStartValue = value; 
    240469        notifyListeners(); 
    241470    } 
    242      
     471 
     472    /** 
     473     * Gets the start of the data as a time value. 
     474     *  
     475     * @return  
     476     */ 
    243477    public double getDataStartValue() { 
    244478        return _dataStartValue; 
    245479    } 
    246480     
    247      
     481    /** 
     482     * Sets the end of the transient based on a string.  Handles bins or time 
     483     * values. 
     484     *  
     485     * @param transientStop  
     486     */     
    248487    public void setTransientStop(String transientStop) { 
    249          
    250     } 
    251      
     488        Double transientStopValue = null; 
     489        if (_showBins) { 
     490            Integer parsedInteger = getIntegerValue(transientStop); 
     491            if (null != parsedInteger) { 
     492                transientStopValue = _inc * parsedInteger; 
     493            } 
     494        } 
     495        else { 
     496            transientStopValue = getDoubleValue(transientStop); 
     497        } 
     498        if (null != transientStopValue) { 
     499            if (transientStopValue >= _dataStartValue && 
     500                    transientStopValue <= _inc * _bins) { 
     501                _transientStopValue = transientStopValue; 
     502            } 
     503        } 
     504        // either update with new valid values or undo invalid values 
     505        notifyListeners(); 
     506    } 
     507 
     508    /** 
     509     * Gets the end of the transient as a string.  Handles bins or time values. 
     510     *  
     511     * @return  
     512     */ 
    252513    public String getTransientStop() { 
    253514        StringBuffer returnValue = new StringBuffer(); 
     
    260521        return returnValue.toString(); 
    261522    } 
    262      
     523 
     524    /** 
     525     * Sets the end of the transient as a bin number. 
     526     *  
     527     * @param bin  
     528     */ 
    263529    public void setTransientStopBin(int bin) { 
    264530        _transientStopValue = _inc * bin; 
    265531        notifyListeners(); 
    266532    } 
    267      
     533 
     534    /** 
     535     * Gets the end of the transient as a bin number. 
     536     *  
     537     * @return  
     538     */ 
    268539    public int getTransientStopBin() { 
    269540        return (int) Math.ceil(_transientStopValue / _inc); 
    270541    } 
    271      
     542 
     543    /** 
     544     * Sets the end of the transient as a time value. 
     545     *  
     546     * @param value  
     547     */ 
    272548    public void setTransientStopValue(double value) { 
    273549        _transientStopValue = value; 
    274550        notifyListeners(); 
    275551    } 
    276      
     552 
     553    /** 
     554     * Gets the end of the transient as a time value. 
     555     *  
     556     * @return  
     557     */ 
    277558    public double getTransientStopValue() { 
    278559        return _transientStopValue; 
    279560    } 
    280      
    281     public double binToValue(int bin, boolean isStart) { 
    282         return isStart ? 0.0 : 1.0; 
    283     } 
    284      
    285     public int valueToBin(double value) { 
    286         return 1; 
    287     } 
    288      
     561  
     562    /** 
     563     * Helper function to extract integers from strings. 
     564     *  
     565     * @param string 
     566     * @return integer or null 
     567     */ 
     568    private Integer getIntegerValue(String string) { 
     569        Integer value = null; 
     570        try { 
     571            value = Integer.parseInt(string); 
     572        } 
     573        catch (NumberFormatException e) { 
     574        } 
     575        return value; 
     576    } 
     577  
     578    /** 
     579     * Helper function to extract doubles from strings. 
     580     *  
     581     * @param string 
     582     * @return integer or null 
     583     */ 
     584    private Double getDoubleValue(String string) { 
     585        Double value = null; 
     586        try { 
     587            value = Double.parseDouble(string); 
     588        } 
     589        catch (NumberFormatException e) { 
     590        } 
     591        return value; 
     592    } 
     593 
     594    /** 
     595     * Notifies all listeners of a change. 
     596     */ 
    289597    private void notifyListeners() { 
    290         System.out.println("notify " + _listeners.size() + " listeners"); 
    291598        for (IFittingCursorListener listener : _listeners) { 
    292599            listener.cursorChanged(this); 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/fitting/cursor/FittingCursorHelper.java

    r7903 r7904  
    66 
    77/** 
    8  * 
    9  * @author aivar 
     8 * This is a helper class for the user interface for setting and displaying 
     9 * the fitting cursor start and stop values.  This listens for changes and 
     10 * keeps the user interface display up to date. 
     11 *  
     12 * @author Aivar Grislis 
    1013 */ 
    11 public class TransientCursorUIHelper implements ITransientCursorUI { 
    12     FittingCursor _fittingCursor; 
    13     IFittingCursorListener _fittingCursorListener; 
    14     ITransientCursorUI _transientCursorUI; 
     14public class FittingCursorHelper implements IFittingCursorUI { 
     15    private FittingCursor _fittingCursor; 
     16    private IFittingCursorListener _fittingCursorListener; 
     17    private IFittingCursorUI _fittingCursorUI; 
    1518     
    16     public TransientCursorUIHelper() { 
     19    /** 
     20     * Sets the UI source and destination of fitting cursor strings, e.g. a 
     21     * wrapper around some JTextField. 
     22     *  
     23     * @param promptCursorUI  
     24     */ 
     25    public void setFittingCursorUI(IFittingCursorUI fittingCursorUI) { 
     26        _fittingCursorUI = fittingCursorUI; 
     27        showFittingCursor(); 
    1728    } 
    18      
     29 
     30    /** 
     31     * Sets the fitting cursor that is keeping track of cursor settings. 
     32     *  
     33     * @param fittingCursor  
     34     */ 
    1935    public void setFittingCursor(FittingCursor fittingCursor) { 
    2036        if (null == _fittingCursor) { 
     
    2743        _fittingCursor.addListener(_fittingCursorListener); 
    2844    } 
    29      
    30     public void setTransientCursorUI(ITransientCursorUI transientCursorUI) { 
    31         _transientCursorUI = transientCursorUI; 
    32         showTransientCursor(); 
     45 
     46    /** 
     47     * Gets whether to show bins or time values for cursors. 
     48     *  
     49     * @return  
     50     */ 
     51    public boolean getShowBins() { 
     52        return _fittingCursor.getShowBins(); 
    3353    } 
    3454     
     
    4060    @Override 
    4161    public String getTransientStart() { 
    42         return _transientCursorUI.getTransientStart(); 
     62        return _fittingCursorUI.getTransientStart(); 
    4363    } 
    4464   
     
    5070    @Override 
    5171    public void setTransientStart(String transientStart) { 
    52         _transientCursorUI.setTransientStart(transientStart); 
    5372        _fittingCursor.setTransientStart(transientStart); 
    5473    } 
     
    5675    /** 
    5776     * Gets the data start cursor. 
     77     *  
    5878     * @return  
    5979     */ 
    6080    @Override 
    6181    public String getDataStart() { 
    62         return _transientCursorUI.getDataStart(); 
     82        return _fittingCursorUI.getDataStart(); 
    6383    } 
    6484 
     
    6888     * @param transientBaseline  
    6989     */ 
     90    @Override 
    7091    public void setDataStart(String dataStart) { 
    71         _transientCursorUI.setDataStart(dataStart); 
    7292        _fittingCursor.setDataStart(dataStart); 
    7393    } 
     
    80100    @Override 
    81101    public String getTransientStop() { 
    82         return _transientCursorUI.getTransientStop(); 
     102        return _fittingCursorUI.getTransientStop(); 
    83103    } 
    84104 
     
    90110    @Override 
    91111    public void setTransientStop(String transientStop) { 
    92         _transientCursorUI.setTransientStop(transientStop); 
    93112        _fittingCursor.setTransientStop(transientStop);  
    94113    } 
     114     
     115    /** 
     116     * Gets the prompt start cursor. 
     117     *  
     118     * @return  
     119     */ 
     120    @Override 
     121    public String getPromptStart() { 
     122        return _fittingCursorUI.getPromptStart(); 
     123    } 
     124   
     125    /** 
     126     * Sets the prompt start cursor. 
     127     *  
     128     * @param promptStart  
     129     */ 
     130    @Override 
     131    public void setPromptStart(String promptStart) { 
     132        _fittingCursor.setPromptStart(promptStart); 
     133    } 
    95134 
    96     private void showTransientCursor() { 
    97         if (_fittingCursor.getShowBins())  { 
    98             int transientStart     = _fittingCursor.getTransientStartBin(); 
    99             int dataStart          = _fittingCursor.getDataStartBin(); 
    100             int transientStop      = _fittingCursor.getTransientStopBin(); 
    101             _transientCursorUI.setTransientStart   ("" + transientStart); 
    102             _transientCursorUI.setDataStart        ("" + dataStart); 
    103             _transientCursorUI.setTransientStop    ("" + transientStop); 
    104         } 
    105         else { 
    106             double transientStart    = _fittingCursor.getTransientStartValue(); 
    107             double dataStart         = _fittingCursor.getDataStartBin(); 
    108             double transientStop     = _fittingCursor.getTransientStopValue(); 
    109             _transientCursorUI.setTransientStart   ("" + transientStart); 
    110             _transientCursorUI.setDataStart        ("" + dataStart); 
    111             _transientCursorUI.setTransientStop    ("" + transientStop); 
     135    /** 
     136     * Gets the prompt end cursor. 
     137     *  
     138     * @return  
     139     */ 
     140    @Override 
     141    public String getPromptStop() { 
     142        return _fittingCursorUI.getPromptStop(); 
     143    } 
     144 
     145    /** 
     146     * Sets the prompt end cursor. 
     147     *  
     148     * @param promptStop  
     149     */ 
     150    @Override 
     151    public void setPromptStop(String promptStop) { 
     152        _fittingCursor.setPromptStart(promptStop);  
     153    } 
     154     
     155    /** 
     156     * Gets the prompt baseline cursor as a string. 
     157     * @return  
     158     */ 
     159    @Override 
     160    public String getPromptBaseline() { 
     161        return _fittingCursorUI.getPromptBaseline(); 
     162    } 
     163 
     164    /** 
     165     * Sets the prompt baseline cursor as a string. 
     166     *  
     167     * @param promptBaseline  
     168     */ 
     169    @Override 
     170    public void setPromptBaseline(String promptBaseline) { 
     171        _fittingCursor.setPromptStart(promptBaseline); 
     172    } 
     173 
     174    /** 
     175     * Shows current fitting cursor settings in UI. 
     176     */ 
     177    private void showFittingCursor() { 
     178        if (null != _fittingCursorUI) { 
     179            _fittingCursorUI.setTransientStart(_fittingCursor.getTransientStart()); 
     180            _fittingCursorUI.setDataStart(_fittingCursor.getDataStart()); 
     181            _fittingCursorUI.setTransientStop(_fittingCursor.getTransientStop()); 
     182            _fittingCursorUI.setPromptStart(_fittingCursor.getPromptStart()); 
     183            _fittingCursorUI.setPromptStop(_fittingCursor.getPromptStop()); 
     184            _fittingCursorUI.setPromptBaseline(_fittingCursor.getPromptBaseline());  
    112185        } 
    113186    } 
    114187     
     188    /** 
     189     * Inner listener for cursor changes. 
     190     */    
    115191    private class FittingCursorListener implements IFittingCursorListener { 
     192        @Override 
    116193        public void cursorChanged(FittingCursor cursor) { 
    117             showTransientCursor(); 
     194            showFittingCursor(); 
    118195        } 
    119196    }   
  • trunk/projects/slim-plugin/src/main/java/loci/slim/fitting/cursor/IFittingCursorUI.java

    r7903 r7904  
    66 
    77/** 
    8  * 
     8 *  This is an interface to get/set transient and prompt cursors as strings. 
     9 *  
    910 * @author aivar 
    1011 */ 
    11 public interface ITransientCursorUI { 
     12public interface IFittingCursorUI { 
     13     
    1214    /** 
    1315     * Gets the transient start cursor. 
     
    4951     */ 
    5052    public void setTransientStop(String transientStop); 
     53     
     54    /** 
     55     * Gets the prompt start cursor. 
     56     *  
     57     * @return  
     58     */ 
     59    public String getPromptStart(); 
     60   
     61    /** 
     62     * Sets the prompt start cursor. 
     63     *  
     64     * @param promptStart  
     65     */ 
     66    public void setPromptStart(String promptStart); 
     67 
     68    /** 
     69     * Gets the prompt end cursor. 
     70     *  
     71     * @return  
     72     */ 
     73    public String getPromptStop(); 
     74 
     75    /** 
     76     * Sets the prompt end cursor. 
     77     *  
     78     * @param promptStop  
     79     */ 
     80    public void setPromptStop(String promptStop); 
     81     
     82    /** 
     83     * Gets the prompt baseline cursor. 
     84     * @return  
     85     */ 
     86    public String getPromptBaseline(); 
     87 
     88    /** 
     89     * Sets the prompt baseline cursor. 
     90     *  
     91     * @param promptBaseline  
     92     */ 
     93    public void setPromptBaseline(String promptBaseline); 
    5194} 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/fitting/cursor/LameCursorEstimator.java

    r7903 r7904  
    4646    @Override 
    4747    public IFittingCursorListener globalCursor(double[] prompt, double[] decay) { 
    48         FittingCursor cursor = new FittingCursor(0.01); 
     48        FittingCursor cursor = new FittingCursor(0.01, 64); 
    4949        cursor.setPromptStartBin(getMostSteep(prompt)); 
    5050        cursor.setPromptStopBin(getLeastSteep(prompt)); 
     
    5656    @Override 
    5757    public IFittingCursorListener localCursor(FittingCursor global, double[] prompt, double[] decay) { 
    58         FittingCursor cursor = new FittingCursor(0.01); 
     58        FittingCursor cursor = new FittingCursor(0.01, 64); 
    5959        cursor.setPromptStartBin(global.getPromptStartBin()); 
    6060        cursor.setPromptStopBin(global.getPromptStopBin()); 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ui/DecayGraph.java

    r7903 r7904  
    8686    static final Color TRANS_STOP_COLOR = Color.RED.darker(); 
    8787    static final Color BASE_COLOR = Color.GREEN.darker(); 
    88     static final Color RESIDUAL_COLOR = Color.BLACK; 
     88    static final Color RESIDUAL_COLOR = Color.GRAY.brighter(); //Color.BLACK; 
    8989 
    9090    private static DecayGraph _instance; 
     
    212212     */ 
    213213    public void setStartStop(int transStart, int dataStart, int transStop) { 
    214         if (null == _dataStart) { 
     214        if (true || null == _dataStart) { 
    215215            // initialize the vertical bars 
    216216            double transStartValue = transStart * _timeInc; 
     
    310310        NumberAxis residualAxis = new NumberAxis(RESIDUAL_AXIS_LABEL); 
    311311        XYSplineRenderer residualRenderer = new XYSplineRenderer(); 
    312         residualRenderer.setSeriesShapesVisible(0, false); 
     312        //residualRenderer.setSeriesShapesVisible(0, false); 
    313313        residualRenderer.setSeriesPaint(0, RESIDUAL_COLOR); 
     314        //residualRenderer.setSeriesLinesVisible(0, false); 
     315        residualRenderer.setSeriesShape 
     316                (0, new Ellipse2D.Float(-1.0f, -1.0f, 2.0f, 2.0f)); 
     317         
     318         
     319         
     320         
     321         
    314322        XYPlot residualSubPlot = new XYPlot 
    315323                (_residualDataset, null, residualAxis, residualRenderer); 
     
    599607                                if (_xTransStart == _xTransStop) { 
    600608                                    // all three superimposed 
    601                                     if (x - _xTransStart < 0) { 
     609                                    if (x < _xTransStart) { 
    602610                                        // start dragging trans start line 
    603611                                        _dragTransStartMarker = true; 
     
    610618                                else { 
    611619                                    // trans and data start superimposed 
    612                                     if (x - _xTransStart < 0) { 
     620                                    if (x < _xTransStart) { 
    613621                                        // start dragging trans start line 
    614622                                        _dragTransStartMarker = true; 
     
    628636                            if (_xDataStart == _xTransStop) { 
    629637                                // data start and trans stop superimposed 
    630                                 if (x - _xDataStart < 0) { 
     638                                if (x < _xDataStart) { 
    631639                                    // start dragging data start line 
    632640                                    _dragDataStartMarker = true; 
     
    694702            int dataStart      = cursor.getDataStartBin(); 
    695703            int transientStop  = cursor.getTransientStopBin(); 
     704            setStartStop(transientStart, dataStart, transientStop); 
     705            _frame.repaint(); 
    696706            System.out.println("CHANGED " + transientStart + " " + dataStart + " " + transientStop); 
    697707        } 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ui/ExcitationGraph.java

    r7903 r7904  
    6060import org.jfree.data.xy.XYSeriesCollection; 
    6161import org.jfree.ui.RectangleEdge; 
     62 
     63import loci.slim.fitting.cursor.FittingCursor; 
     64import loci.slim.fitting.cursor.IFittingCursorListener; 
    6265 
    6366/** 
     
    7780    static final Color STOP_COLOR = Color.RED.darker(); 
    7881    static final Color BASE_COLOR = Color.GREEN.darker(); 
    79     JFrame m_frame; 
    80     int m_start; 
    81     int m_stop; 
    82     double m_base; 
    83     int m_bins; 
    84     double m_count; 
    85     StartStopBaseDraggingUI<JComponent> m_startStopBaseDraggingUI; 
    86     IStartStopBaseListener m_startStopBaseListener; 
    87     boolean m_headless = false; 
    88     boolean m_logarithmic = false; 
    89     XYPlot m_excitationPlot; 
    90     XYSeriesCollection m_excitationDataset; 
    91     XYSeriesCollection m_residualDataset; 
    92     static ChartPanel m_panel; 
    93     JXLayer<JComponent> m_layer; 
    94  
    95     JFreeChart m_decayChart; 
    96     JFreeChart m_residualsChart; 
     82    JFrame _frame; 
     83    FittingCursor _fittingCursor; 
     84    IFittingCursorListener _fittingCursorListener; 
     85    int _start; 
     86    int _stop; 
     87    double _base; 
     88    int _bins; 
     89    double _count; 
     90    StartStopBaseDraggingUI<JComponent> _startStopBaseDraggingUI; 
     91    boolean _headless = false; 
     92    boolean _logarithmic = false; 
     93    XYPlot _excitationPlot; 
     94    XYSeriesCollection _excitationDataset; 
     95    XYSeriesCollection _residualDataset; 
     96    static ChartPanel _panel; 
     97    JXLayer<JComponent> _layer; 
     98 
     99    JFreeChart _decayChart; 
     100    JFreeChart _residualsChart; 
    97101 
    98102    /** 
     
    109113    ExcitationGraph(final int start, final int stop, final double base, 
    110114            final int bins, double[] values, final double timeInc) { 
    111         m_start = start; 
    112         m_stop = stop; 
    113         m_base = base; 
    114         m_bins = bins; 
    115         m_count = 0.0f; 
     115        _start = start; 
     116        _stop = stop; 
     117        _base = base; 
     118        _bins = bins; 
     119        _count = 0.0f; 
    116120        // find maximum count 
    117121        for (double value : values) { 
    118             if (value > m_count) { 
    119                 m_count = value; 
     122            if (value > _count) { 
     123                _count = value; 
    120124            } 
    121125        } 
     
    129133 
    130134        // Add JXLayer to draw/drag start/stop bars 
    131         m_layer = new JXLayer<JComponent>(chartPanel); 
    132         m_startStopBaseDraggingUI = new StartStopBaseDraggingUI<JComponent>(chartPanel, m_excitationPlot, this); 
    133         m_layer.setUI(m_startStopBaseDraggingUI); 
    134  
     135        _layer = new JXLayer<JComponent>(chartPanel); 
     136        _startStopBaseDraggingUI = new StartStopBaseDraggingUI<JComponent>(chartPanel, _excitationPlot, this); 
     137        _layer.setUI(_startStopBaseDraggingUI); 
     138 
     139     System.out.println("ExcitationGraph start " + start + " stop " + stop + " base " + base); 
    135140        // initialize the vertical bars that show start and stop time bins and 
    136141        // the horizontal bar with the base count. 
    137         m_startStopBaseDraggingUI.setStartStopBaseValues( 
     142        _startStopBaseDraggingUI.setStartStopBaseValues( 
    138143                timeInc * start, timeInc * stop, timeInc * bins, 
    139                 base, m_count); 
     144                base, _count); 
    140145    } 
    141146 
     
    146151     */ 
    147152    public JComponent getComponent() { 
    148         return m_layer; 
    149     } 
    150  
    151     /** 
    152      * Registers a single, external start/stop/base listener. 
    153      * This receives new values of start and stop time bins and/or the base 
    154      * count. 
    155      * 
    156      * @param startStopBaseListener 
    157      */ 
    158     void setStartStopBaseListener(IStartStopBaseListener startStopBaseListener) { 
    159         m_startStopBaseListener = startStopBaseListener; 
     153        return _layer; 
     154    } 
     155     
     156    public void setFittingCursor(FittingCursor fittingCursor) { 
     157        if (null == _fittingCursor) { 
     158            _fittingCursorListener = new FittingCursorListener(); 
     159        } 
     160        else { 
     161            _fittingCursor.removeListener(_fittingCursorListener); 
     162        } 
     163        _fittingCursor = fittingCursor; 
     164        _fittingCursor.addListener(_fittingCursorListener); 
    160165    } 
    161166 
     
    170175    public void setStartStopBaseProportion( 
    171176            double startProportion, double stopProportion, double baseProportion) { 
    172         int start = (int) (startProportion * m_bins + 0.5); 
    173         int stop = (int) (stopProportion * m_bins + 0.5); 
    174         int base = (int) (baseProportion * m_count + 0.5); 
     177        int start = (int) (startProportion * _bins + 0.5); 
     178        int stop = (int) (stopProportion * _bins + 0.5); 
     179        int base = (int) (baseProportion * _count + 0.5); 
    175180        //System.out.println("start " + start + " stop " + stop); 
    176         if (start != m_start || stop != m_stop) { 
    177             // redraw UI on bin boundaries 
    178          //TODO NO NO NO!!!     setStartStop(start, stop); 
    179             if (null != m_startStopBaseListener) { 
    180                 //System.out.println("NOTIFY LISTENER"); 
    181                 m_startStopBaseListener.setStartStopBase(start, stop, base); 
    182             } 
     181        if (start != _start || stop != _stop || base != _base) { 
     182            _fittingCursor.setPromptStartBin(start); 
     183            _fittingCursor.setPromptStopBin(stop); 
     184            _fittingCursor.setPromptBaselineValue(base); 
    183185        } 
    184186    } 
     
    204206        // make a vertical axis 
    205207        NumberAxis photonAxis; 
    206         if (m_logarithmic) { 
     208        if (_logarithmic) { 
    207209            photonAxis = new LogarithmicAxis("Photons"); 
    208210        } 
     
    216218        excitationRenderer.setSeriesPaint(0, EXCITATION_COLOR); 
    217219 
    218         m_excitationPlot = new XYPlot(m_excitationDataset, timeAxis, photonAxis, excitationRenderer); 
    219         m_excitationPlot.setDomainCrosshairVisible(true); 
    220         m_excitationPlot.setRangeCrosshairVisible(true); 
     220        _excitationPlot = new XYPlot(_excitationDataset, timeAxis, photonAxis, excitationRenderer); 
     221        _excitationPlot.setDomainCrosshairVisible(true); 
     222        _excitationPlot.setRangeCrosshairVisible(true); 
    221223 
    222224        // now make the top level JFreeChart 
    223         JFreeChart chart = new JFreeChart(null, JFreeChart.DEFAULT_TITLE_FONT, m_excitationPlot, true); 
     225        JFreeChart chart = new JFreeChart(null, JFreeChart.DEFAULT_TITLE_FONT, _excitationPlot, true); 
    224226        chart.removeLegend(); 
    225227 
     
    240242        for (int i = 0; i < bins; ++i) { 
    241243            yData = values[i]; 
    242             if (m_logarithmic) { 
     244            if (_logarithmic) { 
    243245                // logarithmic plots can't handle <= 0.0 
    244246                series.add(xCurrent, (yData > 0.0 ? yData : null)); 
     
    250252        } 
    251253 
    252         m_excitationDataset = new XYSeriesCollection(); 
    253         m_excitationDataset.addSeries(series); 
     254        _excitationDataset = new XYSeriesCollection(); 
     255        _excitationDataset.addSeries(series); 
    254256    } 
    255257 
     
    261263    static class StartStopBaseDraggingUI<V extends JComponent> extends AbstractLayerUI<V> { 
    262264        private static final int CLOSE_ENOUGH = 4; // pizels 
    263         private ChartPanel m_panel; 
    264         private XYPlot m_plot; 
    265         private IStartStopBaseProportionListener m_listener; 
    266         boolean m_draggingStartMarker = false; 
    267         boolean m_draggingStopMarker = false; 
    268         boolean m_draggingBaseMarker = false; 
    269         private double m_startMarkerProportion = 0.25; 
    270         private double m_stopMarkerProportion = 0.75; 
    271         private double m_baseMarkerProportion = 0.25; 
    272         private int m_x0; 
    273         private int m_y0; 
    274         private int m_x1; 
    275         private int m_y1; 
    276         private int m_xStart; 
    277         private int m_xStop; 
    278         private int m_yBase; 
     265        private ChartPanel _panel; 
     266        private XYPlot _plot; 
     267        private IStartStopBaseProportionListener _listener; 
     268        boolean _draggingStartMarker = false; 
     269        boolean _draggingStopMarker = false; 
     270        boolean _draggingBaseMarker = false; 
     271        private double _startMarkerProportion = 0.25; 
     272        private double _stopMarkerProportion = 0.75; 
     273        private double _baseMarkerProportion = 0.25; 
     274        private int _x0; 
     275        private int _y0; 
     276        private int _x1; 
     277        private int _y1; 
     278        private int _xStart; 
     279        private int _xStop; 
     280        private int _yBase; 
    279281 
    280282        /** 
     
    286288         */ 
    287289        StartStopBaseDraggingUI(ChartPanel panel, XYPlot plot, IStartStopBaseProportionListener listener) { 
    288             m_panel    = panel; 
    289             m_plot     = plot; 
    290             m_listener = listener; 
     290            _panel    = panel; 
     291            _plot     = plot; 
     292            _listener = listener; 
    291293        } 
    292294 
     
    299301 
    300302            if (0.1 > width) { 
    301                 m_startMarkerProportion = startValue / maxHorzValue; 
    302                 m_stopMarkerProportion = stopValue / maxHorzValue; 
     303                _startMarkerProportion = startValue / maxHorzValue; 
     304                _stopMarkerProportion = stopValue / maxHorzValue; 
    303305            } 
    304306            else { 
    305307                double minRepresentedValue = horzScreenToValue((int) x); 
    306308                double maxRepresentedValue = horzScreenToValue((int) (x + width)); 
    307                 m_startMarkerProportion = (startValue - minRepresentedValue) / (maxRepresentedValue - minRepresentedValue); 
    308                 m_stopMarkerProportion = (stopValue - minRepresentedValue) / (maxRepresentedValue - minRepresentedValue); 
     309                _startMarkerProportion = (startValue - minRepresentedValue) / (maxRepresentedValue - minRepresentedValue); 
     310                _stopMarkerProportion = (stopValue - minRepresentedValue) / (maxRepresentedValue - minRepresentedValue); 
    309311            } 
    310312 
    311313            if (0.1 > height) { 
    312                 m_baseMarkerProportion = baseValue / maxVertValue; 
     314                _baseMarkerProportion = baseValue / maxVertValue; 
    313315            } 
    314316            else { 
    315317                double minRepresentedValue = vertScreenToValue((int) y); 
    316318                double maxRepresentedValue = vertScreenToValue((int) (y + height)); 
    317                 m_baseMarkerProportion = (baseValue - minRepresentedValue) / (maxRepresentedValue - minRepresentedValue); 
     319                _baseMarkerProportion = (baseValue - minRepresentedValue) / (maxRepresentedValue - minRepresentedValue); 
    318320            } 
    319321        } 
     
    336338            double x = area.getX(); 
    337339            double y = area.getY(); 
    338             m_x0 = (int) area.getX(); 
    339             m_y0 = (int) area.getY(); 
    340             m_x1 = (int) (area.getX() + area.getWidth()); 
    341             m_y1 = (int) (area.getY() + area.getHeight()); 
     340            _x0 = (int) area.getX(); 
     341            _y0 = (int) area.getY(); 
     342            _x1 = (int) (area.getX() + area.getWidth()); 
     343            _y1 = (int) (area.getY() + area.getHeight()); 
    342344            double width = area.getWidth(); 
    343345            double height = area.getHeight(); 
    344             m_xStart = (int) Math.round(x + width * m_startMarkerProportion) + HORZ_TWEAK; 
    345             m_xStop = (int) Math.round(x + width * m_stopMarkerProportion) + HORZ_TWEAK; 
    346             m_yBase = (int) Math.round(y + height * (1 - m_baseMarkerProportion)); 
     346            _xStart = (int) Math.round(x + width * _startMarkerProportion) + HORZ_TWEAK; 
     347            _xStop = (int) Math.round(x + width * _stopMarkerProportion) + HORZ_TWEAK; 
     348            _yBase = (int) Math.round(y + height * (1 - _baseMarkerProportion)); 
    347349 
    348350            // custom painting is here 
    349351            g2.setStroke(new BasicStroke(2f)); 
    350352            g2.setXORMode(XORvalue(START_COLOR)); 
    351             g2.drawLine(m_xStart, m_y0, m_xStart, m_y1); 
     353            g2.drawLine(_xStart, _y0, _xStart, _y1); 
    352354            g2.setXORMode(XORvalue(STOP_COLOR)); 
    353             g2.drawLine(m_xStop, m_y0, m_xStop, m_y1); 
     355            g2.drawLine(_xStop, _y0, _xStop, _y1); 
    354356            g2.setXORMode(XORvalue(BASE_COLOR)); 
    355             g2.drawLine(m_x0, m_yBase, m_x1, m_yBase); 
     357            g2.drawLine(_x0, _yBase, _x1, _yBase); 
    356358        } 
    357359 
     
    365367            super.processMouseMotionEvent(e, l); 
    366368            if (e.getID() == MouseEvent.MOUSE_DRAGGED) { 
    367                 if (m_draggingStartMarker || m_draggingStopMarker) { 
     369                if (_draggingStartMarker || _draggingStopMarker) { 
    368370                    double newProportion = getHorzDraggedProportion(e); 
    369                     if (m_draggingStartMarker) { 
    370                         if (newProportion <= m_stopMarkerProportion) { 
    371                             m_startMarkerProportion = newProportion; 
     371                    if (_draggingStartMarker) { 
     372                        if (newProportion <= _stopMarkerProportion) { 
     373                            _startMarkerProportion = newProportion; 
    372374                        } 
    373375                    } 
    374376                    else { 
    375                         if (newProportion >= m_startMarkerProportion) { 
    376                             m_stopMarkerProportion = newProportion; 
     377                        if (newProportion >= _startMarkerProportion) { 
     378                            _stopMarkerProportion = newProportion; 
    377379                        } 
    378380                    } 
     
    380382                    setDirty(true); 
    381383                } 
    382                 else if (m_draggingBaseMarker) { 
    383                     m_baseMarkerProportion = getVertDraggedProportion(e); 
     384                else if (_draggingBaseMarker) { 
     385                    _baseMarkerProportion = getVertDraggedProportion(e); 
    384386 
    385387                    // mark the ui as dirty and needed to be repainted 
     
    403405         */ 
    404406        private double getHorzDraggedProportion(MouseEvent e) { 
    405             Rectangle2D dataArea = m_panel.getChartRenderingInfo().getPlotInfo().getDataArea(); 
     407            Rectangle2D dataArea = _panel.getChartRenderingInfo().getPlotInfo().getDataArea(); 
    406408            Rectangle2D area = getDataArea(); 
    407409            double proportion = ((double) e.getX() - area.getX()) / area.getWidth(); 
     
    423425         */ 
    424426        private double getVertDraggedProportion(MouseEvent e) { 
    425             Rectangle2D dataArea = m_panel.getChartRenderingInfo().getPlotInfo().getDataArea(); 
     427            Rectangle2D dataArea = _panel.getChartRenderingInfo().getPlotInfo().getDataArea(); 
    426428            Rectangle2D area = getDataArea(); 
    427429            //double proportion = ((double) e.getY() - area.getY()) / area.getHeight(); 
     
    446448                int x = e.getX(); 
    447449                int y = e.getY(); 
    448                 if (y > m_y0 - CLOSE_ENOUGH && y < m_y1 + CLOSE_ENOUGH) { 
    449                     if (Math.abs(x - m_xStart) < CLOSE_ENOUGH) { 
     450                if (y > _y0 - CLOSE_ENOUGH && y < _y1 + CLOSE_ENOUGH) { 
     451                    if (Math.abs(x - _xStart) < CLOSE_ENOUGH) { 
    450452                        // start dragging start line 
    451                         m_draggingStartMarker = true; 
     453                        _draggingStartMarker = true; 
    452454 
    453455                    } 
    454                     else if (Math.abs(x - m_xStop) < CLOSE_ENOUGH) { 
     456                    else if (Math.abs(x - _xStop) < CLOSE_ENOUGH) { 
    455457                        // start dragging stop line 
    456                         m_draggingStopMarker = true; 
     458                        _draggingStopMarker = true; 
    457459                    } 
    458                     else if (Math.abs(y - m_yBase) < CLOSE_ENOUGH) { 
     460                    else if (Math.abs(y - _yBase) < CLOSE_ENOUGH) { 
    459461                        // start dragging base line 
    460                         m_draggingBaseMarker = true; 
     462                        _draggingBaseMarker = true; 
    461463                    } 
    462464                } 
    463465            } 
    464466            if (e.getID() == MouseEvent.MOUSE_RELEASED) { 
    465                 m_draggingStartMarker = m_draggingStopMarker = m_draggingBaseMarker = false; 
     467                _draggingStartMarker = _draggingStopMarker = _draggingBaseMarker = false; 
    466468                SwingUtilities.invokeLater( 
    467469                        new Runnable() { 
    468470                            public void run() { 
    469                                 m_listener.setStartStopBaseProportion(m_startMarkerProportion, m_stopMarkerProportion, m_baseMarkerProportion); 
     471                                _listener.setStartStopBaseProportion(_startMarkerProportion, _stopMarkerProportion, _baseMarkerProportion); 
    470472                            } 
    471473                }); 
     
    479481         */ 
    480482        private Rectangle2D getDataArea() { 
    481             Rectangle2D dataArea = m_panel.getChartRenderingInfo().getPlotInfo().getDataArea(); 
     483            Rectangle2D dataArea = _panel.getChartRenderingInfo().getPlotInfo().getDataArea(); 
    482484            return dataArea; 
    483485        } 
     
    490492         */ 
    491493        private double horzScreenToValue(int x) { 
    492             return m_plot.getDomainAxis().java2DToValue((double) x, getDataArea(), RectangleEdge.TOP); 
     494            return _plot.getDomainAxis().java2DToValue((double) x, getDataArea(), RectangleEdge.TOP); 
    493495        } 
    494496 
     
    500502         */ 
    501503        private double vertScreenToValue(int y) { 
    502             return m_plot.getRangeAxis().java2DToValue((double) y, getDataArea(), RectangleEdge.LEFT); 
    503         } 
    504     } 
     504            return _plot.getRangeAxis().java2DToValue((double) y, getDataArea(), RectangleEdge.LEFT); 
     505        } 
     506    } 
     507     
     508    private class FittingCursorListener implements IFittingCursorListener { 
     509        public void cursorChanged(FittingCursor cursor) { 
     510            int promptStart       = cursor.getPromptStartBin(); 
     511            int promptStop        = cursor.getPromptStopBin(); 
     512            double promptBaseline = cursor.getPromptBaselineValue(); 
     513            //setStartStop(transientStart, dataStart, transientStop); 
     514            _frame.repaint(); 
     515            System.out.println("PROMPT CHANGED " + promptStart + " " + promptStop + " " + promptBaseline); 
     516        } 
     517    }   
    505518} 
    506519 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ui/ExcitationPanel.java

    r7892 r7904  
    6060import javax.swing.border.EmptyBorder; 
    6161 
    62  
    6362import loci.slim.Excitation; 
     63import loci.slim.fitting.cursor.FittingCursor; 
    6464 
    6565/** 
     
    7979    private JTextField m_baseField; 
    8080 
    81     public ExcitationPanel(Excitation excitation) { 
     81    public ExcitationPanel(Excitation excitation, FittingCursor fittingCursor) { 
    8282 
    8383        m_excitation = excitation; 
     
    9292        double timeInc = excitation.getTimeInc(); 
    9393        ExcitationGraph excitationGraph = new ExcitationGraph(start, stop, base, bins, values, timeInc); 
     94        excitationGraph.setFittingCursor(fittingCursor); 
    9495         
    9596        JPanel panel = new JPanel(new BorderLayout()); 
    9697        panel.add("North", createTopPanel()); 
    9798        panel.add("Center", excitationGraph.getComponent()); 
    98         panel.add("South", createBottomPanel()); 
    9999 
    100100        this.getContentPane().add(panel); 
    101101 
    102         this.setSize(450, 450); 
     102        this.setSize(450, 225); 
    103103        this.pack(); 
    104104        this.setVisible(true); 
     
    160160        return panel; 
    161161    } 
    162  
    163     /* 
    164      * Creates a panel with excitation parameters. 
    165      */ 
    166     private JPanel createBottomPanel() { 
    167         JPanel panel = new JPanel(); 
    168         panel.setBorder(new EmptyBorder(0, 0, 8, 8)); 
    169         panel.setLayout(new SpringLayout()); 
    170  
    171         JLabel startLabel = new JLabel("Start"); 
    172         startLabel.setHorizontalAlignment(SwingConstants.RIGHT); 
    173         panel.add(startLabel); 
    174         m_startField = new JTextField(9); 
    175         panel.add(m_startField); 
    176  
    177         JLabel stopLabel = new JLabel("Stop"); 
    178         stopLabel.setHorizontalAlignment(SwingConstants.RIGHT); 
    179         panel.add(stopLabel); 
    180         m_stopField = new JTextField(9); 
    181         panel.add(m_stopField); 
    182  
    183         JLabel baseLabel = new JLabel("Base"); 
    184         baseLabel.setHorizontalAlignment(SwingConstants.RIGHT); 
    185         panel.add(baseLabel); 
    186         m_baseField = new JTextField(9); 
    187         panel.add(m_baseField); 
    188  
    189         // rows, cols, initX, initY, xPad, yPad 
    190         SpringUtilities.makeCompactGrid(panel, 3, 2, 4, 4, 4, 4); 
    191  
    192         JPanel enclosingPanel = new JPanel(); 
    193         enclosingPanel.add(panel); 
    194  
    195         return enclosingPanel; 
    196     } 
    197162} 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ui/IUserInterfacePanel.java

    r7903 r7904  
    4141import loci.curvefitter.ICurveFitter.FitRegion; 
    4242import loci.curvefitter.ICurveFitter.NoiseModel; 
    43 import loci.slim.fitting.cursor.FittingCursor; 
    44 import loci.slim.fitting.cursor.IFittingCursorListener; 
     43import loci.slim.fitting.cursor.FittingCursorHelper; 
    4544 
    4645/** 
     
    5554public interface IUserInterfacePanel { 
    5655     
    57     public void setFittingCursor(FittingCursor fittingCursor); 
     56    /** 
     57     * Sets the fitting cursor helper, which keeps track of prompt and transient 
     58     * start and stop cursors. 
     59     *  
     60     * @param fittingCursorUIHelper  
     61     */ 
     62    public void setFittingCursorHelper(FittingCursorHelper fittingCursorUIHelper); 
    5863 
    5964    /** 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ui/UserInterfacePanel.java

    r7903 r7904  
    4242import java.awt.event.ComponentAdapter; 
    4343import java.awt.event.ComponentEvent; 
     44import java.awt.event.FocusAdapter; 
     45import java.awt.event.FocusEvent; 
     46import java.awt.event.FocusListener; 
    4447import java.awt.event.ItemEvent; 
    4548import java.awt.event.ItemListener; 
     
    5760import javax.swing.JLabel; 
    5861import javax.swing.JPanel; 
     62import javax.swing.JTabbedPane; 
    5963import javax.swing.JTextField; 
    6064import javax.swing.SpringLayout; 
    6165import javax.swing.SwingConstants; 
    6266import javax.swing.border.EmptyBorder; 
     67import javax.swing.event.DocumentEvent; 
     68import javax.swing.event.DocumentListener; 
    6369 
    6470import ij.gui.GenericDialog; 
     
    6874import loci.curvefitter.ICurveFitter.FitRegion; 
    6975import loci.curvefitter.ICurveFitter.NoiseModel; 
    70 import loci.slim.fitting.cursor.FittingCursor; 
    71 import loci.slim.fitting.cursor.IFittingCursorListener; 
    72 import loci.slim.fitting.cursor.ITransientCursorUI; 
     76import loci.slim.fitting.cursor.FittingCursorHelper; 
     77import loci.slim.fitting.cursor.IFittingCursorUI; 
    7378 
    7479/** 
     
    7883 */ 
    7984 
    80 public class UserInterfacePanel implements IUserInterfacePanel, ITransientCursorUI { 
     85public class UserInterfacePanel implements IUserInterfacePanel, IFittingCursorUI { 
    8186    // Unicode special characters 
    8287    private static final Character CHI    = '\u03c7'; 
     
    149154    private static final String EXCITATION_ITEMS[] = { EXCITATION_NONE, EXCITATION_FILE, EXCITATION_CREATE }; 
    150155     
    151     private FittingCursor _fittingCursor; 
    152     private IFittingCursorListener _fittingCursorListener; 
     156    private FittingCursorHelper _fittingCursorHelper; 
    153157     
    154158    public IUserInterfacePanelListener m_listener; 
     
    168172    JCheckBox[] m_analysisCheckBoxList; 
    169173    JCheckBox m_fitAllChannels; 
    170  
     174     
     175    // cursor settings 
     176    JTextField m_transientStartField; 
     177    JTextField m_dataStartField; 
     178    JTextField m_transientStopField; 
     179    JTextField m_promptStartField; 
     180    JTextField m_promptStopField; 
     181    JTextField m_promptBaselineField; 
     182    JComboBox m_promptComboBox; 
     183    JButton m_estimateCursorsButton; 
     184     
    171185    // fit settings 
    172186    JTextField m_xField; 
    173187    JTextField m_yField; 
    174     JTextField m_transStartField; 
    175     JTextField m_dataStartField; 
    176     JTextField m_transStopField; 
    177188    JTextField m_thresholdField; 
    178189    JTextField m_chiSqTargetField; 
    179190    JComboBox m_binningComboBox; 
    180     JComboBox m_excitationComboBox; 
    181191 
    182192    // parameter panel 
     
    242252    String m_fitButtonText = FIT_IMAGE; 
    243253 
    244     public UserInterfacePanel(boolean showTau, String[] analysisChoices, String[] binningChoices) { 
     254    public UserInterfacePanel(boolean tabbed, boolean showTau, 
     255            String[] analysisChoices, String[] binningChoices) 
     256    { 
    245257        String lifetimeLabel = "" + (showTau ? TAU : LAMBDA); 
    246258 
     
    250262        JPanel outerPanel = new JPanel(); 
    251263        outerPanel.setLayout(new BoxLayout(outerPanel, BoxLayout.Y_AXIS)); 
    252  
    253         // create inner panel 
    254         JPanel innerPanel = new JPanel(); 
    255         innerPanel.setLayout(new BoxLayout(innerPanel, BoxLayout.X_AXIS)); 
    256  
    257         JPanel fitPanel = createFitPanel(analysisChoices); 
    258         fitPanel.setBorder(border("Fit")); 
    259         innerPanel.add(fitPanel); 
    260  
    261         JPanel controlPanel = createControlPanel(binningChoices); 
    262         controlPanel.setBorder(border("Control")); 
    263         innerPanel.add(controlPanel); 
    264  
    265         // Create cards and the panel that contains the cards 
    266         m_cardPanel = new JPanel(new CardLayout()); 
    267         m_cardPanel.add(createSingleExponentialPanel(lifetimeLabel), SINGLE_EXPONENTIAL); 
    268         m_cardPanel.add(createDoubleExponentialPanel(lifetimeLabel), DOUBLE_EXPONENTIAL); 
    269         m_cardPanel.add(createTripleExponentialPanel(lifetimeLabel), TRIPLE_EXPONENTIAL); 
    270         m_cardPanel.add(createStretchedExponentialPanel(lifetimeLabel), STRETCHED_EXPONENTIAL); 
    271         m_cardPanel.setBorder(border("Params")); 
    272         innerPanel.add(m_cardPanel); 
    273  
    274         outerPanel.add(innerPanel); 
     264         
     265        if (tabbed) { 
     266            JTabbedPane tabbedPane = new JTabbedPane(); 
     267 
     268            JPanel fitPanel = createFitPanel(analysisChoices); 
     269            tabbedPane.addTab("Fit", fitPanel); 
     270 
     271            JPanel cursorPanel = createCursorPanel(); 
     272            tabbedPane.addTab("Cursors", cursorPanel);  
     273 
     274            JPanel controlPanel = createControlPanel(binningChoices); 
     275            tabbedPane.addTab("Control", controlPanel);    
     276 
     277            // Create cards and the panel that contains the cards 
     278            m_cardPanel = new JPanel(new CardLayout()); 
     279            m_cardPanel.add(createSingleExponentialPanel(lifetimeLabel), SINGLE_EXPONENTIAL); 
     280            m_cardPanel.add(createDoubleExponentialPanel(lifetimeLabel), DOUBLE_EXPONENTIAL); 
     281            m_cardPanel.add(createTripleExponentialPanel(lifetimeLabel), TRIPLE_EXPONENTIAL); 
     282            m_cardPanel.add(createStretchedExponentialPanel(lifetimeLabel), STRETCHED_EXPONENTIAL); 
     283            tabbedPane.addTab("Params", m_cardPanel); 
     284 
     285            outerPanel.add(tabbedPane); 
     286        } 
     287        else { 
     288            // create inner panel 
     289            JPanel innerPanel = new JPanel(); 
     290            innerPanel.setLayout(new BoxLayout(innerPanel, BoxLayout.X_AXIS)); 
     291 
     292            JPanel fitPanel = createFitPanel(analysisChoices); 
     293            fitPanel.setBorder(border("Fit")); 
     294            innerPanel.add(fitPanel); 
     295 
     296            JPanel cursorPanel = createCursorPanel(); 
     297            cursorPanel.setBorder(border("Cursors")); 
     298            innerPanel.add(cursorPanel);  
     299 
     300            JPanel controlPanel = createControlPanel(binningChoices); 
     301            controlPanel.setBorder(border("Control")); 
     302            innerPanel.add(controlPanel); 
     303 
     304            // Create cards and the panel that contains the cards 
     305            m_cardPanel = new JPanel(new CardLayout()); 
     306            m_cardPanel.add(createSingleExponentialPanel(lifetimeLabel), SINGLE_EXPONENTIAL); 
     307            m_cardPanel.add(createDoubleExponentialPanel(lifetimeLabel), DOUBLE_EXPONENTIAL); 
     308            m_cardPanel.add(createTripleExponentialPanel(lifetimeLabel), TRIPLE_EXPONENTIAL); 
     309            m_cardPanel.add(createStretchedExponentialPanel(lifetimeLabel), STRETCHED_EXPONENTIAL); 
     310            m_cardPanel.setBorder(border("Params")); 
     311            innerPanel.add(m_cardPanel); 
     312 
     313            outerPanel.add(innerPanel); 
     314        } 
    275315 
    276316        //Lay out the buttons from left to right. 
     
    333373 
    334374        }); 
    335     } 
    336      
    337     public void setFittingCursor(FittingCursor fittingCursor) { 
    338         if (null == _fittingCursor) { 
    339              
    340             _fittingCursorListener = new FittingCursorListener(); 
    341         } 
    342         else { 
    343             _fittingCursor.removeListener(_fittingCursorListener); 
    344         } 
    345         _fittingCursor = fittingCursor; 
    346         _fittingCursor.addListener(_fittingCursorListener); 
    347     } 
    348  
     375 
     376        // no prompt initially 
     377        enablePromptCursors(false); 
     378    } 
     379 
     380    @Override 
     381    public void setFittingCursorHelper(FittingCursorHelper fittingCursorHelper) { 
     382        _fittingCursorHelper = fittingCursorHelper; 
     383        _fittingCursorHelper.setFittingCursorUI(this); 
     384    } 
     385 
     386    @Override 
    349387    public JFrame getFrame() { 
    350388        return m_frame; 
    351389    } 
    352      
     390 
     391    @Override 
    353392    public void setListener(IUserInterfacePanelListener listener) { 
    354393        m_listener = listener; 
    355394    } 
    356395 
     396    @Override 
    357397    public void reset() { 
    358398        enableAll(true); 
     
    372412        m_regionComboBox.addItemListener( 
    373413            new ItemListener() { 
     414                @Override 
    374415                public void itemStateChanged(ItemEvent e) { 
    375416                    if (e.getStateChange() == ItemEvent.SELECTED) { 
    376417                        String item = (String) e.getItem(); 
    377                         if (SUM_REGION == item) { 
     418                        if (SUM_REGION.equals(item)) { 
    378419                            m_fitButtonText = FIT_SUMMED_PIXELS; 
    379420                        } 
    380                         else if (ROIS_REGION == item) { 
     421                        else if (ROIS_REGION.equals(item)) { 
    381422                            m_fitButtonText = FIT_SUMMED_ROIS; 
    382423                        } 
    383                         else if (PIXEL_REGION == item) { 
     424                        else if (PIXEL_REGION.equals(item)) { 
    384425                            m_fitButtonText = FIT_PIXEL; 
    385426                        } 
    386                         else if (ALL_REGION == item) { 
     427                        else if (ALL_REGION.equals(item)) { 
    387428                            m_fitButtonText = FIT_IMAGE; 
    388429                        } 
     
    498539        comboBox.setSelectedIndex(0); 
    499540    } 
     541     
     542    private JPanel createCursorPanel() { 
     543        JPanel cursorPanel = new JPanel(); 
     544        cursorPanel.setBorder(new EmptyBorder(0, 0, 8, 8)); 
     545        cursorPanel.setLayout(new SpringLayout()); 
     546 
     547        JLabel transStartLabel = new JLabel("Transient Start"); 
     548        transStartLabel.setHorizontalAlignment(SwingConstants.RIGHT); 
     549        cursorPanel.add(transStartLabel); 
     550        m_transientStartField = new JTextField(9); 
     551        m_transientStartField.addActionListener(new ActionListener() { 
     552            public void actionPerformed(ActionEvent e) { 
     553                _fittingCursorHelper.setTransientStart(m_transientStartField.getText()); 
     554            } 
     555        }); 
     556        m_transientStartField.addFocusListener(new FocusAdapter() { 
     557            public void focusLost(FocusEvent e) { 
     558                _fittingCursorHelper.setTransientStart(m_transientStartField.getText()); 
     559            } 
     560        }); 
     561        cursorPanel.add(m_transientStartField); 
     562         
     563        JLabel dataStartLabel = new JLabel("Data Start"); 
     564        dataStartLabel.setHorizontalAlignment(SwingConstants.RIGHT); 
     565        cursorPanel.add(dataStartLabel); 
     566        m_dataStartField = new JTextField(9); 
     567        m_dataStartField.addActionListener(new ActionListener() { 
     568            public void actionPerformed(ActionEvent e) { 
     569                _fittingCursorHelper.setDataStart(m_dataStartField.getText()); 
     570            } 
     571        }); 
     572        m_dataStartField.addFocusListener(new FocusAdapter() { 
     573            public void focusLost(FocusEvent e) { 
     574                _fittingCursorHelper.setDataStart(m_dataStartField.getText()); 
     575            } 
     576        }); 
     577        cursorPanel.add(m_dataStartField); 
     578 
     579        JLabel transStopLabel = new JLabel("Transient End"); 
     580        transStopLabel.setHorizontalAlignment(SwingConstants.RIGHT); 
     581        cursorPanel.add(transStopLabel); 
     582        m_transientStopField = new JTextField(9); 
     583        m_transientStopField.addActionListener(new ActionListener() { 
     584            public void actionPerformed(ActionEvent e) { 
     585                _fittingCursorHelper.setTransientStop(m_transientStopField.getText()); 
     586            } 
     587        }); 
     588        m_transientStopField.addFocusListener(new FocusAdapter() { 
     589            public void focusLost(FocusEvent e) { 
     590                _fittingCursorHelper.setTransientStop(m_transientStopField.getText()); 
     591            } 
     592        }); 
     593        cursorPanel.add(m_transientStopField); 
     594 
     595        JLabel excitationStartLabel = new JLabel("Excitation Delay"); 
     596        excitationStartLabel.setHorizontalAlignment(SwingConstants.RIGHT); 
     597        cursorPanel.add(excitationStartLabel); 
     598        m_promptStartField = new JTextField(9); 
     599        m_promptStartField.addActionListener(new ActionListener() { 
     600            public void actionPerformed(ActionEvent e) { 
     601                _fittingCursorHelper.setPromptStart(m_promptStartField.getText()); 
     602            } 
     603        }); 
     604        m_promptStartField.addFocusListener(new FocusAdapter() { 
     605            public void focusLost(FocusEvent e) { 
     606                _fittingCursorHelper.setPromptStart(m_promptStartField.getText()); 
     607            } 
     608        }); 
     609        cursorPanel.add(m_promptStartField);        
     610         
     611        JLabel excitationStopLabel = new JLabel("Excitation Width"); 
     612        excitationStopLabel.setHorizontalAlignment(SwingConstants.RIGHT); 
     613        cursorPanel.add(excitationStopLabel); 
     614        m_promptStopField = new JTextField(9); 
     615        m_promptStopField.addActionListener(new ActionListener() { 
     616            public void actionPerformed(ActionEvent e) { 
     617                _fittingCursorHelper.setPromptStop(m_promptStopField.getText()); 
     618            } 
     619        }); 
     620        m_promptStopField.addFocusListener(new FocusAdapter() { 
     621            public void focusLost(FocusEvent e) { 
     622                _fittingCursorHelper.setPromptStop(m_promptStopField.getText()); 
     623            } 
     624        }); 
     625        cursorPanel.add(m_promptStopField);            
     626         
     627        JLabel excitationBaselineLabel = new JLabel("Excitation Baseline"); 
     628        excitationBaselineLabel.setHorizontalAlignment(SwingConstants.RIGHT); 
     629        cursorPanel.add(excitationBaselineLabel); 
     630        m_promptBaselineField = new JTextField(9); 
     631        m_promptBaselineField.addActionListener(new ActionListener() { 
     632            public void actionPerformed(ActionEvent e) { 
     633                _fittingCursorHelper.setPromptBaseline(m_promptBaselineField.getText()); 
     634            } 
     635        }); 
     636        m_promptBaselineField.addFocusListener(new FocusAdapter() { 
     637            public void focusLost(FocusEvent e) { 
     638                _fittingCursorHelper.setPromptBaseline(m_promptBaselineField.getText()); 
     639            } 
     640        }); 
     641        cursorPanel.add(m_promptBaselineField);  
     642         
     643        JLabel excitationLabel = new JLabel("Excitation"); 
     644        excitationLabel.setHorizontalAlignment(SwingConstants.RIGHT); 
     645        cursorPanel.add(excitationLabel); 
     646        m_promptComboBox = new JComboBox(EXCITATION_ITEMS); 
     647        m_promptComboBox.addActionListener( 
     648            new ActionListener() { 
     649                public void actionPerformed(ActionEvent e) { 
     650                    String selectedItem = (String) m_promptComboBox.getSelectedItem(); 
     651                    boolean isExcitationLoaded = false; 
     652                    if (EXCITATION_NONE.equals(selectedItem)) { 
     653                        if (null != m_listener) { 
     654                            m_listener.cancelExcitation(); 
     655                        } 
     656                    } 
     657                    else if (EXCITATION_FILE.equals(selectedItem)) { 
     658                        String fileName = getFileName("Load Excitation File", ""); 
     659                        if (null != fileName && null != m_listener) { 
     660                            isExcitationLoaded = m_listener.loadExcitation(fileName); 
     661                        } 
     662                    } 
     663                    else if (EXCITATION_CREATE.equals(selectedItem)) { 
     664                        String fileName = getFileName("Save Excitation File", ""); 
     665                        if (null != fileName && null != m_listener) { 
     666                            isExcitationLoaded = m_listener.createExcitation(fileName); 
     667                        } 
     668                    } 
     669 
     670                    if (isExcitationLoaded) { 
     671                        m_promptComboBox.setSelectedItem(EXCITATION_FILE); 
     672                        enablePromptCursors(true); 
     673                    } 
     674                    else { 
     675                        m_promptComboBox.setSelectedItem(EXCITATION_NONE); 
     676                        String text = _fittingCursorHelper.getShowBins() ? "0" : "0.0"; 
     677                        m_promptStartField.setText(text); 
     678                        m_promptStopField.setText(text); 
     679                        m_promptBaselineField.setText("0.0"); 
     680                        enablePromptCursors(false); 
     681                    } 
     682                } 
     683            } 
     684        ); 
     685        cursorPanel.add(m_promptComboBox); 
     686         
     687        JLabel dummyLabel = new JLabel(""); 
     688        dummyLabel.setHorizontalAlignment(SwingConstants.RIGHT); 
     689        cursorPanel.add(dummyLabel); 
     690        m_estimateCursorsButton = new JButton("Estimate Cursors"); 
     691        cursorPanel.add(m_estimateCursorsButton); 
     692 
     693        // rows, cols, initX, initY, xPad, yPad 
     694        SpringUtilities.makeCompactGrid(cursorPanel, 8, 2, 4, 4, 4, 4); 
     695 
     696        JPanel panel = new JPanel(new BorderLayout()); 
     697        panel.add("North", cursorPanel); 
     698 
     699        return panel; 
     700    } 
    500701 
    501702    /* 
     
    519720        controlPanel.add(m_yField); 
    520721 
    521         JLabel transStartLabel = new JLabel("Transient Start"); 
     722  /*      JLabel transStartLabel = new JLabel("Transient Start"); 
    522723        transStartLabel.setHorizontalAlignment(SwingConstants.RIGHT); 
    523724        controlPanel.add(transStartLabel); 
    524         m_transStartField = new JTextField(9); 
    525         controlPanel.add(m_transStartField); 
     725        m_transientStartField = new JTextField(9); 
     726        m_transientStartField.addActionListener(new ActionListener() { 
     727            public void actionPerformed(ActionEvent e) { 
     728                _fittingCursor.setTransientStart(m_transientStartField.getText()); 
     729            } 
     730        }); 
     731        m_transientStartField.addFocusListener(new FocusAdapter() { 
     732            public void focusLost(FocusEvent e) { 
     733                _fittingCursor.setTransientStart(m_transientStartField.getText()); 
     734            } 
     735        }); 
     736        controlPanel.add(m_transientStartField); 
    526737         
    527738        JLabel dataStartLabel = new JLabel("Data Start"); 
     
    529740        controlPanel.add(dataStartLabel); 
    530741        m_dataStartField = new JTextField(9); 
     742        m_dataStartField.addActionListener(new ActionListener() { 
     743            public void actionPerformed(ActionEvent e) { 
     744                _fittingCursor.setDataStart(m_dataStartField.getText()); 
     745            } 
     746        }); 
     747        m_dataStartField.addFocusListener(new FocusAdapter() { 
     748            public void focusLost(FocusEvent e) { 
     749                _fittingCursor.setDataStart(m_dataStartField.getText()); 
     750            } 
     751        }); 
    531752        controlPanel.add(m_dataStartField); 
    532753 
     
    534755        transStopLabel.setHorizontalAlignment(SwingConstants.RIGHT); 
    535756        controlPanel.add(transStopLabel); 
    536         m_transStopField = new JTextField(9); 
    537         controlPanel.add(m_transStopField); 
     757        m_transientStopField = new JTextField(9); 
     758        m_transientStopField.addActionListener(new ActionListener() { 
     759            public void actionPerformed(ActionEvent e) { 
     760                _fittingCursor.setTransientStop(m_transientStopField.getText()); 
     761            } 
     762        }); 
     763        m_transientStopField.addFocusListener(new FocusAdapter() { 
     764            public void focusLost(FocusEvent e) { 
     765                _fittingCursor.setTransientStop(m_transientStopField.getText()); 
     766            } 
     767        }); 
     768        controlPanel.add(m_transientStopField);*/ 
    538769 
    539770        JLabel thresholdLabel = new JLabel("Threshold"); 
     
    555786        controlPanel.add(m_binningComboBox); 
    556787 
    557         JLabel excitationLabel = new JLabel("Excitation"); 
     788     /*   JLabel excitationLabel = new JLabel("Excitation"); 
    558789        excitationLabel.setHorizontalAlignment(SwingConstants.RIGHT); 
    559790        controlPanel.add(excitationLabel); 
     
    591822            } 
    592823        ); 
    593         controlPanel.add(m_excitationComboBox); 
     824        controlPanel.add(m_excitationComboBox); */ 
    594825 
    595826        // rows, cols, initX, initY, xPad, yPad 
    596         SpringUtilities.makeCompactGrid(controlPanel, 9, 2, 4, 4, 4, 4); 
     827        SpringUtilities.makeCompactGrid(controlPanel, 5, 2, 4, 4, 4, 4); 
    597828 
    598829        JPanel panel = new JPanel(new BorderLayout()); 
     
    9861217            checkBox.setEnabled(enable); 
    9871218        } 
    988         //m_analysisComboBox.setEnabled(enable); 
    9891219        m_fitAllChannels.setEnabled(enable); 
     1220         
     1221        // cursors settings 
     1222        m_transientStartField.setEditable(enable); 
     1223        m_dataStartField.setEditable(enable); 
     1224        m_transientStopField.setEditable(enable); 
     1225        boolean promptEnable = enable; 
     1226        if (enable) { 
     1227            promptEnable = m_promptComboBox.getSelectedIndex() == 0; 
     1228        } 
     1229        enablePromptCursors(promptEnable); 
     1230        m_promptComboBox.setEnabled(enable); 
    9901231 
    9911232        // fit control settings 
    9921233        m_xField.setEditable(enable); 
    9931234        m_yField.setEditable(enable); 
    994         m_transStartField.setEditable(enable); 
    995         m_transStopField.setEditable(enable); 
    9961235        m_thresholdField.setEditable(enable); 
    9971236        m_chiSqTargetField.setEditable(enable); 
     
    11841423    public void setY(int y) { 
    11851424        m_yField.setText("" + y); 
    1186     } 
    1187  
    1188     public void setStart(int start) { 
    1189         m_transStartField.setText("" + start); 
    1190     } 
    1191  
    1192     public int getStop() { 
    1193         return parseInt(m_transStopField); 
    1194     } 
    1195  
    1196     public void setStop(int stop) { 
    1197         m_transStopField.setText("" + stop); 
    11981425    } 
    11991426 
     
    14121639     */ 
    14131640    public String getTransientStart() { 
    1414         return m_transStartField.getText();   
     1641        return m_transientStartField.getText();   
    14151642    } 
    14161643   
     
    14211648     */ 
    14221649    public void setTransientStart(String transientStart) { 
    1423         m_transStartField.setText(transientStart); 
     1650        m_transientStartField.setText(transientStart); 
    14241651    } 
    14251652     
     
    14461673     */ 
    14471674    public String getTransientStop() { 
    1448         return m_transStopField.getText(); 
     1675        return m_transientStopField.getText(); 
    14491676    } 
    14501677 
     
    14551682     */ 
    14561683    public void setTransientStop(String transientStop) { 
    1457         m_transStopField.setText(transientStop); 
     1684        m_transientStopField.setText(transientStop); 
     1685    } 
     1686 
     1687    /** 
     1688     * Gets the excitation start cursor. 
     1689     *  
     1690     * @return  
     1691     */ 
     1692    public String getPromptStart() { 
     1693        return m_promptStartField.getText(); 
     1694    } 
     1695 
     1696    /** 
     1697     * Sets the excitation start cursor. 
     1698     *  
     1699     * @param promptStart  
     1700     */ 
     1701    public void setPromptStart(String promptStart) { 
     1702        m_promptStartField.setText(promptStart); 
     1703    } 
     1704 
     1705    /** 
     1706     * Gets the excitation end cursor. 
     1707     * @return  
     1708     */ 
     1709    public String getPromptStop() { 
     1710        return m_promptStopField.getText(); 
     1711    } 
     1712 
     1713    /** 
     1714     * Sets the excitation end cursor. 
     1715     *  
     1716     * @param promptStop  
     1717     */ 
     1718    public void setPromptStop(String promptStop) { 
     1719        m_promptStopField.setText(promptStop); 
     1720    } 
     1721 
     1722    /** 
     1723     * Gets the excitation baseline. 
     1724     *  
     1725     * @return  
     1726     */ 
     1727    public String getPromptBaseline() { 
     1728        return m_promptBaselineField.getText(); 
     1729    } 
     1730 
     1731    /** 
     1732     * Sets the excitation baseline. 
     1733     *  
     1734     * @param promptBaseline  
     1735     */ 
     1736    public void setPromptBaseline(String promptBaseline) { 
     1737        m_promptBaselineField.setText(promptBaseline); 
    14581738    } 
    14591739 
     
    14691749    } 
    14701750 
     1751    /** 
     1752     * Gray out the prompt cursors if no prompt is loaded. 
     1753     *  
     1754     * @param enable  
     1755     */ 
     1756    private void enablePromptCursors(boolean enable) { 
     1757        m_promptStartField.setEditable(enable); 
     1758        m_promptStopField.setEditable(enable); 
     1759        m_promptBaselineField.setEditable(enable); 
     1760    } 
     1761     
    14711762    /** 
    14721763     * This decides whether the existing parameters could be used as the 
     
    14931784        return dialog.getNextString(); 
    14941785    } 
    1495      
    1496     private class FittingCursorListener implements IFittingCursorListener { 
    1497         public void cursorChanged(FittingCursor cursor) { 
    1498             if (cursor.getShowBins()) { 
    1499                 int transStart = cursor.getTransientStartBin(); 
    1500                 int dataStart  = cursor.getDataStartBin(); 
    1501                 int transStop  = cursor.getTransientStopBin(); 
    1502                 setTransientStart("" + transStart); 
    1503                 setDataStart     ("" + dataStart); 
    1504                 setTransientStop ("" + transStop); 
    1505             } 
    1506             else { 
    1507                 double transStart = cursor.getTransientStartValue(); 
    1508                 double dataStart  = cursor.getDataStartValue(); 
    1509                 double transStop  = cursor.getTransientStopValue(); 
    1510                 setTransientStart("" + transStart); 
    1511                 setDataStart     ("" + dataStart); 
    1512                 setTransientStop ("" + transStop); 
    1513             } 
    1514         } 
    1515     } 
    15161786} 
Note: See TracChangeset for help on using the changeset viewer.