raplaselectionpane.java

来自「Rapla是一个灵活的多用户资源管理系统。它提供的一些功能有：日历GUI」· Java 代码 · 共 361 行

/*--------------------------------------------------------------------------* | Copyright (C) 2006  Christopher Kohlhaas                                 |
 |                                                                          |
 | This program is free software; you can redistribute it and/or modify     |
 | it under the terms of the GNU General Public License as published by the |
 | Free Software Foundation. A copy of the license has been included with   |
 | these distribution in the COPYING file, if not go to www.fsf.org         |
 |                                                                          |
 | As a special exception, you are granted the permissions to link this     |
 | program with every library, which license fulfills the Open Source       |
 | Definition as published by the Open Source Initiative (OSI).             |
 *--------------------------------------------------------------------------*/

package org.rapla.gui.internal;

import java.awt.Font;
import java.awt.Point;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashSet;
import java.util.List;

import javax.swing.BorderFactory;
import javax.swing.BoxLayout;
import javax.swing.JCheckBox;
import javax.swing.JComponent;
import javax.swing.JPanel;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.tree.DefaultTreeModel;

import org.rapla.components.layout.TableLayout;
import org.rapla.entities.Category;
import org.rapla.entities.RaplaType;
import org.rapla.entities.User;
import org.rapla.entities.domain.Permission;
import org.rapla.entities.dynamictype.ClassificationFilter;
import org.rapla.facade.Conflict;
import org.rapla.facade.ModificationEvent;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.MenuContext;
import org.rapla.gui.MenuFactory;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.gui.TreeFactory;
import org.rapla.gui.internal.action.FilterAction;
import org.rapla.gui.internal.action.OnlyMyAction;
import org.rapla.gui.internal.common.CalendarModelImpl;
import org.rapla.gui.internal.common.CalendarSelectionModel;
import org.rapla.gui.internal.common.InternMenus;
import org.rapla.gui.internal.common.MultiCalendarView;
import org.rapla.gui.internal.view.TreeFactoryImpl;
import org.rapla.gui.toolkit.PopupEvent;
import org.rapla.gui.toolkit.PopupListener;
import org.rapla.gui.toolkit.RaplaButton;
import org.rapla.gui.toolkit.RaplaMenu;
import org.rapla.gui.toolkit.RaplaMenuItem;
import org.rapla.gui.toolkit.RaplaPopupMenu;
import org.rapla.gui.toolkit.RaplaTree;
import org.rapla.gui.toolkit.RaplaWidget;


public final class RaplaSelectionPane extends RaplaGUIComponent
    implements
    RaplaWidget
{
    JPanel content = new JPanel();
    JPanel filterFrame = new JPanel();
    RaplaButton filterButton = new RaplaButton();
    public RaplaTree treeSelection = new RaplaTree();
    TableLayout tableLayout;

    CalendarSelectionModel model;
    MultiCalendarView view;
    Listener listener = new Listener();
    RaplaType displayedType = null;
    Conflict[] conflicts = new Conflict[] {};
    OnlyMyAction myAction;
    RaplaMenuItem ownReservations;
    JCheckBox onlyOwnReservations;


    public RaplaSelectionPane(RaplaContext context, MultiCalendarView view, CalendarSelectionModel model) throws RaplaException {
        super( context);


        this.model = model;
        this.view = view;
        double[][] sizes = new double[][] {
            {TableLayout.FILL}
            ,{TableLayout.PREFERRED,TableLayout.PREFERRED,TableLayout.FILL}
        };
        tableLayout= new TableLayout(sizes);
        content.setLayout(tableLayout);
        filterFrame.setLayout( new BoxLayout( filterFrame, BoxLayout.Y_AXIS));
        filterFrame.add( filterButton );
        filterFrame.setBorder( BorderFactory.createEmptyBorder(2,4,0,0));
        //filterFrame.
        onlyOwnReservations = new JCheckBox();
        onlyOwnReservations.setFont( onlyOwnReservations.getFont().deriveFont( Font.PLAIN, (float)10.0 ));
        myAction =new OnlyMyAction( context, model );
        onlyOwnReservations.setAction( myAction );
        onlyOwnReservations.setIcon( getIcon("icon.unchecked"));
        onlyOwnReservations.setSelectedIcon( getIcon("icon.checked"));
        

        //filterFrame.add( my) ;
        //filterFrame.setBorder( BorderFactory.createEmptyBorder(0,0,2,0) );
        content.add("0,0,l,t",filterFrame);
        content.add("0,1",onlyOwnReservations);
        content.add("0,2",treeSelection);
        //content.setPreferredSize(new Dimension(260,400));
        content.setBorder(BorderFactory.createRaisedBevelBorder());

        FilterAction filterAction  = new FilterAction(getContext(), content, null);
        filterAction.setFilter( model );
        filterButton.setAction(filterAction);
        filterAction.addPropertyChangeListener(listener);
        myAction.addPropertyChangeListener( listener );
        treeSelection.setToolTipRenderer(getTreeFactory().createTreeToolTipRenderer());
        treeSelection.setMultiSelect(true);

        RaplaMenu viewMenu = (RaplaMenu)getContext().lookup( InternMenus.VIEW_MENU_ROLE);
        RaplaMenuItem filterMenu = new RaplaMenuItem("filter");
        filterMenu.setAction( filterAction );
        viewMenu.insertBeforeId( filterMenu,"view_save" );

        ownReservations = new RaplaMenuItem("only_own_reservations");
        ownReservations.setText( getString("only_own_reservations"));
        ownReservations.setAction( myAction );
        ownReservations.setIcon( getIcon("icon.unchecked"));
        viewMenu.insertBeforeId( ownReservations, "view_save" );


        updateTree();
        updateSelection();
        treeSelection.addChangeListener(listener);
        treeSelection.addPopupListener(listener);
        javax.swing.ToolTipManager.sharedInstance().registerComponent(treeSelection.getTree());

        updateMenu();
        updateActions();

    }

    private boolean canSeeEventsFromOthers()  {
        try
        {
            Category category = getQuery().getUserGroupsCategory().getCategory(Permission.GROUP_CAN_READ_EVENTS_FROM_OTHERS);
            if ( category == null)
            {
                return true;
            }
            User user = getUser();
            return user.isAdmin() || user.belongsTo( category ) ;
        }
        catch ( RaplaException ex )
        {
            return false;
        }
    }

    private CalendarSelectionModel getModel() {
        return model;
    }

    public void dataChanged(ModificationEvent evt) throws RaplaException {
        updateTree();
        updateMenu();
        updateActions();
    }


    final private TreeFactory getTreeFactory() {
        return (TreeFactory) getService(TreeFactory.ROLE);
    }


    boolean treeListenersEnabled = true;
    /* (non-Javadoc)
     * @see org.rapla.gui.internal.view.ITreeFactory#createClassifiableModel(org.rapla.entities.dynamictype.Classifiable[], org.rapla.entities.dynamictype.DynamicType[])
     */

    private void updateTree() throws RaplaException {

        treeSelection.getTree().setRootVisible( false );
        treeSelection.getTree().setShowsRootHandles( true );
        treeSelection.getTree().setCellRenderer(((TreeFactoryImpl)getTreeFactory()).createComplexRenderer());

        ClassificationFilter[] filter = getModel().getFilter();
        boolean onlyOwn = model.isOnlyCurrentUserSelected();
        User conflictUser = onlyOwn ? getUser() : null;
        DefaultTreeModel treeModel = ((TreeFactoryImpl)getTreeFactory()).createModel( filter, conflictUser );
        try {
            treeListenersEnabled = false;
            treeSelection.exchangeTreeModel(treeModel);
            updateSelection();
        } finally {
            treeListenersEnabled = true;
        }

    }

    private void updateSelection() throws RaplaException {
        Collection selectedObjects = new ArrayList(getModel().getSelectedObjects());
        if ( model.isOnlyCurrentUserSelected() ) {
            selectedObjects.remove( getUser());
        }
        treeSelection.select( selectedObjects );
    }

      public JComponent getComponent() {
        return content;
    }

    class Listener
        implements
        PopupListener
        ,ChangeListener
        ,PropertyChangeListener
    {

        public void showPopup(PopupEvent evt) {
            try {

                Point p = evt.getPoint();
                Object obj = evt.getSelectedObject();
                List list = treeSelection.getSelectedElements();

                MenuContext menuContext = new MenuContext( getContext(), obj,getComponent(),p);
                menuContext.setSelectedObjects( list );

                RaplaPopupMenu menu= new RaplaPopupMenu();

                RaplaMenu newMenu = new RaplaMenu("new");
                newMenu.setText(getString("new"));
                ((MenuFactoryImpl)getMenuFactory()).addNew( newMenu, menuContext, null);

                getMenuFactory().addObjectMenu( menu, menuContext, "EDIT_BEGIN");
                menu.insertAfterId( newMenu, "EDIT_BEGIN" );

                JComponent component = (JComponent) evt.getSource();

                menu.show(component, p.x, p.y);
            } catch (RaplaException ex) {
                showException (ex,getComponent());
            }
        }


        private void applyFilter() throws RaplaException {
            view.getSelectedCalendar().update();
        }


        public void stateChanged(ChangeEvent evt) {
            if ( !treeListenersEnabled) {
                return;
            }
            try
            {
                HashSet elements =new HashSet(treeSelection.getSelectedElements());
                if ( ownReservations.isSelected() ) 
                {
                    elements.add( getUser());
                }
                getModel().setSelectedObjects( elements );
                Object lastSelected = treeSelection.getInfoElement();
                boolean lastClickedElementIsConflict = lastSelected instanceof Conflict;
                if ( lastClickedElementIsConflict)
                {
                    Date[] date = ((CalendarModelImpl)model).getConflictDates();
                    if ( date.length > 0) {
                        if ( model.getStartDate() != null && model.getStartDate().after(date[0])) {
                            model.setStartDate( date[0]);
                        }
                        if ( model.getEndDate() != null && model.getEndDate().before(date[date.length-1])) {
                            model.setEndDate( date[date.length-1]);
                        }
                        model.setSelectedDate( date[0] );
                    }
                }
                updateMenu();
                updateActions();
                applyFilter();
            }
            catch (Exception ex)
            {
                showException(ex, getComponent());
            }
        }


        public void propertyChange(PropertyChangeEvent evt) {
            try
            {
                if (evt.getPropertyName().equals("filter") || evt.getPropertyName().equals("model")) {
                    updateTree();
                    updateActions();
                    applyFilter();
                }
            }
            catch (Exception ex)
            {
                showException(ex,getComponent());
            }
        }
    }

    private void updateActions() {
        if ( !canSeeEventsFromOthers())
        {
            myAction.setEnabled( false );
        }

        boolean oldState = myAction.isEnabled();
        myAction.setEnabled( false );

        boolean isSelected = model.isOnlyCurrentUserSelected();
        ownReservations.setIcon( isSelected ? getIcon("icon.checked"): getIcon("icon.unchecked"));
        onlyOwnReservations.setSelected( isSelected );
        ownReservations.setSelected( isSelected );
        myAction.setEnabled( oldState );
    }

    private void updateMenu() throws RaplaException {
        RaplaMenu editMenu = (RaplaMenu)getService(InternMenus.EDIT_MENU_ROLE );
        RaplaMenu newMenu = (RaplaMenu)getService( InternMenus.NEW_MENU_ROLE );

        editMenu.removeAllBetween( "EDIT_BEGIN", "EDIT_END");
        newMenu.removeAll();

        List list = treeSelection.getSelectedElements();
        Object focusedObject = null;
        if ( list.size() == 1)
        {
            focusedObject = treeSelection.getSelectedElement();
        }

        MenuContext menuContext = new MenuContext( getContext(), focusedObject,getComponent(), null);
        menuContext.setSelectedObjects( list );


        getMenuFactory().addObjectMenu( editMenu, menuContext, "EDIT_BEGIN");
        ((MenuFactoryImpl)getMenuFactory()).addNew(newMenu, menuContext, null);

        newMenu.setEnabled( newMenu.getMenuComponentCount() > 0 && canUserAllocateSomething( getUser()));
        editMenu.setEnabled( canUserAllocateSomething( getUser()));
    }

    public MenuFactory getMenuFactory() {
        return (MenuFactory) getService(MenuFactory.ROLE);
    }


}