chartmodelbase.java

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

package net.sourceforge.ganttproject.chart;

import java.awt.Dimension;
import java.awt.Graphics;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

import net.sourceforge.ganttproject.calendar.GPCalendar;
import net.sourceforge.ganttproject.calendar.GPCalendar.DayType;
import net.sourceforge.ganttproject.chart.GraphicPrimitiveContainer.Rectangle;
import net.sourceforge.ganttproject.gui.UIConfiguration;
import net.sourceforge.ganttproject.gui.options.model.GPOptionChangeListener;
import net.sourceforge.ganttproject.gui.options.model.GPOptionGroup;
import net.sourceforge.ganttproject.gui.zoom.ZoomEvent;
import net.sourceforge.ganttproject.task.TaskLength;
import net.sourceforge.ganttproject.task.TaskManager;
import net.sourceforge.ganttproject.time.TimeFrame;
import net.sourceforge.ganttproject.time.TimeUnit;
import net.sourceforge.ganttproject.time.TimeUnitFunctionOfDate;
import net.sourceforge.ganttproject.time.TimeUnitStack;
import net.sourceforge.ganttproject.time.gregorian.GPTimeUnitStack;

public class ChartModelBase implements TimeUnitStack.Listener {

    public static final Object STATIC_MUTEX = new Object();

    private final OptionEventDispatcher myOptionEventDispatcher = new OptionEventDispatcher();
    
    private final ChartHeaderImpl myChartHeader;

    private final ChartGridImpl myChartGrid;

    private Dimension myBounds;

    private Date myStartDate;

    protected int myAtomUnitPixels;

    private TimeFrame[] myTimeFrames;

    protected final TimeUnitStack myTimeUnitStack;

    private TimeUnit myTopUnit;

    protected TimeUnit myBottomUnit;

    protected java.util.List<TimeUnitVisitor> myTimeUnitVisitors = new ArrayList<TimeUnitVisitor>();

    protected final BottomUnitLineRendererImpl myBottomUnitLineRenderer;

    protected TimeFrameWidthFunction myFrameWidthFunction;

    private RegularFramesWithFunction myRegularFrameWidthFunction = new RegularFramesWithFunction();

    private SkewedFramesWidthFunction mySkewedFrameWidthFunction = new SkewedFramesWidthFunction();

    private final BackgroundRendererImpl myBackgroundRenderer;

    private final StyledPainterImpl myPainter;

    private final List myOptionListeners = new ArrayList();
    
    private final UIConfiguration myProjectConfig;

	private CachingOffsetCalculatorImpl myCachingOffsetCalculator;

    public ChartModelBase(TaskManager taskManager, TimeUnitStack timeUnitStack,
            UIConfiguration projectConfig) {
        myTaskManager = taskManager;
        myProjectConfig = projectConfig;
        myChartUIConfiguration = new ChartUIConfiguration(projectConfig);
        myPainter = new StyledPainterImpl(myChartUIConfiguration);
        myTimeUnitStack = timeUnitStack;
        timeUnitStack.addTimeUnitStackListener(this);
        myChartHeader = new ChartHeaderImpl(this);
        myChartGrid = new ChartGridImpl(this, projectConfig);
        myBottomUnitLineRenderer = new BottomUnitLineRendererImpl();
        myBackgroundRenderer = new BackgroundRendererImpl(this);
        addTimeUnitVisitor(myChartHeader);
        addTimeUnitVisitor(myBottomUnitLineRenderer);
        myTimeUnitVisitors.add(myChartGrid);
        myCachingOffsetCalculator = new CachingOffsetCalculatorImpl(myTimeUnitStack);
    }

    public void paint(Graphics g) {
        int height = (int) getBounds().getHeight()
                - getChartUIConfiguration().getHeaderHeight();
        myChartGrid.setHeight(height);
        myBackgroundRenderer.setHeight(height);
        if (getTopUnit().isConstructedFrom(myBottomUnit)) {
            myFrameWidthFunction = myRegularFrameWidthFunction;
            for (int i = 0; i < myTimeUnitVisitors.size(); i++) {
                ((TimeUnitVisitor) myTimeUnitVisitors.get(i)).setEnabled(true);
            }
            paintRegularTimeFrames(g, getTimeFrames(null));
        } else {
            myFrameWidthFunction = mySkewedFrameWidthFunction;
            mySkewedFrameWidthFunction.initialize();
            paintSkewedTimeFrames(g);
        }
    }

    public void clearTimeUnitVisitors() {
        myTimeUnitVisitors.clear();
    }
    public void addTimeUnitVisitor(TimeUnitVisitor visitor) {
        myTimeUnitVisitors.add(visitor);
        if (visitor instanceof ChartRendererBase) {
            ((ChartRendererBase)visitor).setChartModel(this);
        }
    }

    protected void enableRenderers1() {
        myChartHeader.setEnabled(false);
        myBottomUnitLineRenderer.setEnabled(true);
        myChartGrid.setEnabled(true);
    }

    protected void enableRenderers2() {
        myChartHeader.setEnabled(true);
        myBottomUnitLineRenderer.setEnabled(false);
        myChartGrid.setEnabled(false);
    }

    private void paintSkewedTimeFrames(Graphics g) {
        TimeUnit savedBottomUnit = myBottomUnit;
        TimeUnit topUnit = getTopUnit();
        setTopUnit(myBottomUnit);
        myTimeFrames = null;
        enableRenderers1();
        TimeFrame[] timeFrames = getTimeFrames(null);
        paintRegularTimeFrames(g, timeFrames);
        Date exactStart = timeFrames[0].getStartDate();
        // System.err.println("... done");
        // System.err.println("[ChartModelImpl] rendering skewed frames. Top
        // unit="+myTopUnit+" bottom unit="+myBottomUnit);
        // System.err.println(" rendering top line");
        myTimeFrames = null;
        setTopUnit(topUnit);
        myBottomUnit = topUnit;
        enableRenderers2();
        timeFrames = getTimeFrames(exactStart);

        paintRegularTimeFrames(g, timeFrames);
        myBottomUnit = savedBottomUnit;
        //
        // System.err.println(" rendering bottom line");
    }

    protected void paintMainArea(Graphics mainArea, Painter p) {
        myChartGrid.getPrimitiveContainer().paint(p, mainArea);
    }

    private void paintRegularTimeFrames(Graphics g, TimeFrame[] timeFrames) {
        fireBeforeProcessingTimeFrames();
        for (int i = 0; i < timeFrames.length; i++) {
            TimeFrame next = timeFrames[i];
            fireFrameStarted(next);
            TimeUnit topUnit = next.getTopUnit();
            fireUnitLineStarted(topUnit);
            fireUnitLineFinished(topUnit);
            //
            TimeUnit bottomUnit = myBottomUnit;// next.getBottomUnit();
            fireUnitLineStarted(bottomUnit);
            visitTimeUnits(next, bottomUnit);
            fireUnitLineFinished(bottomUnit);
            fireFrameFinished(next);
        }
        fireAfterProcessingTimeFrames();
        //myPainter.setGraphics(g);
        // Painter p = new StyledPainterImpl(g, getChartUIConfiguration());
        //myChartHeader.getPrimitiveContainer().paint(myPainter, g);
        //myBottomUnitLineRenderer.getPrimitiveContainer().paint(myPainter, g);
        g.translate(0, getChartUIConfiguration()
                .getHeaderHeight());
        myPainter.setGraphics(g);
        // p = new StyledPainterImpl(mainArea, getChartUIConfiguration());
        //myBackgroundRenderer.getPrimitiveContainer().paint(myPainter, g);
        paintMainArea(g, myPainter);
        for (TimeUnitVisitor nextVisitor : myTimeUnitVisitors) {
            if (nextVisitor instanceof Renderer && nextVisitor.isEnabled()) {
                Renderer nextRenderer = (Renderer) nextVisitor;
                nextRenderer.paint().paint(myPainter, g);
            }
        }
        g.translate(0, -getChartUIConfiguration()
                .getHeaderHeight());
        // Graphics resourcesArea = g.create((int)getBounds().getWidth()-20,
        // getChartUIConfiguration().getHeaderHeight(), 20,
        // (int)getBounds().getHeight());
        // myResourcesRendererImpl.getPrimitiveContainer().paint(p,
        // resourcesArea);
        // myTaskProgressRendererImpl.getPrimitiveContainer().paint(p,
        // mainArea);
    }

    void fireBeforeProcessingTimeFrames() {
        myBackgroundRenderer.beforeProcessingTimeFrames();
        for (int i = 0; i < myTimeUnitVisitors.size(); i++) {
            TimeUnitVisitor nextVisitor = (TimeUnitVisitor) myTimeUnitVisitors
                    .get(i);
            if (!nextVisitor.isEnabled()) {
                continue;
            }
            nextVisitor.beforeProcessingTimeFrames();
        }
    }

    void fireAfterProcessingTimeFrames() {
        for (int i = 0; i < myTimeUnitVisitors.size(); i++) {
            TimeUnitVisitor nextVisitor = (TimeUnitVisitor) myTimeUnitVisitors
                    .get(i);
            if (!nextVisitor.isEnabled()) {
                continue;
            }
            nextVisitor.afterProcessingTimeFrames();
        }
    }

    void fireFrameStarted(TimeFrame timeFrame) {
        for (int i = 0; i < myTimeUnitVisitors.size(); i++) {
            TimeUnitVisitor nextVisitor = (TimeUnitVisitor) myTimeUnitVisitors
                    .get(i);
            if (!nextVisitor.isEnabled()) {
                continue;
            }
            nextVisitor.startTimeFrame(timeFrame);
        }
    }

    void fireFrameFinished(TimeFrame timeFrame) {
        for (int i = 0; i < myTimeUnitVisitors.size(); i++) {
            TimeUnitVisitor nextVisitor = (TimeUnitVisitor) myTimeUnitVisitors
                    .get(i);
            if (!nextVisitor.isEnabled()) {
                continue;
            }
            nextVisitor.endTimeFrame(timeFrame);
        }
    }

    void fireUnitLineStarted(TimeUnit timeUnit) {
        for (int i = 0; i < myTimeUnitVisitors.size(); i++) {
            TimeUnitVisitor nextVisitor = (TimeUnitVisitor) myTimeUnitVisitors
                    .get(i);
            if (!nextVisitor.isEnabled()) {
                continue;
            }
            nextVisitor.startUnitLine(timeUnit);
        }
    }

    void fireUnitLineFinished(TimeUnit timeUnit) {
        for (int i = 0; i < myTimeUnitVisitors.size(); i++) {
            TimeUnitVisitor nextVisitor = (TimeUnitVisitor) myTimeUnitVisitors
                    .get(i);
            if (!nextVisitor.isEnabled()) {
                continue;
            }
            nextVisitor.endUnitLine(timeUnit);
        }
    }

    void visitTimeUnits(TimeFrame timeFrame, TimeUnit timeUnit) {
        for (int j = 0; j < timeFrame.getUnitCount(timeUnit); j++) {
            for (int i = 0; i < myTimeUnitVisitors.size(); i++) {
                TimeUnitVisitor nextVisitor = (TimeUnitVisitor) myTimeUnitVisitors
                        .get(i);
                if (!nextVisitor.isEnabled()) {
                    continue;
                }
                nextVisitor.nextTimeUnit(j);
            }
        }

    }

    public void setBounds(Dimension bounds) {
        myBounds = bounds;
    }

    public void setStartDate(Date startDate) {
        if (!startDate.equals(myStartDate)) {
            myStartDate = startDate;
            myTimeFrames = null;
        }
    }

    public Date getStartDate() {
        return myStartDate;
    }

    public Date getEndDate() {
        //TimeFrame[] timeFrames = getTimeFrames(null);
        // for(int i = 0 ; i<timeFrames.length; i++)
        // System.out.println("< "+timeFrames[i].getStartDate() + "" +
        // timeFrames[i].getFinishDate()+" >");

        //TimeFrame last = timeFrames[timeFrames.length - 1];
    	TaskLength visibleLength = getVisibleLength();
    	Date result = getTaskManager().shift(getStartDate(), visibleLength);
        return result;
    }

    public void setBottomUnitWidth(int pixelsWidth) {
    	if (myAtomUnitPixels!=pixelsWidth) {
    		myCachingOffsetCalculator.reset();
    	}
        myAtomUnitPixels = pixelsWidth;
    }

    public void setRowHeight(int rowHeight) {
        getChartUIConfiguration().setRowHeight(rowHeight);
    }

    public void setTopTimeUnit(TimeUnit topTimeUnit) {
        setTopUnit(topTimeUnit);
        myTimeFrames = null;
    }

    public void setBottomTimeUnit(TimeUnit bottomTimeUnit) {
        myBottomUnit = bottomTimeUnit;
        myTimeFrames = null;
    }

    protected UIConfiguration getProjectConfig() {
        return myProjectConfig;
    }
    
    protected Dimension getBounds() {
        return myBounds;
    }

    TimeFrame[] getTimeFrames(Date exactDate) {
        if (myTimeFrames == null) {
            myTimeFrames = calculateTimeFrames(exactDate);
        }
        return myTimeFrames;
    }

    public int getBottomUnitWidth() {
        return myAtomUnitPixels;
    }

    private TimeFrame[] calculateTimeFrames(Date exactDate) {
        ArrayList result = new ArrayList();
        int totalFramesWidth = 0;
        Date currentDate = myStartDate;