Changeset 7915


Ignore:
Timestamp:
03/06/12 15:23:36 (7 years ago)
Author:
aivar
Message:

SLIM Plugin: Working on double/int cursor discrepancies.

Location:
trunk/projects/slim-plugin/src/main/java/loci/slim
Files:
8 edited

Legend:

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

    r7910 r7915  
    284284         
    285285        // show the UI; do fits 
    286         final IUserInterfacePanel uiPanel = new UserInterfacePanel(TABBED, 
    287                 USE_TAU, m_analysis.getChoices(), m_binning.getChoices()); 
    288286        FittingCursorHelper fittingCursorHelper = new FittingCursorHelper(); 
    289287        fittingCursorHelper.setFittingCursor(_fittingCursor); 
    290         uiPanel.setFittingCursorHelper(fittingCursorHelper); 
     288        final IUserInterfacePanel uiPanel = new UserInterfacePanel(TABBED, 
     289                USE_TAU, m_analysis.getChoices(), m_binning.getChoices(), 
     290                fittingCursorHelper); 
    291291        uiPanel.setX(0); 
    292292        uiPanel.setY(0); 
     
    512512 
    513513            double[] results = CursorHelper.estimateCursors(m_timeRange, excitation.getValues(), decay); 
     514             
    514515            // want all the fitting cursor listeners to get everything at once 
    515516            _fittingCursor.suspendNotifications(true); 
     
    773774        FitInfo fitInfo = getFitInfo(m_grayScaleImage, uiPanel, _fittingCursor); 
    774775        fitInfo.setXInc(m_timeRange); 
    775         if (null != m_excitationPanel) { 
    776             fitInfo.setPrompt(m_excitationPanel.getValues(1)); 
    777             fitInfo.setStartPrompt(0); 
    778             fitInfo.setStopPrompt(100); 
     776        if (_fittingCursor.getHasPrompt() && null != m_excitationPanel) { 
     777            double start = _fittingCursor.getPromptStartValue(); 
     778            double stop  = _fittingCursor.getPromptStopValue(); 
     779            double base  = _fittingCursor.getPromptBaselineValue(); 
     780            double[] values = m_excitationPanel.getValues(start, stop, base); 
     781            fitInfo.setPrompt(values); 
    779782        } 
    780783        fitInfo.setIndexColorModel(HistogramTool.getIndexColorModel()); 
     
    10461049             
    10471050            // for TRI2 compatibility: 
    1048             if (FitAlgorithm.SLIMCURVE_RLD_LMA.equals(uiPanel.getFunction())) { 
     1051            if (FitAlgorithm.SLIMCURVE_RLD_LMA.equals(uiPanel.getFunction())) { //TODO ARG UGLY 
    10491052                // these lines give TRI2 compatible fit results 
    10501053                int estimateStartIndex = 
     
    10701073        // show decay and update UI parameters 
    10711074        int visibleChannel = m_fitAllChannels ? m_channel : 0; 
    1072         double[] irf = null; 
    1073         if (null != m_excitationPanel) { 
    1074             // get the IRF curve scaled for total number of fitted pixels 
    1075             irf = m_excitationPanel.getValues(dataArray[visibleChannel].getPixels()); 
    1076         } 
    10771075        String title = "Summed"; 
    10781076        if (1 < m_channels) { 
    10791077            title += " Channel " + (m_channel + 1); 
    10801078        } 
    1081         showDecayGraph(title, uiPanel, _fittingCursor, irf, dataArray[visibleChannel]); 
     1079        showDecayGraph(title, uiPanel, _fittingCursor, dataArray[visibleChannel]); 
    10821080        uiPanel.setParameters(dataArray[visibleChannel].getParams()); 
    10831081 
     
    11671165            int dataIndex = nominalChannel * getRois().length + (roiNumber - 1); 
    11681166 
    1169             double[] irf = null; 
    1170             if (null != m_excitationPanel) { 
    1171                 // get the IRF curve scaled for number of pixels in this ROI 
    1172                 irf = m_excitationPanel.getValues(dataArray[dataIndex].getPixels()); 
    1173             } 
    11741167            String title = "Roi " + roiNumber; 
    11751168            if (1 < m_channels) { 
    11761169                title += " Channel " + (m_channel + 1); 
    11771170            } 
    1178             showDecayGraph(title, uiPanel, _fittingCursor, irf, dataArray[dataIndex]); 
     1171            showDecayGraph(title, uiPanel, _fittingCursor, dataArray[dataIndex]); 
    11791172            double lifetime = dataArray[dataIndex].getParams()[3]; 
    11801173            if (lifetime < min) { 
     
    12981291 
    12991292        // show decay graph for visible channel 
    1300         double irf[] = null; 
    1301         if (null != m_excitationPanel) { 
    1302             // get the IRF curve scaled for a single pixel 
    1303             irf = m_excitationPanel.getValues(1); 
    1304         } 
    13051293        String title = "Pixel " + x + " " + y; 
    13061294        if (1 < m_channels) { 
     
    13111299            visibleChannel = m_channel; 
    13121300        } 
    1313         showDecayGraph(title, uiPanel, _fittingCursor, irf, dataArray[visibleChannel]); 
     1301        showDecayGraph(title, uiPanel, _fittingCursor, dataArray[visibleChannel]); 
    13141302 
    13151303        // update UI parameters 
     
    17771765        curveFitter.setFree(translateFree(uiPanel.getFunction(), uiPanel.getFree())); 
    17781766        if (null != m_excitationPanel) { 
    1779             // get the raw, unscaled IRF curve (will get scaled for number of pixels later) 
    1780             curveFitter.setInstrumentResponse(m_excitationPanel.getValues(1)); 
     1767            double[] excitation = null; 
     1768            if (null != m_excitationPanel) { 
     1769                double start = _fittingCursor.getPromptStartValue(); 
     1770                double stop  = _fittingCursor.getPromptStopValue(); 
     1771                double base  = _fittingCursor.getPromptBaselineValue(); 
     1772                excitation = m_excitationPanel.getValues(start, stop, base); 
     1773            }             
     1774            curveFitter.setInstrumentResponse(excitation); 
    17811775        } 
    17821776        return curveFitter; 
     
    18391833            final IUserInterfacePanel uiPanel, 
    18401834            final FittingCursor fittingCursor, 
    1841             final double irf[], 
    18421835            final ICurveFitData data) 
    18431836    { 
     
    18501843        int transientStop  = fittingCursor.getTransientStopBin(); 
    18511844        decayGraph.setStartStop(transientStart, dataStart, transientStop); 
    1852         decayGraph.setData(irf, data); 
     1845        decayGraph.setData(data); 
    18531846    } 
    18541847     
  • trunk/projects/slim-plugin/src/main/java/loci/slim/fitting/cursor/FittingCursor.java

    r7910 r7915  
    4747 */ 
    4848public class FittingCursor { 
     49    private static final String DOUBLE_ZERO_STRING = "0.0"; 
     50    private static final String INTEGER_ZERO_STRING = "0"; 
    4951    private double _inc; 
    5052    private int _bins; 
     
    5254    private boolean _showBins; 
    5355    private volatile boolean _suspend; 
     56    private boolean _hasPrompt; 
    5457    private double _promptStartValue; 
    5558    private double _promptStopValue; 
     
    7073        _listeners = Collections.synchronizedSet(new HashSet<IFittingCursorListener>()); 
    7174        _showBins = false; 
     75        _suspend = false; 
     76        _hasPrompt = false; 
    7277    } 
    7378 
     
    107112        return _showBins; 
    108113    } 
    109      
     114 
     115    /** 
     116     * Used to turn on/off listener notifications.  Mainly if several cursor 
     117     * settings need to be changed in one batch, turn off listener notifications, 
     118     * make all but one cursor settings change, then turn on listener  
     119     * notifications and make the last cursor settings change. 
     120     *  
     121     * @param suspend  
     122     */ 
    110123    public void suspendNotifications(boolean suspend) { 
    111124        _suspend = suspend; 
     125    } 
     126 
     127    /** 
     128     * Returns whether or not a prompt has been loaded. 
     129     *  
     130     * @param hasPrompt  
     131     */ 
     132    public void setHasPrompt(boolean hasPrompt) { 
     133        _hasPrompt = hasPrompt; 
     134    } 
     135 
     136    /** 
     137     * Sets whether or not a prompt has been loaded. 
     138     *  
     139     * @return  
     140     */ 
     141    public boolean getHasPrompt() { 
     142        return _hasPrompt; 
    112143    } 
    113144 
     
    152183        StringBuffer returnValue = new StringBuffer(); 
    153184        if (_showBins) { 
    154             int delay = getPromptStartBin() - getTransientStartBin(); 
    155             returnValue.append(delay); 
    156         } 
    157         else { 
    158             double delay = getPromptStartValue() - getTransientStartValue(); 
    159             returnValue.append(delay); 
     185            if (_hasPrompt) { 
     186                int delay = getPromptStartBin() - getTransientStartBin(); 
     187                returnValue.append(delay); 
     188            } 
     189            else { 
     190                returnValue.append(INTEGER_ZERO_STRING); 
     191            } 
     192        } 
     193        else { 
     194            if (_hasPrompt) { 
     195                double delay = getPromptStartValue() - getTransientStartValue(); 
     196                returnValue.append(delay); 
     197            } 
     198            else { 
     199                returnValue.append(DOUBLE_ZERO_STRING); 
     200            } 
    160201        } 
    161202        return returnValue.toString(); 
     
    238279        StringBuffer returnValue = new StringBuffer(); 
    239280        if (_showBins) { 
    240             int width = getPromptStopBin() - getPromptStartBin(); 
    241             returnValue.append(width); 
    242         } 
    243         else { 
    244             double width = getPromptStopValue() - getPromptStartValue(); 
    245             returnValue.append(width); 
     281            if (_hasPrompt) { 
     282                int width = getPromptStopBin() - getPromptStartBin(); 
     283                returnValue.append(width); 
     284            } 
     285            else { 
     286                returnValue.append(INTEGER_ZERO_STRING); 
     287            } 
     288        } 
     289        else { 
     290            if (_hasPrompt) { 
     291                double width = getPromptStopValue() - getPromptStartValue(); 
     292                returnValue.append(width); 
     293            } 
     294            else { 
     295                returnValue.append(DOUBLE_ZERO_STRING); 
     296            } 
    246297        } 
    247298        return returnValue.toString(); 
     
    307358    public String getPromptBaseline() { 
    308359        StringBuffer returnValue = new StringBuffer(); 
    309         returnValue.append(getPromptBaselineValue()); 
     360        if (_hasPrompt) { 
     361            returnValue.append(getPromptBaselineValue()); 
     362        } 
     363        else { 
     364            returnValue.append(DOUBLE_ZERO_STRING); 
     365        } 
    310366        return returnValue.toString(); 
    311367    } 
     
    618674        } 
    619675    } 
     676     
     677  
     678    //TODO ARG 
     679    // These two methods support round-tripping from int -> double ->int and 
     680    // double -> int -> double. 
     681    // 
     682    private static int doubleToInt(boolean low, double inc, double value) { 
     683        int returnValue = 0; 
     684        if (low) { 
     685            returnValue = (int) Math.floor(value / inc); 
     686        } 
     687        else { 
     688            returnValue = (int) Math.ceil(value / inc) + 1; 
     689        } 
     690        return returnValue; 
     691    } 
     692     
     693    private static double intToDouble(boolean low, double inc, int value) { 
     694        double returnValue = 0.0; 
     695        if (low) { 
     696            returnValue = inc * value + inc / 8192; 
     697        } 
     698        else { 
     699            returnValue = inc * (value - 1) - inc / 8192; 
     700        } 
     701        return returnValue; 
     702    } 
     703     
     704    private static double randomDouble(java.util.Random random, int range) { 
     705        return random.nextDouble() * range; 
     706    } 
     707     
     708    public static void main(String [] args) 
     709    { 
     710        int lowProbs = 0, highProbs = 0; 
     711        java.util.Random random = new java.util.Random(); 
     712        for (int i = 0; i < 300000; ++i) { 
     713            double d = randomDouble(random, 10); // random 0.0...10.0 
     714            int fred = doubleToInt(true, 0.01, d); 
     715            double wilma = intToDouble(true, 0.01, fred); 
     716            int barney = doubleToInt(true, 0.01, wilma); 
     717            if (fred != barney) { 
     718                System.out.println("random is " + d + " to int low is " + fred + " back to double " + wilma + " to int " + barney); 
     719                ++lowProbs; 
     720            } 
     721            if (d / wilma > 1.05 || d / wilma < 0.95) { 
     722                System.out.println("d is " + d + " and wilma " + wilma); 
     723                ++lowProbs; 
     724            } 
     725            fred = doubleToInt(false, 0.01, d); 
     726            wilma = intToDouble(false, 0.01, fred); 
     727            barney = doubleToInt(false, 0.01, wilma); 
     728            if (fred != barney) { 
     729                System.out.println("random is " + d + " to int high is " + fred + " back to double " + wilma + " to int " + barney); 
     730                ++highProbs; 
     731            } 
     732            if (d / wilma > 1.05 || d / wilma < 0.95) { 
     733                System.out.println("d is " + d + " and wilma is " + wilma); 
     734                ++highProbs; 
     735            } 
     736           // System.out.println("random " + d + " to int high " + fred + " back to double " + wilma + " to int low " + barney); 
     737        } 
     738        System.out.println(" " + lowProbs + " low, " + highProbs + " high oout of 30000"); 
     739        System.exit(0); 
     740    } 
     741     
    620742} 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/fitting/cursor/FittingCursorHelper.java

    r7910 r7915  
    5252        return _fittingCursor.getShowBins(); 
    5353    } 
     54 
     55    /** 
     56     * Turns on/off prompt cursors. 
     57     *  
     58     * @param enable  
     59     */ 
     60    public void enablePrompt(boolean enable) { 
     61        _fittingCursor.setHasPrompt(enable); 
     62    } 
    5463     
    5564    /** 
     
    192201        @Override 
    193202        public void cursorChanged(FittingCursor cursor) { 
     203            System.out.println("FittingCursorHelper.cursorChanged"); 
    194204            showFittingCursor(); 
    195205        } 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ui/DecayGraph.java

    r7910 r7915  
    7777    static final String UNITS_LABEL = "nanoseconds"; 
    7878    static final String RESIDUAL_AXIS_LABEL = "Residual"; 
     79    static final int DECAY_WEIGHT = 4; 
     80    static final int RESIDUAL_WEIGHT = 1; 
    7981    static final int HORZ_TWEAK = 4; 
    80     static final Color IRF_COLOR = Color.GRAY; 
    8182    static final Color DECAY_COLOR = Color.GRAY.darker(); 
    8283    static final Color FITTED_COLOR = Color.RED; 
     
    210211     * @param data 
    211212     */ 
    212     public void setData(final double[] irf, ICurveFitData data) { 
    213         createDatasets(10, 200, _bins, _timeInc, irf, data); 
     213    public void setData(ICurveFitData data) { 
     214        createDatasets(10, 200, _bins, _timeInc, data); 
    214215 
    215216    } 
     
    301302        XYSplineRenderer decayRenderer = new XYSplineRenderer(); 
    302303        decayRenderer.setSeriesShapesVisible(0, false); 
    303         decayRenderer.setSeriesShapesVisible(1, false); 
    304         decayRenderer.setSeriesLinesVisible(2, false); 
     304        decayRenderer.setSeriesLinesVisible(1, false); 
    305305        decayRenderer.setSeriesShape 
    306                 (2, new Ellipse2D.Float(-1.0f, -1.0f, 2.0f, 2.0f)); 
    307  
    308         decayRenderer.setSeriesPaint(0, IRF_COLOR); 
    309         decayRenderer.setSeriesPaint(1, FITTED_COLOR); 
    310         decayRenderer.setSeriesPaint(2, DECAY_COLOR); 
     306                (1, new Ellipse2D.Float(-1.0f, -1.0f, 2.0f, 2.0f)); 
     307 
     308        decayRenderer.setSeriesPaint(0, FITTED_COLOR); 
     309        decayRenderer.setSeriesPaint(1, DECAY_COLOR); 
    311310 
    312311        _decaySubPlot = new XYPlot 
     
    316315 
    317316        // add decay sub-plot to parent 
    318         parent.add(_decaySubPlot, 4); 
     317        parent.add(_decaySubPlot, DECAY_WEIGHT); 
    319318 
    320319        // create residual sub-plot 
    321320        NumberAxis residualAxis = new NumberAxis(RESIDUAL_AXIS_LABEL); 
    322321        XYSplineRenderer residualRenderer = new XYSplineRenderer(); 
    323         //residualRenderer.setSeriesShapesVisible(0, false); 
    324322        residualRenderer.setSeriesPaint(0, RESIDUAL_COLOR); 
    325         //residualRenderer.setSeriesLinesVisible(0, false); 
    326323        residualRenderer.setSeriesShape 
    327324                (0, new Ellipse2D.Float(-1.0f, -1.0f, 2.0f, 2.0f)); 
    328          
    329          
    330          
    331          
    332325         
    333326        XYPlot residualSubPlot = new XYPlot 
     
    338331 
    339332        // add residual sub-plot to parent 
    340         parent.add(residualSubPlot, 1); 
     333        parent.add(residualSubPlot, RESIDUAL_WEIGHT); 
    341334 
    342335        // now make the top level JFreeChart 
     
    358351     */ 
    359352    private void createDatasets(int start, int stop, int bins, double timeInc, 
    360             double[] irf, ICurveFitData data) 
     353            ICurveFitData data) 
    361354    { 
    362         XYSeries series1 = new XYSeries("IRF"); 
    363         double xCurrent = 0; 
    364         if (null != irf) { 
    365             for (int i = 0; i < bins; ++i) { 
    366                 // logarithmic plots can't handle <= 0 
    367                 if (irf[i] > 0.0) { 
    368                     series1.add(xCurrent, irf[i]); 
    369                 } 
    370                 else { 
    371                     series1.add(xCurrent, null); 
    372                 } 
    373                 xCurrent += timeInc; 
    374             } 
    375         } 
    376  
    377355        XYSeries series2 = new XYSeries("Fitted"); 
    378356        XYSeries series3 = new XYSeries("Data"); 
     
    380358 
    381359        double yData, yFitted; 
    382         xCurrent = 0; 
     360        double xCurrent = 0; 
    383361        for (int i = 0; i < bins; ++i) { 
    384362            yData = data.getYCount()[i]; 
     
    407385 
    408386        _decayDataset.removeAllSeries(); 
    409         _decayDataset.addSeries(series1); 
    410387        _decayDataset.addSeries(series2); 
    411388        _decayDataset.addSeries(series3); 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ui/ExcitationPanel.java

    r7910 r7915  
    7373 */ 
    7474public class ExcitationPanel extends JFrame { 
    75     private Excitation m_excitation; 
     75    private Excitation _excitation; 
     76    private int _bins; 
     77    private double _timeInc; 
    7678 
    7779    public ExcitationPanel(Excitation excitation, FittingCursor fittingCursor) { 
    7880 
    79         m_excitation = excitation; 
     81        _excitation = excitation; 
    8082 
    8183        this.setTitle("Instrument Response Function"); 
     
    8587        double base = fittingCursor.getPromptBaselineValue(); 
    8688 
    87         //int start = excitation.getStart(); 
    88         //int stop = excitation.getStop(); 
    89         //double base = excitation.getBase(); 
    9089        double[] values = excitation.getValues(); 
    91         int bins = values.length; 
    92         double timeInc = excitation.getTimeInc(); 
    93         ExcitationGraph excitationGraph = new ExcitationGraph(start, stop, base, bins, values, timeInc); 
     90        _bins = values.length; 
     91        _timeInc = excitation.getTimeInc(); 
     92        ExcitationGraph excitationGraph = new ExcitationGraph(start, stop, base, 
     93                _bins, values, _timeInc); 
    9494        excitationGraph.setFittingCursor(fittingCursor); 
    9595         
     
    103103        this.pack(); 
    104104        this.setVisible(true); 
    105         // load the excitation curve 
    106         // fit default cursors 
    107         // show excitation graph 
    108         // show additional UI 
    109105    } 
    110106     
     
    113109    } 
    114110 
    115     public double[] getValues(int pixels) { 
    116         double inValues[] = m_excitation.getValues(); 
    117         for (double fV : inValues) { 
    118             System.out.print(" " + fV); 
     111    /** 
     112     * This is based on TRCursors.c UpdatePrompt in TRI2. 
     113     *  
     114     * @param start 
     115     * @param stop 
     116     * @return  
     117     */ 
     118    public double[] getValues(double start, double stop, double base) { 
     119        int startIndex = (int) Math.ceil(start / _timeInc); 
     120        if (startIndex < 0) { 
     121            startIndex = 0; 
    119122        } 
    120         System.out.println(""); 
    121         System.out.println("start " + m_excitation.getStart() + " stop " + m_excitation.getStop() + " base " + m_excitation.getBase()); 
    122  
    123         int start = m_excitation.getStart(); 
    124         int stop = m_excitation.getStop(); 
    125         double base = m_excitation.getBase(); 
    126         double[] values = new double[inValues.length]; 
    127         for (int i = 0; i < values.length; ++i) { 
    128             if (i < start || i > stop) { 
    129                 values[i] = 0.0; 
    130             } 
    131             else if (inValues[i] > base) { 
    132                 values[i] = pixels * inValues[i]; 
    133                 System.out.println("pixels " + pixels + "  value " + values[i]); 
    134             } 
    135             else { 
    136                 values[i] = 0.0; 
    137             } 
     123        int stopIndex = (int) Math.floor(stop / _timeInc) + 1; 
     124        if (stopIndex > _bins) { 
     125            stopIndex = _bins; 
    138126        } 
    139         System.out.println(""); 
     127         
     128        if (stopIndex <= startIndex) { 
     129            return null; 
     130        } 
     131         
     132        double inValues[] = _excitation.getValues(); 
     133        double scaling = 0.0; 
     134        for (int i = startIndex; i < stopIndex; ++i) { 
     135            scaling += inValues[i]; 
     136        } 
     137         
     138        if (0.0 == scaling) { 
     139            return null; 
     140        } 
     141  
     142        double[] values = new double[stopIndex - startIndex]; 
     143        int j = 0; 
     144        for (int i = startIndex; i < stopIndex; ++i) { 
     145            values[j++] = (inValues[i] - base) / scaling; 
     146        }     
    140147        return values; 
    141148    } 
     
    153160        //panel.add(fileLabel); 
    154161 
    155         panel.add(new JLabel(m_excitation.getFileName())); 
     162        panel.add(new JLabel(_excitation.getFileName())); 
    156163 
    157164        // rows, cols, initX, initY, xPad, yPad 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ui/IDecayGraph.java

    r7903 r7915  
    7272     * @param data 
    7373     */ 
    74     public void setData(final double[] irf, ICurveFitData data); 
     74    public void setData(ICurveFitData data); 
    7575     
    7676    /** 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ui/IUserInterfacePanel.java

    r7904 r7915  
    5353 */ 
    5454public interface IUserInterfacePanel { 
    55      
    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); 
    6355 
    6456    /** 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ui/UserInterfacePanel.java

    r7910 r7915  
    253253 
    254254    public UserInterfacePanel(boolean tabbed, boolean showTau, 
    255             String[] analysisChoices, String[] binningChoices) 
     255            String[] analysisChoices, String[] binningChoices, 
     256            FittingCursorHelper fittingCursorHelper) 
    256257    { 
    257258        String lifetimeLabel = "" + (showTau ? TAU : LAMBDA); 
    258  
     259         
     260        _fittingCursorHelper = fittingCursorHelper; 
     261         
    259262        m_frame = new JFrame("SLIM Plugin"); 
    260263 
     
    376379        // no prompt initially 
    377380        enablePromptCursors(false); 
    378     } 
    379  
    380     @Override 
    381     public void setFittingCursorHelper(FittingCursorHelper fittingCursorHelper) { 
    382         _fittingCursorHelper = fittingCursorHelper; 
     381 
     382        // show initial cursors 
    383383        _fittingCursorHelper.setFittingCursorUI(this); 
    384384    } 
     
    17561756     */ 
    17571757    private void enablePromptCursors(boolean enable) { 
     1758        _fittingCursorHelper.enablePrompt(enable); 
     1759         
    17581760        m_promptDelayField.setEditable(enable); 
    17591761        m_promptWidthField.setEditable(enable); 
Note: See TracChangeset for help on using the changeset viewer.