taskrendererimpl.java

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

        for (int i = 0; i < deps.length; i++) {
            TaskDependency next = deps[i];
            TaskDependency.ActivityBinding activityBinding = next
                    .getActivityBinding();
            TaskActivity dependant = activityBinding.getDependantActivity();
            GraphicPrimitiveContainer dependantContainer = getContainerFor(dependant.getTask());
            GraphicPrimitiveContainer.Rectangle dependantRectangle = (Rectangle)dependantContainer
                    .getPrimitive(dependant);
            if (dependantRectangle == null) {
                
                //System.out.println("dependantRectangle == null");
                continue;
            }
            TaskActivity dependee = activityBinding.getDependeeActivity();
            GraphicPrimitiveContainer dependeeContainer = getContainerFor(dependee.getTask());
            GraphicPrimitiveContainer.Rectangle dependeeRectangle = (Rectangle)dependeeContainer
                    .getPrimitive(dependee);
            if (dependeeRectangle == null) {
                //System.out.println("dependeeRectangle == null");
                continue;
            }
            Date[] bounds = activityBinding.getAlignedBounds();
            PointVector dependantVector;
            if (bounds[0].equals(dependant.getStart())) {
                dependantVector = new WestPointVector(new Point(
                        dependantRectangle.myLeftX, dependantRectangle
                                .getMiddleY()));
            } else if (bounds[0].equals(dependant.getEnd())) {
                dependantVector = new EastPointVector(new Point(
                        dependantRectangle.getRightX(), dependantRectangle
                                .getMiddleY()));
            } else {
                throw new RuntimeException();
            }
            //
            PointVector dependeeVector;
            if (bounds[1].equals(dependee.getStart())) {
                dependeeVector = new WestPointVector(new Point(
                        dependeeRectangle.myLeftX, dependeeRectangle
                                .getMiddleY()));
            } else if (bounds[1].equals(dependee.getEnd())) {
                dependeeVector = new EastPointVector(new Point(
                        dependeeRectangle.getRightX(), dependeeRectangle
                                .getMiddleY()));
            } else {
                throw new RuntimeException();
            }
            DependencyDrawData data = new DependencyDrawData(next,
                    dependantRectangle, dependeeRectangle, dependantVector,
                    dependeeVector);
            result.add(data);
        }
    }

    private int getRowHeight() {
        return myModel.getRowHeight();
    }

    private List myActivitiesOutOfView = new ArrayList();
    
    private void pullQueue(Date unitStart, Date unitFinish) {
    	
        for (Iterator activities = myVisibleActivities.iterator(); activities
                .hasNext();) {
            TaskActivity next = (TaskActivity) activities.next();
            if (next.getEnd().before(getChartModel().getStartDate())) {
                myActivitiesOutOfView.add(next);
                activities.remove();
                continue;
            }
            if (next.getStart().before(getChartModel().getStartDate()) && next.getEnd().after(getChartModel().getEndDate())) {
                myCurrentlyProcessed.add(next);
                activities.remove();
                continue;                
            }
            if (next.getStart().after(unitFinish)) {
                break;
            }
            if (next.getStart().compareTo(unitStart) >= 0
                    && next.getStart().compareTo(unitFinish) < 0
                    || next.getEnd().compareTo(unitStart) >= 0
                    && next.getEnd().compareTo(unitFinish) < 0) {
                //System.err.println("pullQueue: \nnextActivity="+next+"\ntask="+next.getTask()+" \nunitStart="+unitStart+" unitFinish="+unitFinish);
                myCurrentlyProcessed.add(next);
                activities.remove();
            }
        }
        // initialize the myPreviousCurrentlyProcessed List
        // each index value matches with the row
        // null value means there is no previous task for this row or
        // the previous task is not between unitStart & unitFinish

        if (myModel.isPrevious()) {
            List visibleTasks = ((ChartModelImpl) getChartModel())
                    .getVisibleTasks();

            for (int i = 0; i < visibleTasks.size(); i++) {
                Task task = (Task) visibleTasks.get(i);
                int index = getPreviousStateTaskIndex(task);
                GPCalendar calendar = myModel.getTaskManager().getCalendar();
                if (index != -1) {
                    GanttPreviousStateTask previousStateTask = (GanttPreviousStateTask) myPreviousStateTasks
                            .get(index);
                    previousStateTask.setState(task, calendar);
                    if (previousStateTask.getStart().after(unitFinish)) {
                        myPreviousStateCurrentlyProcessed.add(null);
                    } else if (previousStateTask.getStart().getTime()
                            .compareTo(unitStart) >= 0
                            && previousStateTask.getStart().getTime()
                                    .compareTo(unitFinish) < 0)
                    // )|| previousStateTask.getEnd(
                    // calendar)
                    // .getTime().compareTo(unitStart) > 0
                    // && previousStateTask.getEnd(
                    // calendar)
                    // .getTime().compareTo(unitFinish) < 0)
                    {
                        myPreviousStateCurrentlyProcessed
                                .add(previousStateTask);
                        myPreviousStateTasks.remove(index);
                    }
                    // if just a part of the previous task is visible
                    else if (previousStateTask.getStart().getTime().compareTo(
                            unitStart) < 0
                            && (previousStateTask.getEnd(calendar).getTime()
                                    .compareTo(unitStart) > 0)) {
                        GanttCalendar newStart = new GanttCalendar(unitStart);
                        int id = previousStateTask.getId();
                        int duration = previousStateTask.getDuration()
                                - newStart.diff(previousStateTask.getStart());
                        int diff = newStart.diff(previousStateTask.getStart());
                        for (int j = 0; j < diff; j++) {
                            if (calendar.isNonWorkingDay(previousStateTask
                                    .getStart().newAdd(j).getTime())) {
                                duration++;
                            }
                        }
                        boolean isMilestone = previousStateTask.isMilestone();
                        boolean hasNested = previousStateTask.hasNested();
                        GanttPreviousStateTask partOfPreviousTask = new GanttPreviousStateTask(
                                id, newStart, duration, isMilestone, hasNested);
                        partOfPreviousTask.setState(task, calendar);
                        partOfPreviousTask.setIsAPart(true);
                        myPreviousStateCurrentlyProcessed
                                .add(partOfPreviousTask);
                        myPreviousStateTasks.remove(index);
                    } else
                        myPreviousStateCurrentlyProcessed.add(null);
                } else
                    myPreviousStateCurrentlyProcessed.add(null);
            }
        }
    }

    // return the index in the List tasks of the previous Task which have the
    // same ID as next
    // return -1 if there is no previous Task with the next ID
    private int getPreviousStateTaskIndex(Task task) {
        if (myPreviousStateTasks == null)
            return -1;
        for (int i = 0; i < myPreviousStateTasks.size(); i++) {
            if (task.getTaskID() == ((GanttPreviousStateTask) myPreviousStateTasks
                    .get(i)).getId())
                return i;
        }
        return -1;
    }

    private static class DependencyDrawData {
        final GraphicPrimitiveContainer.Rectangle myDependantRectangle;

        final GraphicPrimitiveContainer.Rectangle myDependeeRectangle;

        final TaskDependency myDependency;

        final PointVector myDependantVector;

        final PointVector myDependeeVector;

        public DependencyDrawData(TaskDependency dependency,
                GraphicPrimitiveContainer.GraphicPrimitive dependantPrimitive,
                GraphicPrimitiveContainer.GraphicPrimitive dependeePrimitive,
                PointVector dependantVector, PointVector dependeeVector) {
            myDependency = dependency;
            myDependantRectangle = (GraphicPrimitiveContainer.Rectangle) dependantPrimitive;
            myDependeeRectangle = (GraphicPrimitiveContainer.Rectangle) dependeePrimitive;
            myDependantVector = dependantVector;
            myDependeeVector = dependeeVector;
        }

        public String toString() {
            return "From activity="
                    + myDependency.getActivityBinding().getDependantActivity()
                    + " (vector=" + myDependantVector + ")\n to activity="
                    + myDependency.getActivityBinding().getDependeeActivity()
                    + " (vector=" + myDependeeVector;
        }
    }

    private static abstract class PointVector {
        private final Point myPoint;

        protected PointVector(Point point) {
            myPoint = point;
        }

        Point getPoint() {
            return myPoint;
        }

        abstract boolean reaches(Point targetPoint);

        abstract Point getPoint(int i);
    }

    private static class WestPointVector extends PointVector {
        protected WestPointVector(Point point) {
            super(point);
        }

        boolean reaches(Point targetPoint) {
            return targetPoint.x <= getPoint().x;
        }

        Point getPoint(int diff) {
            return new Point(getPoint().x - diff, getPoint().y);
        }

        public String toString() {
            return "<=" + getPoint().toString();
        }

    }

    private static class EastPointVector extends PointVector {
        protected EastPointVector(Point point) {
            super(point);
        }

        boolean reaches(Point targetPoint) {
            return targetPoint.x >= getPoint().x;
        }

        Point getPoint(int diff) {
            return new Point(getPoint().x + diff, getPoint().y);
        }

        public String toString() {
            return ">=" + getPoint().toString();
        }

    }

    public void setProgressRenderingEnabled(boolean renderProgress) {
        myProgressRenderingEnabled = renderProgress;
    }

    public void setDependenciesRenderingEnabled(boolean renderDependencies) {
        myDependenciesRenderingEnabled = renderDependencies;
    }

    public boolean isVisible(int index) {
        return isVisible[index];
    }

    public GPOptionGroup[] getOptionGroups() {
        return myOptionGroups;
    }

    public void setPreviousStateTasks(ArrayList tasks) {
        myTasks = tasks;
    }

    public Rectangle getPrimitive(TaskActivity activity) {
        return (Rectangle) getContainerFor(activity.getTask()).getPrimitive(
                activity);
    }

    private GraphicPrimitiveContainer getContainerFor(Task task) {
        boolean hasNested = ((ChartModelImpl) getChartModel())
                .getTaskContainment().hasNestedTasks(task); // JA Switch to
        return hasNested ? getPrimitiveContainer().getLayer(2)
                : getPrimitiveContainer();
    }

    public void customColumsChange(CustomColumEvent event) {
        int type = event.getType();
        if (type == CustomColumEvent.EVENT_ADD)
            addOption(event.getColName());
        else if (type == CustomColumEvent.EVENT_REMOVE)
            removeOption((event.getColName()));
    }
}