chartmodelimpl.java

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

    public ChartItem getChartItemWithCoordinates(int x, int y) {
    	y = y + getVerticalOffset();
        ChartItem result = findTaskProgressItem(x, y);
        if (result == null) {
            result = findTaskBoundaryItem(x, y);
        }
        return result;
    }

    private ChartItem findTaskProgressItem(int x, int y) {
        ChartItem result = null;
        GraphicPrimitiveContainer.GraphicPrimitive primitive = myTaskRendererImpl
                .getPrimitiveContainer().getLayer(1).getPrimitive(x, 4,
                        y - getChartUIConfiguration().getHeaderHeight(), 0);
        if (primitive instanceof GraphicPrimitiveContainer.Rectangle) {
            GraphicPrimitiveContainer.Rectangle rect = (GraphicPrimitiveContainer.Rectangle) primitive;
            if ("task.progress.end".equals(primitive.getStyle())
                    && rect.getRightX() >= x - 4 && rect.getRightX() <= x + 4) {
                result = new TaskProgressChartItem(x, getBottomUnitWidth(),
                        getBottomUnit(), (Task) primitive.getModelObject());
            }
        }
        return result;
    }

    private ChartItem findTaskBoundaryItem(int x, int y) {
        ChartItem result = null;
        GraphicPrimitiveContainer.GraphicPrimitive primitive = myTaskRendererImpl
                .getPrimitiveContainer().getPrimitive(x,
                        y - getChartUIConfiguration().getHeaderHeight());
        if (primitive==null) {
            primitive = myTaskRendererImpl.getPrimitiveContainer().getLayer(2).getPrimitive(x, y-getChartUIConfiguration().getHeaderHeight()); 
        }        
        if (primitive instanceof GraphicPrimitiveContainer.Rectangle) {
            GraphicPrimitiveContainer.Rectangle rect = (Rectangle) primitive;
            TaskActivity activity = (TaskActivity) primitive.getModelObject();
            if (activity != null) {
                if (activity.isFirst() && rect.myLeftX - 2 <= x
                        && rect.myLeftX + 2 >= x) {
                    result = new TaskBoundaryChartItem(activity.getTask(), true);
                }
                if (result == null && activity.isLast()
                        && rect.myLeftX + rect.myWidth - 2 <= x
                        && rect.myLeftX + rect.myWidth + 2 >= x) {
                    result = new TaskBoundaryChartItem(activity.getTask(),
                            false);
                }
                if (result == null) {
                    result = new TaskRegularAreaChartItem(activity.getTask());
                }
            }
        }
        return result;
    }

    public java.awt.Rectangle getBoundingRectangle(Task task) {
        java.awt.Rectangle result = null;
        TaskActivity[] activities = task.getActivities();
        for (int i = 0; i < activities.length; i++) {
            GraphicPrimitiveContainer.Rectangle nextRectangle = (GraphicPrimitiveContainer.Rectangle) myTaskRendererImpl
                    .getPrimitive(activities[i]);
            if (nextRectangle != null) {
                java.awt.Rectangle nextAwtRectangle = new java.awt.Rectangle(
                        nextRectangle.myLeftX, nextRectangle.myTopY,
                        nextRectangle.myWidth, nextRectangle.myHeight);
                if (result == null) {
                    result = nextAwtRectangle;
                } else {
                    result = result.union(nextAwtRectangle);
                }
            }
        }
        return result;
    }

    GraphicPrimitiveContainer.Rectangle[] getTaskActivityRectangles(Task task) {
        List result = new ArrayList();
        TaskActivity[] activities = task.getActivities();
        for (int i = 0; i < activities.length; i++) {
            GraphicPrimitiveContainer.Rectangle nextRectangle = (GraphicPrimitiveContainer.Rectangle) myTaskRendererImpl
                    .getPrimitive(activities[i]);
            if (nextRectangle!=null) {
                result.add(nextRectangle);
            }
        }
        return (Rectangle[]) result.toArray(new GraphicPrimitiveContainer.Rectangle[0]);
    }
    
    java.util.List/* <Task> */getVisibleTasks() {
        return myVisibleTasks==null ? Collections.EMPTY_LIST : myVisibleTasks;
    }

    /*
     * (non-Javadoc)
     * 
     * @see net.sourceforge.ganttproject.chart.ChartModel#setTaskContainment(net.sourceforge.ganttproject.task.TaskContainmentHierarchyFacade)
     */
    public void setTaskContainment(
            TaskContainmentHierarchyFacade taskContainment) {
        myTaskContainment = taskContainment;
    }

    TaskContainmentHierarchyFacade getTaskContainment() {
        return myTaskContainment;
    }

    public void setTuningOptions(TuningOptions tuningOptions) {
        myTaskRendererImpl
                .setProgressRenderingEnabled(tuningOptions.renderProgress);
        myTaskRendererImpl
                .setDependenciesRenderingEnabled(tuningOptions.renderDependencies);
    }

    public int setRowHeight() {
        boolean textUP = false;
        boolean textDOWN = false;
        isOnlyDown = false;
        isOnlyUp = false;
        // GPOption[] options = myTaskRendererImpl.getOptionGroups()[0]
        //                .getOptions();// HACK: we assume there is at least one option
        // group which is label options group
        
        
//        for (int i = 1; i < options.length; i++) {
//            EnumerationOption nextOption = (EnumerationOption) options[i];
//            if ((LabelPositionOptionImpl.UP.equals(nextOption.getValue()))) {
//                textUP = true;
//            }
//            if ((LabelPositionOptionImpl.DOWN.equals(nextOption.getValue()))) {
//                textDOWN = true;
//            }
//        }
        
        textUP = myTaskRendererImpl.isTextUp();
        textDOWN =myTaskRendererImpl.isTextDown(); 
        
        
        if ((textUP) && (textDOWN)) {
            rowHeight = 40; 
        } else if (textUP) {
            rowHeight = 30;
            isOnlyUp = true;
        } else if (textDOWN) {
            rowHeight = 30;
            isOnlyDown = true;
        } else {
            rowHeight = 20;
        }
        if (isPreviousState)
            rowHeight = rowHeight + 8;
        return rowHeight;
    }

    public boolean isOnlyUp() {
        return isOnlyUp;
    }

    public boolean isOnlyDown() {
        return isOnlyDown;
    }

    public boolean isSelected(int index) {
        return myTaskRendererImpl.isVisible(index);
    }

    public TaskManager getTaskManager() {
        return taskManager;
    }

    public int getRowHeight() {
        return rowHeight;
    }

    public GPOptionGroup[] getChartOptionGroups() {
        GPOptionGroup[] superGroups = super.getChartOptionGroups();
        GPOptionGroup[] rendererGroups = myTaskRendererImpl.getOptionGroups();
        List result = new ArrayList();
        result.addAll(Arrays.asList(superGroups));
        result.addAll(Arrays.asList(rendererGroups));
        result.add(myDefaultColorOptions);
        result.add(myStateDiffOptions);
        return (GPOptionGroup[]) result.toArray(new GPOptionGroup[result.size()]);
    }


    public int setPreviousStateTasks(ArrayList tasks) {
        if (tasks == null)
            isPreviousState = false;
        else
            isPreviousState = true;
        myTaskRendererImpl.setPreviousStateTasks(tasks);
        return (setRowHeight());
    }

    public boolean isPrevious() {
        return isPreviousState;
    }

    public ChartModelBase createCopy() {
        ChartModelBase result = new ChartModelImpl(getTaskManager(), getTimeUnitStack(), getProjectConfig());
        result.myFrameWidthFunction = this.myFrameWidthFunction;
        result.setStartDate(getStartDate());
        return result;
    }

    public boolean isExplicitlyHidden(Task task) {
        return myHiddenTasks==null ? false : myHiddenTasks.contains(task);
    }
    
    
}