taskrendererimpl.java

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

    /*
     * private void processText(int xInit, int yInit, String text) { String save =
     * text; boolean startNew = false; StringTokenizer st = new
     * StringTokenizer(text, "{}", true); while (st.hasMoreTokens()) { String
     * token = st.nextToken(); if (token.equals("{")) { startNew = true;
     * continue; } if (token.equals("}")) { startNew = false; continue; } if
     * (startNew) { Text t =
     * getPrimitiveContainer().getLayer(2).createText(xInit, yInit, token);
     * xInit += TextLengthCalculatorImpl.getTextLength(myModel
     * .getArea().getGraphics(), token); t.setFont(new Font(null, Font.BOLD,
     * 9)); continue; } getPrimitiveContainer().getLayer(2).createText(xInit,
     * yInit, token); xInit +=
     * TextLengthCalculatorImpl.getTextLength(myModel.getArea() .getGraphics(),
     * token); } }
     */

    private void drawPreviousStateTask(GanttPreviousStateTask task, int row) {
        int topy = (row * getRowHeight()) + getRowHeight() - 8;
        int posX = myPosX;
        if (task.getStart().getTime().compareTo(myUnitStart) >= 0) {
            TaskLength deltaLength = myModel.getTaskManager().createLength(
                    getChartModel().getTimeUnitStack().getDefaultTimeUnit(),
                    myUnitStart, task.getStart().getTime());

            int deltaX = (int) (deltaLength.getLength(myCurrentUnit) * getChartModel()
                    .getBottomUnitWidth());
            posX += deltaX;
        }
        int duration = task.getEnd(myModel.getTaskManager().getCalendar())
                .diff(task.getStart());

        TaskLength tl = myModel.getTaskManager().createLength(duration);
        int length = (int) (tl.getLength(myCurrentUnit) * getChartModel()
                .getBottomUnitWidth());

        Integer nextOrdNumber = (Integer) myActivity2ordinalNumber.get(task);
        GraphicPrimitiveContainer container = getPrimitiveContainer();

        Rectangle rect = container.createRectangle(posX, topy, length, 6);
        String style = "";
        if (task.isMilestone()) {
            style = "previousStateTask.milestone";
        } else if (task.hasNested()) {
            style = "previousStateTask.super";
            if (task.isAPart())
                style = "previousStateTask.super.apart";
        } else {
            style = "previousStateTask";
        }
        if (task.getState() == GanttPreviousStateTask.EARLIER)
            style = style + ".earlier";
        else if (task.getState() == GanttPreviousStateTask.LATER)
            style = style + ".later";
        rect.setStyle(style);
    }

    private String getTaskLabel(Task task, int position) {
        StringBuffer result = new StringBuffer();
        Object property = TaskProperties.getProperty(task,
                myLabelOptions[position].getValue());
        if (property != null) {
            if (property instanceof Boolean)
                if (((Boolean) property).booleanValue())
                    result.append(lang.getText("yes"));
                else
                    result.append(lang.getText("no"));
            else
                result.append(property);
        }
        return result.toString();
    }

    private long getNegativeOffset(Date offsetDate, Date anchorDate) {
    	if (getChartModel().getTimeUnitStack().getDefaultTimeUnit().equals(myCurrentUnit)) {
    		TaskLength length = getChartModel().getTaskManager().createLength(myCurrentUnit, offsetDate, anchorDate);
    		return -length.getLength()*getChartModel().getBottomUnitWidth();
    	}
    	int length = 0;
    	while(true) {
    		ChartModelBase.Offset[] offsets = getChartModel().calculateOffsets(myCurrentTimeFrame, myCurrentUnit, offsetDate, getChartModel().getTimeUnitStack().getDefaultTimeUnit(), getChartModel().getBottomUnitWidth());
    		assert offsets.length>0;
    		Date lastOffsetEnd = offsets[offsets.length-1].getOffsetEnd(); 
    		if (lastOffsetEnd.before(anchorDate)) {
    			offsetDate = lastOffsetEnd;
    			length += offsets[offsets.length-1].getOffsetPixels();
    			continue;
    		}
			for (int i=offsets.length-1; i>=0; i--) {
				Offset offset = offsets[i];
				if (offset.getOffsetEnd().after(anchorDate)) {
					continue;
				}
				length+=offset.getOffsetPixels();
				break;
			}
			break;
    	}
    	return -length;
    }
    private long getPositiveOffset(Date offsetDate, Date anchorDate) {
        if (getChartModel().getTimeUnitStack().getDefaultTimeUnit().equals(myCurrentUnit)) {
            TaskLength length = getChartModel().getTaskManager().createLength(myCurrentUnit, anchorDate, offsetDate);
            return length.getLength()*getChartModel().getBottomUnitWidth();
        }
        int length = 0;
        while(true) {
            ChartModelBase.Offset[] offsets = getChartModel().calculateOffsets(
                    myCurrentTimeFrame, 
                    myCurrentUnit, 
                    anchorDate, 
                    getChartModel().getTimeUnitStack().getDefaultTimeUnit(), 
                    getChartModel().getBottomUnitWidth());
            if (offsets.length==0) {
                throw new IllegalStateException("Failed to calculate offsets for anchorDate="+anchorDate);
            }
            Date lastOffsetEnd = offsets[offsets.length-1].getOffsetEnd(); 
            //System.err.println("[TaskRendererImpl] getPositiveOffset(): |offsets|="+offsets.length+" last offset end="+lastOffsetEnd+" last offset pixels="+offsets[offsets.length-1].getOffsetPixels());
            if (lastOffsetEnd.before(offsetDate)) {
                anchorDate = lastOffsetEnd;
                length += offsets[offsets.length-1].getOffsetPixels();
                continue;
            }
            //int firstOffsetPixels = offsets[0].getOffsetPixels();
            for (int i=0; i<offsets.length; i++) {
                Offset offset = offsets[i];
                if (false==offset.getOffsetEnd().before(offsetDate)) {
                    length+=(offset.getOffsetPixels());
                    break;
                }
            }
            break;
        }
        return length;
        
    }
    private java.awt.Rectangle getBoundingRectangle(TaskActivity activity) {
        //System.err.println("[TaskRendererImpl] getBoundingRectangle():\nunit start="+myUnitStart+"\nactivity="+activity);
        int posX = myPosX;
        int length;
        if (false==activity.getStart().equals(myUnitStart)) {
            int deltaX = 0;
            if (activity.getStart().before(myUnitStart)) {
            	deltaX = (int) getNegativeOffset(activity.getStart(), myUnitStart);
            }
            else if (activity.getStart().after(myUnitStart)) {
                deltaX = (int) getPositiveOffset(activity.getStart(), myUnitStart);
            }
            posX += deltaX;
            length=(int) getPositiveOffset(activity.getEnd(), myUnitStart)-deltaX;            
        }
        else {
            length = (int) (activity.getDuration().getLength(myCurrentUnit) * getChartModel()
                    .getBottomUnitWidth());
        }
        Integer nextOrdNumber = (Integer) myActivity2ordinalNumber
                .get(activity);
        int topy = nextOrdNumber.intValue() * getRowHeight() + 4; // JA Added
        // 4 so that
        // it draws
        // in middle
        // of row
        return new java.awt.Rectangle(posX, topy, length, getRowHeight());
    }

    private void createDependencyLines() {
        List/* <DependencyDrawData> */dependencyDrawData = prepareDependencyDrawData();
        drawDependencies(dependencyDrawData);
    }

    /**
     * @param dependencyDrawData
     */
    private void drawDependencies(List dependencyDrawData) {
        // if(dependencyDrawData.size() == 0)
        // System.out.println("VIDE");

        GraphicPrimitiveContainer primitiveContainer = getPrimitiveContainer()
                .getLayer(2);
        int arrowLength = 7;
        for (int i = 0; i < dependencyDrawData.size(); i++) {
            DependencyDrawData next = (DependencyDrawData) dependencyDrawData
                    .get(i);
            if (next.myDependeeVector
                    .reaches(next.myDependantVector.getPoint())) {
                // when dependee.end <= dependant.start && dependency.type is
                // any
                // or dependee.end <= dependant.end && dependency.type==FF
                // or dependee.start >= dependant.end && dependency.type==SF
                int ysign = signum(next.myDependantVector.getPoint().y
                        - next.myDependeeVector.getPoint().y);
                Point first = new Point(next.myDependeeVector.getPoint().x,
                        next.myDependeeVector.getPoint().y);
                Point second = new Point(next.myDependantVector.getPoint(-3).x,
                        next.myDependeeVector.getPoint().y);
                Point third = new Point(next.myDependantVector.getPoint(-3).x,
                        next.myDependantVector.getPoint().y);
                java.awt.Rectangle arrowBoundary = null;
                String style;
                if (next.myDependantVector.reaches(third)) {
                    second.x += arrowLength;
                    third.x += arrowLength;
                    Point forth = next.myDependantVector.getPoint();
                    primitiveContainer.createLine(third.x, third.y, forth.x,
                            forth.y);
                    arrowBoundary = new java.awt.Rectangle(forth.x,
                            forth.y - 3, arrowLength, 6);
                    style = "dependency.arrow.left";
                } else {
                    third.y -= ysign * next.myDependantRectangle.myHeight / 2;
                    arrowBoundary = new java.awt.Rectangle(third.x - 3, third.y
                            - (ysign > 0 ? ysign * arrowLength : 0), 6,
                            arrowLength);
                    style = ysign > 0 ? "dependency.arrow.down"
                            : "dependency.arrow.up";
                }
                primitiveContainer.createLine(first.x, first.y, second.x,
                        second.y);
                primitiveContainer.createLine(second.x, second.y, third.x,
                        third.y);
                if (arrowBoundary != null) {
                    Rectangle arrow = getPrimitiveContainer().createRectangle(
                            arrowBoundary.x, arrowBoundary.y,
                            arrowBoundary.width, arrowBoundary.height);
                    arrow.setStyle(style);
                }
            } else {
                Point first = next.myDependeeVector.getPoint(3);
                if (next.myDependantVector.reaches(first)) {
                    Point second = new Point(first.x, next.myDependantVector
                            .getPoint().y);
                    primitiveContainer.createLine(next.myDependeeVector
                            .getPoint().x, next.myDependeeVector.getPoint().y,
                            first.x, first.y);
                    primitiveContainer.createLine(first.x, first.y, second.x,
                            second.y);
                    primitiveContainer.createLine(second.x, second.y,
                            next.myDependantVector.getPoint().x,
                            next.myDependantVector.getPoint().y);
                    int xsign = signum(next.myDependantVector.getPoint().x
                            - second.x);
                    java.awt.Rectangle arrowBoundary = new java.awt.Rectangle(
                            next.myDependantVector.getPoint(7).x,
                            next.myDependantVector.getPoint().y - 3, xsign * 7,
                            6);
                    Rectangle arrow = primitiveContainer.createRectangle(
                            arrowBoundary.x, arrowBoundary.y,
                            arrowBoundary.width, arrowBoundary.height);
                    arrow.setStyle(xsign < 0 ? "dependency.arrow.left"
                            : "dependency.arrow.right");
                } else {
                    Point forth = next.myDependantVector.getPoint(3);
                    Point second = new Point(first.x, (first.y + forth.y) / 2);
                    Point third = new Point(forth.x, (first.y + forth.y) / 2);
                    primitiveContainer.createLine(next.myDependeeVector
                            .getPoint().x, next.myDependeeVector.getPoint().y,
                            first.x, first.y);
                    primitiveContainer.createLine(first.x, first.y, second.x,
                            second.y);
                    primitiveContainer.createLine(second.x, second.y, third.x,
                            third.y);
                    primitiveContainer.createLine(third.x, third.y, forth.x,
                            forth.y);
                    primitiveContainer.createLine(forth.x, forth.y,
                            next.myDependantVector.getPoint().x,
                            next.myDependantVector.getPoint().y);
                }
            }
        }
    }

    private final int signum(int value) {
        if (value == 0) {
            return 0;
        }
        return value < 0 ? -1 : 1;
    }

    /**
     * @return
     */
    private List prepareDependencyDrawData() {
        List result = new ArrayList();
        List/* <Task> */visibleTasks = ((ChartModelImpl) getChartModel())
                .getVisibleTasks();
        for (int i = 0; i < visibleTasks.size(); i++) {
            if (visibleTasks.get(i).equals(BlankLineNode.BLANK_LINE))
                continue; // todo a revoir...
            Task nextTask = (Task) visibleTasks.get(i);
            if (nextTask != null)
                prepareDependencyDrawData(nextTask, result);
        }
        return result;
    }

    private void prepareDependencyDrawData(Task task, List result) {
        TaskDependency[] deps = task.getDependencies().toArray();