eu.hansolo.steelseries.tools.Data Maven / Gradle / Ivy

Go to download
package eu.hansolo.steelseries.tools;


/**
 *
 * @author Gerrit Grunwald 
 */
public class Data implements DataModel
{
    // 
    private javax.swing.event.ChangeEvent changeEvent;
    private final javax.swing.event.EventListenerList LISTENER_LIST = new javax.swing.event.EventListenerList();    
    private double minValue;
    private double maxValue;
    private double range;
    private double value;
    private double oldValue;
    private double peakValue;
    private boolean autoResetToZero;
    private double threshold;
    private double minMeasuredValue;
    private double maxMeasuredValue;
    private double trackStart;
    private double trackSection;
    private double trackStop;
    private final java.util.ArrayList SECTIONS;
    private final java.util.ArrayList AREAS;
    private final java.util.ArrayList TICKMARK_SECTIONS;
    private eu.hansolo.steelseries.tools.GaugeType gaugeType;
    private double freeAreaAngle;
    private double angleStep;
    private double rotationOffset;
    private double tickmarkOffset;
    // 
    
    // 
    public Data()
    {        
        SECTIONS = new java.util.ArrayList(10);
        AREAS = new java.util.ArrayList(10);
        TICKMARK_SECTIONS = new java.util.ArrayList(10);
        init();
    }
    
    private void init()
    {
        minValue = 0;
        maxValue = 100;
        range = maxValue - minValue;
        value = minValue;
        oldValue = minValue;
        peakValue = minValue;
        autoResetToZero = false;
        threshold = range / 2.0;
        minMeasuredValue = maxValue;
        maxMeasuredValue = minValue;
        trackStart = minValue;
        trackSection = range / 2.0;
        trackStop = maxValue;
        SECTIONS.clear();
        AREAS.clear();
        gaugeType = eu.hansolo.steelseries.tools.GaugeType.TYPE4;
        freeAreaAngle = Math.toRadians(60);
        angleStep = (2.0 * Math.PI - freeAreaAngle) / range;
        rotationOffset = Math.PI + (getFreeAreaAngle() / 2.0);
        tickmarkOffset = 0;
    }
    // 
    
    // 
    @Override
    public double getMinValue()
    {
        return minValue;
    }

    @Override
    public void setMinValue(final double MIN_VALUE)
    {
        minValue = MIN_VALUE;
        range = maxValue - minValue;
        validate();        
        calcAngleStep();        
        fireStateChanged();
    }

    @Override
    public double getMaxValue()
    {
        return maxValue;
    }

    @Override
    public void setMaxValue(final double MAX_VALUE)
    {
        maxValue = MAX_VALUE;
        range = maxValue - minValue;
        validate();        
        calcAngleStep();        
        fireStateChanged();
    }

    @Override
    public double getRange()
    {
        return (maxValue - minValue);
    }

    @Override
    public void setRange(final double MIN_VALUE, final double MAX_VALUE)
    {
        range = (MAX_VALUE - MIN_VALUE);
        maxValue = MAX_VALUE;
        minValue = MIN_VALUE;
        validate();
        calcAngleStep();
        fireStateChanged();
    }
    
    @Override
    public double getValue()
    {
        return value;
    }

    @Override
    public void setValue(final double VALUE)
    {
        oldValue = value;      
        if (VALUE >= minValue && VALUE <= maxValue)
        {
            value = VALUE;
        }
        else
        {
            if (VALUE < minValue)
            {
                value = minValue;
            }
            
            if (VALUE > maxValue)
            {
                value = maxValue;
            }
        }                          
        fireStateChanged();
    }

    @Override
    public double getOldValue()
    {
        return oldValue;
    }

    @Override
    public double getPeakValue()
    {
        return peakValue;
    }

    @Override
    public void setPeakValue(final double PEAK_VALUE)
    {
        peakValue = PEAK_VALUE;
        fireStateChanged();
    }
    
    @Override
    public boolean isAutoResetToZero()
    {
        return autoResetToZero;
    }
    
    @Override
    public void setAutoResetToZero(final boolean AUTO_RESET_TO_ZERO)
    {
        if (minValue > 0 || maxValue < 0)
        {
            autoResetToZero = false;
        }
        else
        {
            autoResetToZero = AUTO_RESET_TO_ZERO;            
        }                
        fireStateChanged();
    }
    
    @Override
    public double getThreshold()
    {
        return threshold;
    }

    @Override
    public void setThreshold(final double THRESHOLD)
    {
        if (THRESHOLD >= minValue && THRESHOLD <= maxValue)
        {
            threshold = THRESHOLD;
        }
        else
        {
            if (THRESHOLD < minValue)
            {
                threshold = minValue;
            }
            
            if (THRESHOLD > maxValue)
            {
                threshold = maxValue;
            }
        }       
        fireStateChanged();
    }

    @Override
    public double getMinMeasuredValue()
    {
        return minMeasuredValue;
    }

    @Override
    public void setMinMeasuredValue(final double MIN_MEASURED_VALUE)
    {
        if (MIN_MEASURED_VALUE >= minValue && MIN_MEASURED_VALUE <= maxValue)
        {
            minMeasuredValue = MIN_MEASURED_VALUE;
        }
        else
        {
            if (MIN_MEASURED_VALUE < minValue)
            {
                minMeasuredValue = minValue;
            }
            
            if (MIN_MEASURED_VALUE > maxValue)
            {
                minMeasuredValue = maxValue;
            }
        }               
        fireStateChanged();
    }

    @Override
    public void resetMinMeasuredValue()
    {
        minMeasuredValue = value;
        fireStateChanged();
    }

    @Override
    public void resetMinMeasuredValue(final double MIN_MEASURED_VALUE)
    {
        minMeasuredValue = MIN_MEASURED_VALUE > maxValue ? maxValue : MIN_MEASURED_VALUE;
        minMeasuredValue = MIN_MEASURED_VALUE < minValue ? minValue : MIN_MEASURED_VALUE;
        fireStateChanged();
    }

    @Override
    public double getMaxMeasuredValue()
    {
        return maxMeasuredValue;
    }

    @Override
    public void setMaxMeasuredValue(final double MAX_MEASURED_VALUE)
    {
        if (MAX_MEASURED_VALUE >= minValue && MAX_MEASURED_VALUE <= maxValue)
        {
            maxMeasuredValue = MAX_MEASURED_VALUE;
        }
        else
        {
            if (MAX_MEASURED_VALUE < minValue)
            {
                maxMeasuredValue = minValue;
            }
            
            if (MAX_MEASURED_VALUE > maxValue)
            {
                maxMeasuredValue = maxValue;
            }
        }               
        fireStateChanged();
    }

    @Override
    public void resetMaxMeasuredValue()
    {
        maxMeasuredValue = value;
        fireStateChanged();
    }

    @Override
    public void resetMaxMeasuredValue(final double MAX_MEASURED_VALUE)
    {
        maxMeasuredValue = MAX_MEASURED_VALUE > maxValue ? maxValue : MAX_MEASURED_VALUE;
        maxMeasuredValue = MAX_MEASURED_VALUE < minValue ? minValue : MAX_MEASURED_VALUE;
        fireStateChanged();
    }

    @Override
    public double getTrackStart()
    {
        return trackStart;
    }

    @Override
    public void setTrackStart(final double TRACK_START)
    {
        trackStart = TRACK_START;
        validate();
        fireStateChanged();
    }

    @Override
    public double getTrackSection()
    {
        return trackSection;
    }

    @Override
    public void setTrackSection(final double TRACK_SECTION)
    {
        trackSection = TRACK_SECTION;
        validate();        
        fireStateChanged();
    }

    @Override
    public double getTrackStop()
    {
        return trackStop;
    }

    @Override
    public void setTrackStop(final double TRACK_STOP)
    {
        trackStop = TRACK_STOP;
        validate();        
        fireStateChanged();
    }

    @Override
    public java.util.List getSections()
    {
        final java.util.List SECTIONS_COPY = new java.util.ArrayList(10);
        SECTIONS_COPY.addAll(SECTIONS);
        //return (java.util.ArrayList) SECTIONS.clone();
        return SECTIONS_COPY;
    }

    @Override
    public void setSections(Section... SECTIONS_ARRAY)
    {
        SECTIONS.clear();        
        for (eu.hansolo.steelseries.tools.Section section : SECTIONS_ARRAY)
        {            
            SECTIONS.add(new eu.hansolo.steelseries.tools.Section(section.getStart(), section.getStop(), section.getColor()));
        }
        validate();
        fireStateChanged();
    }

    @Override
    public void addSection(Section SECTION)
    {
        SECTIONS.add(SECTION);
        fireStateChanged();
    }

    @Override
    public void resetSections()
    {
        SECTIONS.clear();
        fireStateChanged();
    }

    @Override
    public java.util.List getAreas()
    {
        final java.util.List AREAS_COPY = new java.util.ArrayList(10);
        AREAS_COPY.addAll(AREAS);        
        //return (java.util.ArrayList) AREAS.clone();
        return AREAS_COPY;
    }

    @Override
    public void setAreas(Section... AREAS_ARRAY)
    {
        AREAS.clear();
        for (eu.hansolo.steelseries.tools.Section area : AREAS_ARRAY)
        {            
            AREAS.add(new eu.hansolo.steelseries.tools.Section(area.getStart(), area.getStop(), area.getColor()));
        }
        validate();
        fireStateChanged();
    }

    @Override
    public void addArea(Section AREA)
    {
        AREAS.add(AREA);
    }

    @Override
    public void resetAreas()
    {
        AREAS.clear();
    }
    
    @Override
    public java.util.List getTickmarkSections()
    {
        final java.util.List TICKMARK_SECTIONS_COPY = new java.util.ArrayList(10);
        TICKMARK_SECTIONS_COPY.addAll(TICKMARK_SECTIONS);
        //return (java.util.ArrayList) TICKMARK_SECTIONS.clone();
        return TICKMARK_SECTIONS_COPY;
    }
    
    @Override
    public void setTickmarkSections(final eu.hansolo.steelseries.tools.Section... TICKMARK_SECTIONS_ARRAY)
    {
        TICKMARK_SECTIONS.clear();
        for (eu.hansolo.steelseries.tools.Section tickmarkSection : TICKMARK_SECTIONS_ARRAY)
        {            
            TICKMARK_SECTIONS.add(new eu.hansolo.steelseries.tools.Section(tickmarkSection.getStart(), tickmarkSection.getStop(), tickmarkSection.getColor()));
        }
        validate();
        fireStateChanged();
    }
    
    @Override
    public void addTickmarkSection(final eu.hansolo.steelseries.tools.Section TICKMARK_SECTION)
    {
        TICKMARK_SECTIONS.add(TICKMARK_SECTION);
        fireStateChanged();
    }
    
    @Override
    public void resetTickmarkSections()
    {
        TICKMARK_SECTIONS.clear();
        fireStateChanged();
    }
    
    @Override
    public eu.hansolo.steelseries.tools.GaugeType getGaugeType()
    {
        return gaugeType;
    }
    
    @Override
    public void setGaugeType(final eu.hansolo.steelseries.tools.GaugeType GAUGE_TYPE)
    {
        gaugeType = GAUGE_TYPE;
        switch(getGaugeType())
        {
            case TYPE1:
                freeAreaAngle = 0; 
                rotationOffset = (1.5 * Math.PI);
                tickmarkOffset = 0.5 * Math.PI; 
                break;
                
            case TYPE2:
                freeAreaAngle = 0; 
                rotationOffset = (1.5 * Math.PI);
                tickmarkOffset = 0.5 * Math.PI;
                break;
                
            case TYPE3:
                freeAreaAngle = 0; 
                rotationOffset = Math.PI;
                tickmarkOffset = 0;
                break;
                
            case TYPE4:
                freeAreaAngle = Math.toRadians(60);
                rotationOffset = Math.PI + (getFreeAreaAngle() / 2.0);
                tickmarkOffset = 0;
                break;
                
            default:
                freeAreaAngle = Math.toRadians(60);                
                rotationOffset = Math.PI + (getFreeAreaAngle() / 2.0);
                tickmarkOffset = 0;
                break;
        }   
        calcAngleStep();
        fireStateChanged();
    }
    
    @Override
    public double getFreeAreaAngle()
    {
        return freeAreaAngle;
    }
    
    @Override        
    public double getAngleStep()
    {
        return angleStep;
    }
    
    @Override
    public double getRotationOffset()
    {
        return rotationOffset;
    }
    
    @Override
    public double getTickmarkOffset()
    {
        return tickmarkOffset;
    }
    // 
    
    // 
    @Override
    public void validate()
    {
        // AutoResetToZero
        if (minValue > 0 || maxValue < 0)
        {
            autoResetToZero = false;            
        }
        
        // Threshold
        if (threshold < minValue || threshold > maxValue)
        {                        
            threshold = maxValue;
        }
        
        // MinMeasuredValue
        if (minMeasuredValue < minValue || minMeasuredValue > maxValue)
        {
            minMeasuredValue = value;
        }
        
        // MaxMeasuredValue
        if (maxMeasuredValue > maxValue || maxMeasuredValue < minValue)
        {
            maxMeasuredValue = value;
        }
        
        // PeakValue
        if (peakValue < minValue || peakValue > maxValue)
        {
            peakValue = value;
        }
        
        // TrackStart
        if (trackStart <= minValue || trackStart >= maxValue || trackStart >= trackStop)
        {                        
            trackStart = minValue;
        }
        
        // TrackStop
        if ((trackStop <= minValue) || trackStop >= maxValue || trackStop <= trackStart)
        {
            trackStop = maxValue;
        }
        
        // TrackSection
        if (trackSection <= minValue || trackSection >= maxValue || trackSection <= trackStart || trackSection >= trackStop)
        {            
            trackSection = ((trackStart + (trackStop - trackStart) / 2.0));            
        }
                        
        // Areas
        for (eu.hansolo.steelseries.tools.Section area : AREAS)
        {
            if ((area.getStart() < minValue) || area.getStart() >= maxValue || area.getStart() >= area.getStop())
            {
                area.setStart(minValue);
            }

            if (area.getStop() < minValue || area.getStop() > maxValue || area.getStop() <= area.getStart())
            {
                area.setStop(maxValue);
            }                                
        }
        
        // Sections
        for (eu.hansolo.steelseries.tools.Section section : SECTIONS)
        {
            if ((section.getStart() < minValue) || section.getStart() >= maxValue || section.getStart() >= section.getStop())
            {
                section.setStart(minValue);
            }

            if (section.getStop() < minValue || section.getStop() > maxValue || section.getStop() <= section.getStart())
            {
                section.setStop(maxValue);
            }
        }
        
        // TickmarkSections
        for (eu.hansolo.steelseries.tools.Section tickmarkSection : TICKMARK_SECTIONS)
        {
            if ((tickmarkSection.getStart() < minValue) || tickmarkSection.getStart() >= maxValue || tickmarkSection.getStart() >= tickmarkSection.getStop())
            {
                tickmarkSection.setStart(minValue);
            }

            if (tickmarkSection.getStop() < minValue || tickmarkSection.getStop() > maxValue || tickmarkSection.getStop() <= tickmarkSection.getStart())
            {
                tickmarkSection.setStop(maxValue);
            }
        }                        
    }
    
    private void calcAngleStep()
    {
        switch(gaugeType)
        {
            case TYPE1:
                angleStep = (Math.PI / 2.0 - freeAreaAngle) / range;
                break;
                
            case TYPE2:
                angleStep = (Math.PI - freeAreaAngle) / range;
                break;
                
            case TYPE3:
                angleStep = (1.5 * Math.PI - freeAreaAngle) / range;
                break;
                
            case TYPE4:
                angleStep = (2.0 * Math.PI - freeAreaAngle) / range;
                break;
                
            default:
                angleStep = (2.0 * Math.PI - freeAreaAngle) / range;
                break;
        } 
    }
     
    /**
     * Resets the model by calling the init() method
     */
    @Override
    public void reset()
    {
        init();
    }
    // 
    
    // 
    /**
     * Adds the given listener to the listener list
     * @param LISTENER 
     */
    @Override
    public void addChangeListener(javax.swing.event.ChangeListener LISTENER)
    {
        LISTENER_LIST.add(javax.swing.event.ChangeListener.class, LISTENER);
    }

    /**
     * Removes all listeners from the listener list
     * @param LISTENER
     */
    @Override
    public void removeChangeListener(javax.swing.event.ChangeListener LISTENER)
    {
        LISTENER_LIST.remove(javax.swing.event.ChangeListener.class, LISTENER);
    }

    /**
     * Fires an state change event every time the data model changes
     */
    protected void fireStateChanged() 
    {
        Object[] listeners = LISTENER_LIST.getListenerList();
        
        // Process the listeners last to first, notifying
        // those that are interested in this event
        for (int i = listeners.length - 2; i >= 0; i -= 2) 
        {
            if (listeners[i] == javax.swing.event.ChangeListener.class) 
            {
                if (changeEvent == null)
                {
                    changeEvent = new javax.swing.event.ChangeEvent(this);
                }
                ((javax.swing.event.ChangeListener) listeners[i + 1]).stateChanged(changeEvent);
            }
        }
    }
    // 
    
    @Override
    public String toString()
    {
        return "Data";
    }
}