categoryeditui.java

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

/*--------------------------------------------------------------------------*
 | 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.edit;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;

import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JColorChooser;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTree;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeCellRenderer;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;

import org.rapla.components.calendar.RaplaArrowButton;
import org.rapla.components.layout.TableLayout;
import org.rapla.components.util.Tools;
import org.rapla.entities.Category;
import org.rapla.entities.CategoryAnnotations;
import org.rapla.framework.RaplaContext;
import org.rapla.framework.RaplaException;
import org.rapla.gui.EditComponent;
import org.rapla.gui.RaplaGUIComponent;
import org.rapla.gui.TreeFactory;
import org.rapla.gui.toolkit.RaplaButton;
import org.rapla.gui.toolkit.RaplaColorList;
import org.rapla.gui.toolkit.RaplaTree;
import org.rapla.gui.toolkit.RaplaWidget;
import org.rapla.gui.toolkit.RecursiveNode;

/**
 *  @author Christopher Kohlhaas
 */
public class CategoryEditUI extends RaplaGUIComponent
    implements
    EditComponent
    ,RaplaWidget
{
    JPanel panel = new JPanel();

    JPanel toolbar = new JPanel();
    RaplaButton newButton = new RaplaButton();
    RaplaButton newSubButton = new RaplaButton();
    RaplaButton removeButton = new RaplaButton();
    RaplaArrowButton moveUpButton = new RaplaArrowButton('^', 25);
    RaplaArrowButton moveDownButton = new RaplaArrowButton('v', 25);

    JCheckBox editAdvanced = new JCheckBox();

    CategoryNode rootNode;
    Category rootCategory;
    CategoryDetail detailPanel;
    RaplaTreeEdit treeEdit;
    DefaultTreeModel model;
    boolean editKeys;
    Listener listener = new Listener();
    TreeCellRenderer iconRenderer;

    public CategoryEditUI(RaplaContext sm) throws RaplaException {
        super( sm);
        detailPanel = new CategoryDetail(sm);
        panel.setPreferredSize( new Dimension( 690,350 ) );
        treeEdit = new RaplaTreeEdit( getI18n(),detailPanel.getComponent(), listener );
        treeEdit.setListDimension( new Dimension( 250,100 ) );
        toolbar.setLayout( new BoxLayout(toolbar, BoxLayout.X_AXIS));
        toolbar.add(newButton);
        toolbar.add(newSubButton);
        toolbar.add( Box.createHorizontalStrut( 5 ));
        toolbar.add(removeButton);
        toolbar.add( Box.createHorizontalStrut( 5 ));
        toolbar.add(moveUpButton);
        toolbar.add(moveDownButton);
        toolbar.add(editAdvanced);
        panel.setLayout( new BorderLayout() );
        toolbar.add( editAdvanced );
        panel.add( toolbar, BorderLayout.NORTH );
        panel.add( treeEdit.getComponent(), BorderLayout.CENTER );

        editAdvanced.setOpaque( false );
        newButton.addActionListener(listener);
        newSubButton.addActionListener(listener);
        removeButton.addActionListener(listener);
        editAdvanced.addActionListener(listener);
        moveUpButton.addActionListener( listener );
        moveDownButton.addActionListener( listener );
        iconRenderer = getTreeFactory().createRenderer();
        treeEdit.getTree().setCellRenderer(  new TreeCellRenderer() {
            public Component getTreeCellRendererComponent(JTree tree
                    ,Object value
                    ,boolean sel
                    ,boolean expanded
                    ,boolean leaf
                    ,int row
                    ,boolean hasFocus
            ) {
                if ( value instanceof CategoryNode) {
                    Category c = (Category) ((CategoryNode)value).getCategory();
                    value = c.getName(getRaplaLocale().getLocale());
                    if (editKeys) {
                        value = "{" + c.getKey() + "} " + value;
                    }
                }
                return iconRenderer.getTreeCellRendererComponent(tree, value, sel, expanded, leaf, row, hasFocus );
            }
        });
        newButton.setText( getString("new_category") );
        newButton.setIcon( getIcon("icon.new"));
        newSubButton.setText( getString("new_sub-category") );
        newSubButton.setIcon( getIcon("icon.new") );
        removeButton.setText( getString("delete") );
        editAdvanced.setText( getString("edit_advanced") );
        removeButton.setIcon( getIcon("icon.delete") );

        detailPanel.addChangeListener( listener );
        detailPanel.setEditKeys( false );

        editAdvanced.setText(getString("edit_advanced"));

    }

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


    class Listener implements ActionListener,ChangeListener {
        public void actionPerformed(ActionEvent evt) {
            try {
                if ( evt.getSource() == newButton ) {
                    createCategory( false );
                } else if ( evt.getSource() == newSubButton ) {
                    createCategory( true );
                } else if ( evt.getSource() == removeButton ) {
                    removeCategory();
                } else if ( evt.getSource() == moveUpButton ) {
                    moveCategory( -1);
                } else if ( evt.getSource() == moveDownButton ) {
                    moveCategory( 1);
                } else if ( evt.getSource() == editAdvanced ) {
                    editKeys = editAdvanced.isSelected();
                    detailPanel.setEditKeys( editKeys );
                    updateModel();
                } else if (evt.getActionCommand().equals("edit")) {
                    detailPanel.mapFrom( treeEdit.getSelectedValue() );
                }
            } catch (RaplaException ex) {
                showException(ex, getComponent());
            }
        }
        public void stateChanged(ChangeEvent e) {
            try {
                confirmEdits();
            } catch (RaplaException ex) {
                showException(ex, getComponent());
            }
        }
    }

    public JComponent getComponent() {
        return panel;
    }

    public int getSelectedIndex() {
        return treeEdit.getSelectedIndex();
    }


    public void setObject(Object o) throws RaplaException {
        if (!(o instanceof Category))
            throw new RaplaException("Only category objects are accepted: " + o.getClass());
        this.rootCategory = (Category)o;
        updateModel();
    }

    private void createCategory(boolean bCreateSubCategory) throws RaplaException {
        confirmEdits();
        Category newCategory;
        RecursiveNode parentNode;
        TreePath path = treeEdit.getTree().getSelectionPath();
        if (path == null) {
            parentNode = rootNode;
        } else {
            RecursiveNode selectedNode = (RecursiveNode) path.getLastPathComponent();
            if (selectedNode.getParent() == null || bCreateSubCategory)
                parentNode = selectedNode;
            else
                parentNode = (RecursiveNode)selectedNode.getParent();
        }
        newCategory = createNewNodeAt( parentNode );
        updateModel();
        RecursiveNode newNode = rootNode.findNodeFor( newCategory );
        TreePath selectionPath = new TreePath( newNode.getPath() );
        treeEdit.getTree().setSelectionPath( selectionPath );
        detailPanel.requestFocus();
    }


    private String createNewKey(Category[] subCategories) {
        int max = 1;
        for (int i=0;i<subCategories.length;i++) {
            String key = subCategories[i].getKey();
            if (key.length()>1
                && key.charAt(0) =='c'
                && Character.isDigit(key.charAt(1))
                )
                {
                    try {
                        int value = Integer.valueOf(key.substring(1)).intValue();
                        if (value >= max)
                            max = value + 1;
                    } catch (NumberFormatException ex) {
                    }
                }
        }
        return "c" + (max);
    }

    // creates a new Category
    private Category createNewNodeAt(RecursiveNode parentNode) throws RaplaException {
        Category newCategory = getModification().newCategory();

        Category parent = ((CategoryNode) parentNode).getCategory();
        newCategory.setKey(createNewKey(parent.getCategories()));

         newCategory.getName().setName(getI18n().getLang(), getString("new_category") );

        parent.addCategory(newCategory);
        getLogger().debug(" new category " + newCategory + " added to " + parent);
        int index = parentNode.getIndexOfUserObject(newCategory);
        if (index <0 )
            throw new RaplaException("Can't insert new Category");
        return newCategory;
    }

    private void removeCategory() throws RaplaException {
        TreePath[] paths = treeEdit.getTree().getSelectionPaths();
        if ( paths == null )
            return;
        CategoryNode[] categoryNodes = new CategoryNode[paths.length];
        for (int i=0;i<paths.length;i++) {
            categoryNodes[i] = (CategoryNode) paths[i].getLastPathComponent();
        }
        removeNodes(categoryNodes);
        updateModel();
    }

    private void moveCategory( int direction ) throws RaplaException
    {
        TreePath[] paths = treeEdit.getTree().getSelectionPaths();
        if ( paths == null || paths.length == 0)
            return;
        CategoryNode categoryNode = (CategoryNode)paths[0].getLastPathComponent();
        if ( categoryNode == null)
        {
            return;
        }