MyApplicationTimeline.java

/*
 * Copyright 2008 Jeff Dwyer
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package com.apress.progwt.client.college.gui;

import java.util.Date;
import java.util.List;

import com.allen_sauer.gwt.log.client.Log;
import com.apress.progwt.client.college.ServiceCache;
import com.apress.progwt.client.college.gui.ext.AlertDialog;
import com.apress.progwt.client.college.gui.ext.ContextMenu;
import com.apress.progwt.client.college.gui.ext.H2;
import com.apress.progwt.client.college.gui.timeline.ProcessTimeLineEntry;
import com.apress.progwt.client.college.gui.timeline.ProcessTimeLineObjFactory;
import com.apress.progwt.client.college.gui.timeline.ProcessTimeline;
import com.apress.progwt.client.college.gui.timeline.TimelineController;
import com.apress.progwt.client.domain.Application;
import com.apress.progwt.client.domain.ProcessType;
import com.apress.progwt.client.domain.ProcessValue;
import com.apress.progwt.client.domain.User;
import com.apress.progwt.client.domain.commands.SaveProcessCommand;
import com.apress.progwt.client.domain.commands.SiteCommand;
import com.apress.progwt.client.gui.timeline.TimeLineObj;
import com.apress.progwt.client.gui.timeline.TimeLineObjFactory;
import com.apress.progwt.client.rpc.StdAsyncCallback;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.google.gwt.user.client.ui.ClickListener;
import com.google.gwt.user.client.ui.Composite;
import com.google.gwt.user.client.ui.HorizontalPanel;
import com.google.gwt.user.client.ui.Label;
import com.google.gwt.user.client.ui.VerticalPanel;
import com.google.gwt.user.client.ui.Widget;

/**
 * A MyPageTab tab that display our users application information.
 * Specifically the process information.
 * 
 * @author Jeff Dwyer
 * 
 */
public class MyApplicationTimeline extends Composite implements
        MyPageTab, TimelineController {

    /**
     * Hold all Applications and set the timeline to display the chosen
     * applications.
     * 
     * @author Jeff Dwyer
     * 
     */
    private class AppList extends Composite {
        private VerticalPanel mainPanel;

        private Label selected;

        public AppList() {
            mainPanel = new VerticalPanel();
            initWidget(mainPanel);
            setStylePrimaryName("AppTimelineAppList");
        }

        public void load(User user) {
            lastUser = user;
            List<Application> applications = user.getSchoolRankings();

            mainPanel.clear();
            mainPanel.add(new H2("Applications"));

            for (final Application app : applications) {

                final Label schoolL = new Label(app.getSchool().getName());

                schoolL.setStylePrimaryName("ApplicationSelector");
                schoolL.addClickListener(new ClickListener() {
                    public void onClick(Widget sender) {

                        if (selected != null) {
                            selected.removeStyleDependentName("selected");
                        }
                        selected = schoolL;
                        selected.addStyleDependentName("selected");
                        showApplication(app);

                    }
                });

                mainPanel.add(schoolL);
            }
        }

    }

    /**
     * Hold all ProcessType and create new TLO's when they're chosen.
     * 
     * Make them draggable, so they can eb drgged onto the timeline, but
     * don't make them drggable if they'll be used in the context menu.
     * 
     * @author Jeff Dwyer
     * 
     */
    private class ProcessTypePanel extends Composite {
        private ClickListener allClicks;
        private Date date;
        private VerticalPanel mainPanel;

        public ProcessTypePanel() {
            this(new Date(), null);
        }

        public ProcessTypePanel(Date date, ClickListener allClicks) {
            this.date = date;
            this.allClicks = allClicks;
            mainPanel = new VerticalPanel();
            initWidget(mainPanel);

        }

        public void load(User user) {

            mainPanel.clear();

            mainPanel.add(new H2("Application Events"));

            List<ProcessType> processTypes = user.getProcessTypes();

            for (final ProcessType processType : processTypes) {

                ProcessLabel processLabel = new ProcessLabel(processType,
                        MyApplicationTimeline.this, date);

                if (allClicks != null) {
                    processLabel.addClickListener(allClicks);
                } else {
                    timeline.getDragController().makeDraggable(
                            processLabel);
                }
                mainPanel.add(processLabel);
            }
        }

    }

    private Application currentApplication;

    private User lastUser;

    private ProcessTypePanel processTypePanel;

    private AppList schoolPanel;

    // private User thisUser;
    private ServiceCache serviceCache;

    private ProcessTimeline timeline;

    private TimeLineObjFactory timelineObjFactory = new ProcessTimeLineObjFactory();

    public MyApplicationTimeline(ServiceCache serviceCache) {

        this.serviceCache = serviceCache;

        HorizontalPanel mainP = new HorizontalPanel();        
        VerticalPanel chooserP = new VerticalPanel();

        timeline = new ProcessTimeline(this);

        schoolPanel = new AppList();
        processTypePanel = new ProcessTypePanel();

        chooserP.add(schoolPanel);
        chooserP.add(processTypePanel);

        mainP.add(timeline);
        mainP.add(chooserP);

        initWidget(mainP);

    }

    /**
     * called from double click on the background, we know the date, but
     * need a processtype, use a context menu to get the type, which will
     * callback to addProcess(ProcessType,Date) when selected.
     */
    public void addProcess(Date date, int x, int y) {
        Log.debug("AddProcess(date only) " + date);

        final ContextMenu menu = new ContextMenu(x, y);

        ProcessTypePanel typePanel = new ProcessTypePanel(date,
                new ClickListener() {
                    public void onClick(Widget sender) {
                        menu.hide();
                    }
                });
        typePanel.load(lastUser);

        menu.clear();
        menu.setWidget(typePanel);
        menu.show();
    }

    public void addProcess(ProcessType processType, Date date) {
        Log.debug("AddProcess " + processType + " " + date);
        ProcessValue value = new ProcessValue();
        value.setDueDate(date);

        if (getCurrentApplication() != null) {
            ProcessValue existing = getCurrentApplication().getProcess()
                    .get(processType);

            if (existing != null) {
                AlertDialog
                        .alert("Sorry, that already exists for this application.");
                return;
            }
            saveProcess(processType, value);

            // add before callback returns is fine. We'll just overwrite
            // if they edit.
            timeline.addNew(getCurrentApplication(), processType, value);

        } else {
            AlertDialog.alert("Select an application");
        }

    }

    public void delete(Application application) {
        // TODO Auto-generated method stub

    }

    public Application getCurrentApplication() {
        return currentApplication;
    }

    public String getHistoryName() {
        return "MyApplications";
    }

    public TimeLineObjFactory getTimeLineObjFactory() {
        return timelineObjFactory;
    }

    public void load(User user) {

        timeline.load(user);
        schoolPanel.load(user);
        processTypePanel.load(user);

    }

    public void onTLOChange(TimeLineObj<?> tlo) {
        TimeLineObj<ProcessTimeLineEntry> tlopte = (TimeLineObj<ProcessTimeLineEntry>) tlo;

        SaveProcessCommand command = new SaveProcessCommand(
                getCurrentApplication(), tlopte.getObject()
                        .getProcessType(), tlopte.getObject()
                        .getProcessValue());

        serviceCache.executeCommand(command,
                new AsyncCallback<SiteCommand>() {

                    public void onFailure(Throwable caught) {
                        Log.error("fail");
                    }

                    public void onSuccess(SiteCommand result) {
                        Log.debug("Success");
                    }
                });
        serviceCache.executeCommand(command,
                new StdAsyncCallback<SiteCommand>("Update Process Date") {
                });

    }

    public void refresh() {
        // TODO Auto-generated method stub

    }

    public void saveProcess(ProcessType processType, ProcessValue value) {

        SaveProcessCommand command = new SaveProcessCommand(
                getCurrentApplication(), processType, value);

        serviceCache.executeCommand(command,
                new StdAsyncCallback<SiteCommand>("Save Process") {
                });

    }

    public void setCurrentApplication(Application currentApplication) {
        this.currentApplication = currentApplication;
    }

    public void setSelected(TimeLineObj<?> tlo) {

        timeline.showStatus((TimeLineObj<ProcessTimeLineEntry>) tlo);

    }

    protected void showApplication(Application app) {
        setCurrentApplication(app);
        timeline.showApplication(app);
    }
}