DateAxis.java

Go to the documentation of this file.

/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2013, Christian Schudt
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 * 
 * 
 * 
 */
package org.sleuthkit.autopsy.timeline.ui.detailview;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import javafx.beans.property.ObjectProperty;
import javafx.beans.property.ObjectPropertyBase;
import javafx.beans.property.ReadOnlyDoubleProperty;
import javafx.beans.property.ReadOnlyDoubleWrapper;
import javafx.scene.chart.Axis;
import org.joda.time.DateTime;
import org.joda.time.Interval;
import org.sleuthkit.autopsy.timeline.TimeLineController;
import org.sleuthkit.autopsy.timeline.utils.RangeDivisionInfo;

final class DateAxis extends Axis<DateTime> {

    private ObjectProperty<DateTime> lowerBound = new ObjectPropertyBase<DateTime>() {
        @Override
        protected void invalidated() {
            if (!isAutoRanging()) {
                invalidateRange();
                requestAxisLayout();
            }
        }

        @Override
        public Object getBean() {
            return DateAxis.this;
        }

        @Override
        public String getName() {
            return "lowerBound"; // NON-NLS
        }
    };

    private DateTime maxDate;

    private DateTime minDate;

    private RangeDivisionInfo rangeDivisionInfo;

    private final ReadOnlyDoubleWrapper tickSpacing = new ReadOnlyDoubleWrapper();

    private final ObjectProperty<DateTime> upperBound = new ObjectPropertyBase<DateTime>() {
        @Override
        protected void invalidated() {
            if (!isAutoRanging()) {
                invalidateRange();
                requestAxisLayout();
            }
        }

        @Override
        public Object getBean() {
            return DateAxis.this;
        }

        @Override
        public String getName() {
            return "upperBound"; // NON-NLS
        }
    };

    DateAxis() {
        setAutoRanging(false);
    }

    @Override
    public double getDisplayPosition(DateTime date) {
        final double length = -200 + (getSide().isHorizontal() ? getWidth() : getHeight());

        // Get the difference between the max and min date.
        double diff = getUpperBound().getMillis() - getLowerBound().getMillis();

        // Get the actual range of the visible area.
        // The minimal date should start at the zero position, that's why we subtract it.
        double range = length - getZeroPosition();

        // Then get the difference from the actual date to the min date and divide it by the total difference.
        // We get a value between 0 and 1, if the date is within the min and max date.
        double d = (date.getMillis() - getLowerBound().getMillis()) / diff;

        // Multiply this percent value with the range and add the zero offset.
        if (getSide().isVertical()) {
            return getHeight() - d * range + getZeroPosition();
        } else {
            return d * range + getZeroPosition();
        }
    }

    public final DateTime getLowerBound() {
        return lowerBound.get();
    }

    public final void setLowerBound(DateTime date) {
        lowerBound.set(date);
    }

    public final DateTime getUpperBound() {
        return upperBound.get();
    }

    public final void setUpperBound(DateTime date) {
        upperBound.set(date);
    }

    @Override
    public DateTime getValueForDisplay(double displayPosition) {
        final double length = - 200 + (getSide().isHorizontal() ? getWidth() : getHeight());

        // Get the difference between the max and min date.
        double diff = getUpperBound().getMillis() - getLowerBound().getMillis();

        // Get the actual range of the visible area.
        // The minimal date should start at the zero position, that's why we subtract it.
        double range = length - getZeroPosition();

        if (getSide().isVertical()) {
            // displayPosition = getHeight() - ((date - lowerBound) / diff) * range + getZero
            // date = displayPosition - getZero - getHeight())/range * diff + lowerBound
            return new DateTime((long) ((displayPosition - getZeroPosition() - getHeight()) / -range * diff + getLowerBound().getMillis()), TimeLineController.getJodaTimeZone());
        } else {
            // displayPosition = ((date - lowerBound) / diff) * range + getZero
            // date = displayPosition - getZero)/range * diff + lowerBound
            return new DateTime((long) ((displayPosition - getZeroPosition()) / range * diff + getLowerBound().getMillis()), TimeLineController.getJodaTimeZone());
        }
    }

    @Override
    public double getZeroPosition() {
        return 0;
    }

    @Override
    public void invalidateRange(List<DateTime> list) {
        super.invalidateRange(list);

        Collections.sort(list);
        if (list.isEmpty()) {
            minDate = maxDate = new DateTime();
        } else if (list.size() == 1) {
            minDate = maxDate = list.get(0);
        } else if (list.size() > 1) {
            minDate = list.get(0);
            maxDate = list.get(list.size() - 1);
        }
    }

    @Override
    public boolean isValueOnAxis(DateTime date) {
        return date.getMillis() > getLowerBound().getMillis() && date.getMillis() < getUpperBound().getMillis();
    }

    @Override
    public double toNumericValue(DateTime date) {
        return date.getMillis();
    }

    @Override
    public DateTime toRealValue(double v) {
        return new DateTime((long) v);
    }

    @Override
    protected Object autoRange(double length) {
        if (isAutoRanging()) {
            return new Interval(minDate, maxDate);
        } else {
            if (getLowerBound() == null || getUpperBound() == null) {
                return null;
            }
            return getRange();
        }
    }

    @Override
    protected List<DateTime> calculateTickValues(double length, Object range) {
        List<DateTime> tickDates = new ArrayList<>();
        if (range == null) {
            return tickDates;
        }
        rangeDivisionInfo = RangeDivisionInfo.getRangeDivisionInfo((Interval) range);
        final DateTime lowerBound1 = getLowerBound();
        final DateTime upperBound1 = getUpperBound();

        if (lowerBound1 == null || upperBound1 == null) {
            return tickDates;
        }
        DateTime lower = lowerBound1.withZone(TimeLineController.getJodaTimeZone());
        DateTime upper = upperBound1.withZone(TimeLineController.getJodaTimeZone());

        DateTime current = lower;
        // Loop as long we exceeded the upper bound.
        while (current.isBefore(upper)) {
            tickDates.add(current);
            current = current.plus(rangeDivisionInfo.getPeriodSize().getPeriod());//.add(interval.interval, interval.amount);
        }

        // At last add the upper bound.
        tickDates.add(upper);

        // If there are at least three dates, check if the gap between the lower date and the second date is at least half the gap of the second and third date.
        // Do the same for the upper bound.
        // If gaps between dates are to small, remove one of them.
        // This can occur, e.g. if the lower bound is 25.12.2013 and years are shown. Then the next year shown would be 2014 (01.01.2014) which would be too narrow to 25.12.2013.
        if (tickDates.size() > 2) {
            DateTime secondDate = tickDates.get(1);
            DateTime thirdDate = tickDates.get(2);
            DateTime lastDate = tickDates.get(tickDates.size() - 2);
            DateTime previousLastDate = tickDates.get(tickDates.size() - 3);

            // If the second date is too near by the lower bound, remove it.
            if (secondDate.getMillis() - lower.getMillis() < (thirdDate.getMillis() - secondDate.getMillis()) / 2) {
                tickDates.remove(lower);
            }

            // If difference from the upper bound to the last date is less than the half of the difference of the previous two dates,
            // we better remove the last date, as it comes to close to the upper bound.
            if (upper.getMillis() - lastDate.getMillis() < (lastDate.getMillis() - previousLastDate.getMillis()) / 2) {
                tickDates.remove(lastDate);
            }
        }

        if (tickDates.size() >= 2) {
            tickSpacing.set(getDisplayPosition(tickDates.get(1)) - getDisplayPosition(tickDates.get(0)));
        } else if (tickDates.size() >= 4) {
            tickSpacing.set(getDisplayPosition(tickDates.get(2)) - getDisplayPosition(tickDates.get(1)));
        }
        return tickDates;
    }

    @Override
    protected Object getRange() {

        return new Interval(getLowerBound(), getUpperBound());
    }

    @Override
    protected String getTickMarkLabel(DateTime date) {
        return rangeDivisionInfo.getTickFormatter().print(date);
    }

    @Override
    protected void layoutChildren() {
        super.layoutChildren();
    }

    @Override
    protected void setRange(Object range, boolean animating) {

        rangeDivisionInfo = RangeDivisionInfo.getRangeDivisionInfo((Interval) range);

        setLowerBound(new DateTime(rangeDivisionInfo.getLowerBound()));
        setUpperBound(new DateTime(rangeDivisionInfo.getUpperBound()));
    }

    ReadOnlyDoubleProperty getTickSpacing() {
        return tickSpacing.getReadOnlyProperty();
    }
}