taskimpl.java

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

        public void shift(TaskLength shift) {
            TaskImpl.this.shift(shift);
        }

        public void setIsolationLevel(int level) {
            myIsolationLevel = level;
        }

        private void cachePrecomputedShift(Task result, float unitCount) {
        }

        private Task getPrecomputedShift(float unitCount) {
            return null;
        }

        private TaskInfo myTaskInfo;

        public TaskInfo getTaskInfo() {
            return myTaskInfo;
        }

        public void setTaskInfo(TaskInfo taskInfo) {
            myTaskInfo = taskInfo;

        }

    }

    public void setName(String name) {

        myName = name;
    }

    public void setWebLink(String webLink) {

        myWebLink = webLink;
    }

    public void setMilestone(boolean milestone) {
        isMilestone = milestone;
    }

    public void setPriority(int priority) {
        myPriority = priority;
    }

    public void setStart(GanttCalendar start) {
        Date closestWorkingStart = myManager.findClosestWorkingTime(start
                .getTime());
        start.setTime(closestWorkingStart);
        GanttCalendar oldStart = myStart == null ? null : myStart.Clone();
        myStart = start;
        GanttCalendar oldEnd = getEnd();
        
        //if (myID>=0) {
            recalculateActivities();
        //}
    }

    private void adjustNestedTasks() {
        try {
            assert myManager!=null;
            AlgorithmCollection algorithmCollection = myManager.getAlgorithmCollection();
            if (algorithmCollection!=null) {
                algorithmCollection.getAdjustTaskBoundsAlgorithm().adjustNestedTasks(this);
            }
        } catch (TaskDependencyException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
    public boolean isSupertask() {
        return myManager.getTaskHierarchy().hasNestedTasks(this);
    }

    public void setEnd(GanttCalendar end) {
        GanttCalendar oldFinish = myEnd == null ? null : myEnd.Clone();
        myEnd = end;
        recalculateActivities();
        // System.err.println("we have "+myActivities.size()+" activities");
//        if (areEventsEnabled()) {
//            myManager.fireTaskScheduleChanged(this, myStart.Clone(), oldFinish);
//        }
    }

    public void setThirdDate(GanttCalendar third) {
        GanttCalendar oldThird = myThird == null ? null : myThird.Clone();
        myThird = third;
        // recalculateActivities();
        // if (areEventsEnabled()) {
        // myManager.fireTaskScheduleChanged(this, myThird.Clone(), oldThird);
        // }
    }

    public void setThirdDateConstraint(int thirdDateConstraint) {
        myThirdDateConstraint = thirdDateConstraint;
    }

    public void shift(TaskLength shift) {
        float unitCount = shift.getLength(myLength.getTimeUnit());
        if (unitCount != 0f) {
            Task resultTask = shift(unitCount);
            GanttCalendar oldStart = myStart;
            GanttCalendar oldEnd = myEnd;
            myStart = resultTask.getStart();
            myLength = resultTask.getDuration();
            myEnd = resultTask.getEnd();
            if (areEventsEnabled()) {
                myManager.fireTaskScheduleChanged(this, oldStart, oldEnd);
            }
            recalculateActivities();
        }
    }

    public Task shift(float unitCount) {
        Task clone = unpluggedClone();
        if (unitCount > 0) {
            TaskLength length = myManager.createLength(myLength.getTimeUnit(),
                    unitCount);
            // clone.setDuration(length);
            Date shiftedDate = shiftDate(myStart.getTime(), length
                    .getTimeUnit(), length.getLength(), RESTLESS_CALENDAR);
            clone.setStart(new GanttCalendar(shiftedDate));
            clone.setDuration(myLength);
        } else {
            Date newStart = shiftDate(clone.getStart().getTime(), clone
                    .getDuration().getTimeUnit(), (long) unitCount);
            clone.setStart(new GanttCalendar(newStart));
            clone.setDuration(myLength);
        }
        return clone;
    }

    public void setDuration(TaskLength length) {
        assert length.getLength()>0;
    	
        //GanttCalendar oldFinish = myEnd == null ? null : myEnd.Clone();
        myLength = length;
        myEnd=null;
//            Date newEndDate = shiftDate(myStart.getTime(),
//                    length.getTimeUnit(), length.getLength());

            //myEnd = new GanttCalendar(newEndDate);
            // myEnd = myStart.newAdd((int) length.getLength());
            recalculateActivities();
//            if (areEventsEnabled()) {
//                myManager.fireTaskScheduleChanged(this, myStart.Clone(),
//                        oldFinish);
//            }


    }

    private Date shiftDate(Date input, TimeUnit timeUnit, long length) {
        return shiftDate(input, timeUnit, length, myManager.getConfig()
                .getCalendar());
    }

    private Date shiftDate(Date input, TimeUnit timeUnit, long length,
            GPCalendar calendar) {
        List activities = calendar.getActivities(input, timeUnit, length);
        if (activities.isEmpty()) {
            throw new RuntimeException("Can't set length=" + length + " start="
                    + input);
        }
        Date result;
        if (length >= 0) {
            GPCalendarActivity lastActivity = (GPCalendarActivity) activities
                    .get(activities.size() - 1);
            result = lastActivity.getEnd();
        } else {
            GPCalendarActivity firstActivity = (GPCalendarActivity) activities
                    .get(0);
            result = firstActivity.getStart();
        }
        return result;
    }

    public TaskLength translateDuration(TaskLength duration) {
        return myManager.createLength(myLength.getTimeUnit(),
                translateDurationValue(duration));
    }

    private float translateDurationValue(TaskLength duration) {
        if (myLength.getTimeUnit().equals(duration.getTimeUnit())) {
            return duration.getValue();
        }
        if (myLength.getTimeUnit().isConstructedFrom(duration.getTimeUnit())) {
            return duration.getValue()
                    / myLength.getTimeUnit().getAtomCount(
                            duration.getTimeUnit());
        }
        if (duration.getTimeUnit().isConstructedFrom(myLength.getTimeUnit())) {
            return duration.getValue()
                    * duration.getTimeUnit().getAtomCount(
                            myLength.getTimeUnit());
        }
        throw new RuntimeException("Can't transalte duration=" + duration
                + " into units=" + myLength.getTimeUnit());
    }

    private void recalculateActivities() {
        if (myLength == null || myManager == null) {
            return;
        }
        recalculateActivities(myActivities, myStart.getTime(), getEnd().getTime());
        int length = 0;
        for (int i = 0; i < myActivities.size(); i++) {
            TaskActivity next = (TaskActivity) myActivities.get(i);
            if (next.getIntensity() > 0) {
                length += next.getDuration().getLength(
                        getDuration().getTimeUnit());
            }
        }
        myLength = getManager().createLength(myLength.getTimeUnit(), length);
    }

    private void recalculateActivities(List output, Date startDate, Date endDate) {
        GPCalendar calendar = myManager.getConfig().getCalendar();
        List activities = calendar.getActivities(startDate, endDate, myLength.getTimeUnit());
        output.clear();
        for (int i = 0; i < activities.size(); i++) {
            GPCalendarActivity nextCalendarActivity = (GPCalendarActivity) activities
                    .get(i);
            TaskActivityImpl nextTaskActivity;
            if (nextCalendarActivity.isWorkingTime()) {
                nextTaskActivity = new TaskActivityImpl(this,
                        nextCalendarActivity.getStart(), nextCalendarActivity
                                .getEnd());
            } else if (i > 0 && i + 1 < activities.size()) {
                nextTaskActivity = new TaskActivityImpl(this,
                        nextCalendarActivity.getStart(), nextCalendarActivity
                                .getEnd(), 0);
            } else {
                continue;
            }
            output.add(nextTaskActivity);
        }
    }

    public void setCompletionPercentage(int percentage) {
        int oldPercentage = myCompletionPercentage;
        myCompletionPercentage = percentage;
        if (oldPercentage != myCompletionPercentage) {
            EventSender progressEventSender = new ProgressEventSender();
            progressEventSender.enable();
            progressEventSender.fireEvent();
        }
    }

//    public void setStartFixed(boolean isFixed) {
//        isStartFixed = isFixed;
//    }

//    public void setFinishFixed(boolean isFixed) {
//        isFinishFixed = isFixed;
//    }

    public void setShape(ShapePaint shape) {
        myShape = shape;
    }

    public void setColor(Color color) {
        myColor = color;
    }

    public void setNotes(String notes) {
        myNotes = notes;
    }

    public void setExpand(boolean expand) {
        bExpand = expand;
    }

    public void addNotes(String notes) {
        myNotes += notes;
    }

    protected void enableEvents(boolean enabled) {
        myEventsEnabled = enabled;
    }

    protected boolean areEventsEnabled() {
        return myEventsEnabled;
    }

    /**
     * Allows to determine, if a special shape is defined for this task.
     * 
     * @return true, if this task has its own shape defined.
     */
    public boolean shapeDefined() {
        return (myShape != null);
    }

    /**
     * Allows to determine, if a special color is defined for this task.
     * 
     * @return true, if this task has its own color defined.
     */

    public boolean colorDefined() {

        return (myColor != null);

    }

    public String toString() {
        //return myID + ": " + myStart.getTime() + "-" + myLength;
    	return getName();
    }

    public boolean isUnplugged() {
        return myTaskHierarchyItem == null;
    }

    /**
     * Returns the CustomColumnValues.
     * 
     * @return The CustomColumnValues.
     */
    public CustomColumnsValues getCustomValues() {
        return customValues;
    }

    /**
     * @inheritDoc
     */
    public void setCritical(boolean critical) {
        this.critical = critical;
    }

    /**
     * @inheritDoc
     */
    public boolean isCritical() {
        return this.critical;
    }

    // TODO: implementation of this method has no correlation with algorithms
    // recalculating schedules,
    // doesn't affect subtasks and supertasks. It is necessary to call this
    // method explicitly from other
    // parts of code to be sure that constraint fulfils
    //
    // Method GanttCalendar.newAdd() assumes that time unit is day
    public void applyThirdDateConstraint() {
        TaskLength length = getDuration();
        if (getThird() != null)
            switch (getThirdDateConstraint()) {
            case EARLIESTBEGIN:
                // TODO: TIME UNIT (assumption about days)
                if (getThird().after(getStart())) {
                    int difference = getThird().diff(getStart());
                    GanttCalendar _start = getStart().newAdd(difference);
                    GanttCalendar _end = getEnd().newAdd(difference);
                    setEnd(_end);
                    setStart(_start);
                    setDuration(length);
                }
                break;
            }
    }

    private TaskInfo myTaskInfo;

    public TaskInfo getTaskInfo() {
        return myTaskInfo;
    }

    public void setTaskInfo(TaskInfo taskInfo) {
        myTaskInfo = taskInfo;

    }

    public boolean isProjectTask() {
        return isProjectTask;
    }

    public void setProjectTask(boolean projectTask) {
        isProjectTask = projectTask;
    }

    private static final GPCalendar RESTLESS_CALENDAR = new AlwaysWorkingTimeCalendarImpl();

}