chartmodelbase.java

It is all about project scheduling. GanttProject is a tool for creating a project schedule by means

        do {

            TimeFrame currentFrame = myTimeUnitStack.createTimeFrame(
                    currentDate, getTopUnit(currentDate), myBottomUnit);
            if (exactDate != null
                    && currentFrame.getStartDate().before(exactDate)) {
                currentFrame.trimLeft(exactDate);
            }
            if (currentFrame.getStartDate().after(currentFrame.getFinishDate())) {
                throw new IllegalStateException("Frame is invalid:\n"+currentFrame+"\n date="+exactDate);
            }
            result.add(currentFrame);
            int frameWidth = myFrameWidthFunction
                    .getTimeFrameWidth(currentFrame);
            totalFramesWidth += frameWidth;
            currentDate = currentFrame.getFinishDate();

        } while (totalFramesWidth <= getBounds().getWidth());
        //
        return (TimeFrame[]) result.toArray(new TimeFrame[0]);
    }

    public GPCalendar.DayType getDayType(TimeFrame timeFrame,
            TimeUnit timeUnit, int unitIndex) {
        Date startDate = timeFrame.getUnitStart(timeUnit, unitIndex);
        Date endDate = timeFrame.getUnitFinish(timeUnit, unitIndex);
        Calendar c = (Calendar) Calendar.getInstance().clone();
        c.setTime(startDate);
        int startDayOfWeek = c.get(Calendar.DAY_OF_WEEK);
        c.setTime(endDate);
        int endDayOfWeek = c.get(Calendar.DAY_OF_WEEK);

        // return startDayOfWeek==Calendar.SATURDAY ||
        // startDayOfWeek==Calendar.SUNDAY;
        // return getTaskManager().getCalendar().getWeekDayType(startDayOfWeek);

        return getTaskManager().getCalendar().getDayTypeDate(startDate);
    }

    /**
     * @author bard
     */
    private interface TimeFrameWidthFunction {
        int getTimeFrameWidth(TimeFrame timeFrame);
    }

    public TimeUnitStack getTimeUnitStack() {
        return myTimeUnitStack;
    }

    protected DayTypeAlternance[] getDayTypeAlternance(TimeFrame timeFrame,
            TimeUnit timeUnit, int unitIndex) {
        class AlternanceFactory {
            private Calendar c = (Calendar) Calendar.getInstance().clone();

            DayTypeAlternance createAlternance(TimeUnit timeUnit,
                    Date startDate, Date endDate) {
                c.setTime(startDate);
                int startDayOfWeek = c.get(Calendar.DAY_OF_WEEK);
                c.setTime(endDate);
                int endDayOfWeek = c.get(Calendar.DAY_OF_WEEK);
                TaskLength duration = myTaskManager.createLength(timeUnit,
                        startDate, endDate);
                DayType dayType = getTaskManager().getCalendar()
                        .getWeekDayType(startDayOfWeek);
                if ("hour".equals(timeUnit.getName())) {
                    dayType =  startDate.getHours()>=8 && startDate.getHours()<17 && endDate.getHours()<=17 ? GPCalendar.DayType.WORKING : GPCalendar.DayType.WEEKEND; 
                }
                else {
                dayType = getTaskManager().getCalendar().getDayTypeDate(
                        startDate);
                }
                return new DayTypeAlternance(dayType, duration, endDate);
            }
            void createAlternance(TimeUnit timeUnit, TimeFrame timeFrame, List output) {
                DayType startType = null;
                Date startDate = null;
                int unitCount = timeFrame.getUnitCount(timeUnit);
                for (int i=0; i<unitCount; i++) {
                    Date start = timeFrame.getUnitStart(timeUnit, i);
                    c.setTime(start);
                    int startDayOfWeek = c.get(Calendar.DAY_OF_WEEK);
                    DayType dayType = getTaskManager().getCalendar().getWeekDayType(startDayOfWeek);
                    if (startType==null) {
                        startType = dayType;
                        startDate = start;
                    }
                    if (startType!=dayType) {
                        Date end = timeFrame.getUnitFinish(timeUnit,i-1);
                        TaskLength duration = myTaskManager.createLength(timeUnit, startDate, end);
                        output.add(new DayTypeAlternance(startType, duration, end));
                        startType = dayType;
                        startDate = start;
                    }
                }
                Date end = timeFrame.getUnitFinish(timeUnit,unitCount-1);
                TaskLength duration = myTaskManager.createLength(timeUnit, startDate, end);
                output.add(new DayTypeAlternance(startType, duration, end));
                
            }
            
        }
        AlternanceFactory f = new AlternanceFactory();

        DayTypeAlternance[] result;
        Date startDate = timeFrame.getUnitStart(timeUnit, unitIndex);
        Date endDate = timeFrame.getUnitFinish(timeUnit, unitIndex);

        if (timeUnit.equals(myTimeUnitStack.getDefaultTimeUnit())) {
            result = new DayTypeAlternance[] { f.createAlternance(timeUnit,
                    startDate, endDate) };
        } else if (timeUnit.isConstructedFrom(myTimeUnitStack
                .getDefaultTimeUnit())) {
            java.util.List buf = new ArrayList();
            TimeUnit defaultUnit = myTimeUnitStack.getDefaultTimeUnit();
            TimeFrame innerFrame = myTimeUnitStack.createTimeFrame(startDate,
                    timeUnit, defaultUnit);
            // System.err.println("[ChartModelImpl] topUnit="+timeUnit+"
            // bottom="+defaultUnit+"
            // count="+innerFrame.getUnitCount(defaultUnit));
            f.createAlternance(defaultUnit, innerFrame, buf);
            result = (DayTypeAlternance[]) buf
                    .toArray(new DayTypeAlternance[buf.size()]);
        } else {
            throw new RuntimeException("We should not be here");
        }
        // System.err.println("from "+startDate+" to
        // "+endDate+"\n"+java.util.Arrays.asList(result));
        return result;
    }

    Offset[] calculateOffsets(TimeFrame timeFrame, TimeUnit frameBottomUnit, Date bottomUnitStartDate, TimeUnit offsetUnit, int frameBottomUnitWidth) {
        return myCachingOffsetCalculator.calculateOffsets(timeFrame, frameBottomUnit, bottomUnitStartDate, offsetUnit, frameBottomUnitWidth);
    }
    
    //private final OffsetCalculatorImpl myOffsetCalculator;
    protected final ChartUIConfiguration myChartUIConfiguration;

    public ChartUIConfiguration getChartUIConfiguration() {
        return myChartUIConfiguration;
    }

    private class RegularFramesWithFunction implements TimeFrameWidthFunction {
        public int getTimeFrameWidth(TimeFrame timeFrame) {
            return timeFrame.getUnitCount(myBottomUnit) * myAtomUnitPixels;
        }
    }

    private class SkewedFramesWidthFunction implements TimeFrameWidthFunction {
        private float myWidthPerDefaultUnit;

        void initialize() {
            int defaultUnitsPerBottomUnit = myBottomUnit
                    .getAtomCount(myTimeUnitStack.getDefaultTimeUnit());
            myWidthPerDefaultUnit = (float) myAtomUnitPixels
                    / defaultUnitsPerBottomUnit;
        }

        public int getTimeFrameWidth(TimeFrame timeFrame) {
            int defaultUnitsPerTopUnit = timeFrame.getUnitCount(myTimeUnitStack
                    .getDefaultTimeUnit());
            return (int) (defaultUnitsPerTopUnit * myWidthPerDefaultUnit);
        }

    }

    int getBottomUnitWidth(TimeFrame nextFrame) {
        int frameWidth = myFrameWidthFunction.getTimeFrameWidth(nextFrame);
        int bottomUnitsCount = nextFrame
                .getUnitCount(nextFrame.getBottomUnit());
        // System.err.println("ChartModelImpl: getBottomUnitWidth:
        // nextFrame="+nextFrame+" width="+frameWidth+"
        // bottomUnitsCount="+bottomUnitsCount);
        return frameWidth / bottomUnitsCount;
    }

    protected final TaskManager myTaskManager;

    private int myVerticalOffset;

    public TaskManager getTaskManager() {
        return myTaskManager;
    }

    public ChartHeader getChartHeader() {
        return myChartHeader;
    }

    protected ChartGridImpl getChartGrid() {
        return myChartGrid;
    }

    public float calculateLength(int fromX, int toX, int y) {
        // return toX - fromX;

        int curX = fromX;
        int totalPixels = toX - fromX;
        int holidayPixels = 0;
        while (curX < toX) {
            GraphicPrimitiveContainer.GraphicPrimitive nextPrimitive = getChartGrid()
                    .getPrimitiveContainer().getPrimitive(curX,
                            y - getChartUIConfiguration().getHeaderHeight());
            if (nextPrimitive instanceof GraphicPrimitiveContainer.Rectangle
                    && GPCalendar.DayType.WEEKEND == nextPrimitive
                            .getModelObject()) {
                GraphicPrimitiveContainer.Rectangle nextRect = (Rectangle) nextPrimitive;
                holidayPixels += nextRect.getRightX() - curX;
                if (nextRect.myLeftX < curX) {
                    holidayPixels -= curX - nextRect.myLeftX;
                }
                if (nextRect.myLeftX < fromX) {
                    holidayPixels -= fromX - nextRect.myLeftX;
                }
                if (nextRect.getRightX() > toX) {
                    holidayPixels -= nextRect.getRightX() - toX;
                }
                curX = nextRect.getRightX() + 1;
            } else {
                curX += getBottomUnitWidth();
            }
        }
        float workPixels = (float) totalPixels - (float) holidayPixels;
        return workPixels / (float) getBottomUnitWidth();
    }

    public float calculateLengthNoWeekends(int fromX, int toX) {
        int totalPixels = toX - fromX;
        return totalPixels / (float) getBottomUnitWidth();
    }

    /**
     * @return A length of the visible part of this chart area measured in the
     *         bottom line time units
     */
    public TaskLength getVisibleLength() {
        double pixelsLength = getBounds().getWidth();
        float unitsLength = (float) (pixelsLength / getBottomUnitWidth());
        TaskLength result = getTaskManager().createLength(getBottomUnit(),
                unitsLength);
        return result;
    }

    public void setHeaderHeight(int i) {
        getChartUIConfiguration().setHeaderHeight(i);
    }

    public void setVerticalOffset(int offset) {
        myVerticalOffset = offset;
    }
    
    protected int getVerticalOffset() {
        return myVerticalOffset;
    }
    
    public TimeUnit getBottomUnit() {
        return myBottomUnit;
    }
    
    private void setTopUnit(TimeUnit myTopUnit) {
        this.myTopUnit = myTopUnit;
    }

    public TimeUnit getTopUnit() {
        return getTopUnit(myStartDate);
    }

    private TimeUnit getTopUnit(Date startDate) {
        TimeUnit result = myTopUnit;
        if (myTopUnit instanceof TimeUnitFunctionOfDate) {
            if (startDate == null) {
                throw new RuntimeException("No date is set");
            } else {
                result = ((TimeUnitFunctionOfDate) myTopUnit)
                        .createTimeUnit(startDate);
            }
        }
        return result;
    }

    public GPOptionGroup[] getChartOptionGroups() {
        return new GPOptionGroup[] {myChartGrid.getOptions()};
    }

    public void addOptionChangeListener(GPOptionChangeListener listener) {
        myOptionListeners.add(listener);
    }

    protected void fireOptionsChanged() {
        for (int i = 0; i < myOptionListeners.size(); i++) {
            GPOptionChangeListener next = (GPOptionChangeListener) myOptionListeners
                    .get(i);
            next.optionsChanged();
        }
    }

    public ChartModelBase createCopy() {
        ChartModelBase result = new ChartModelBase(getTaskManager(), getTimeUnitStack(), myProjectConfig);
        result.myFrameWidthFunction = this.myFrameWidthFunction;
        return result;
    }

    public OptionEventDispatcher getOptionEventDispatcher() {
        return myOptionEventDispatcher;
    }
    
    public class OptionEventDispatcher {
        void optionsChanged() {
            fireOptionsChanged();
        }
    }
    

    public static class Offset {
        private TaskLength myOffsetLength;
        private Date myOffsetAnchor;
        private Date myOffsetEnd;
        private int myOffsetPixels;
        private TimeUnit myOffsetUnit;
        Offset(TimeUnit offsetUnit, Date offsetAnchor, Date offsetEnd, int offsetPixels) {
            //myOffsetLength = myTaskManager.createLength(offsetUnit, offsetAnchor, offsetEnd);
            myOffsetAnchor = offsetAnchor;
            myOffsetEnd = offsetEnd;
            myOffsetPixels = offsetPixels;
            myOffsetUnit = offsetUnit;
        }
//        TaskLength getOffsetLength() {
//            return null;
//        }
        Date getOffsetAnchor() {
            return myOffsetAnchor;
        }
        public Date getOffsetEnd() {
            return myOffsetEnd;
        }
        public int getOffsetPixels() {
            return myOffsetPixels;
        }
        TimeUnit getOffsetUnit() {
            return myOffsetUnit;
        }
        
        
    }

    public void timeUnitStackChanged() {
        myTimeFrames = null;
    }
}