Dépôt officiel du code source de l'ERP OpenConcerto

package org.openconcerto.modules.extensionbuilder.menu.mainmenu;

import java.util.Enumeration;
import java.util.List;

import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.MutableTreeNode;
import javax.swing.tree.TreePath;

import org.openconcerto.erp.config.MenuManager;
import org.openconcerto.modules.extensionbuilder.Extension;
import org.openconcerto.modules.extensionbuilder.component.ActivableMutableTreeNode;
import org.openconcerto.ui.group.Group;
import org.openconcerto.ui.group.Item;

public class MenuItemTreeModel extends DefaultTreeModel {

    private boolean showAll = true;
    private Extension extension;

    public MenuItemTreeModel() {
        super(null, false);

    }

    public void setShowAll(boolean b) {
        this.showAll = b;
        System.err.println("MenuItemTreeModel.setShowAll(): " + b);
    }

    public void fillFromDescriptor(Extension extension) {

        if (extension == null) {
            throw new IllegalArgumentException("null extension");
        }
        if (this.extension != null) {
            // this.extension.removeChangeListener(this);
        }
        this.extension = extension;
        // this.extension.addChangeListener(this);
        final Group currentMenuGroup = MenuManager.getInstance().getGroup();
        Group menuGroup = Group.copy(currentMenuGroup, new Group(currentMenuGroup.getId()));

        extension.initMenuGroup(menuGroup);

        final ActivableMutableTreeNode root = new ActivableMutableTreeNode(null);
        root.setActive(true);
        if (menuGroup == null) {
            return;
        }
        // FIXME manque des items...
        System.out.println(MenuManager.getInstance().getGroup().printTree());

        addToTreeNode(root, menuGroup, 0);
        setRoot(root);

    }

    void addToTreeNode(DefaultMutableTreeNode node, Item item, int depth) {
        if (depth > 50) {
            return;
        }
        depth++;
        final ActivableMutableTreeNode newChild = new ActivableMutableTreeNode(item);
        newChild.setActive(isActive(item.getId()));
        if (this.showAll || newChild.isActive()) {
            node.add(newChild);
        }
        if (item instanceof Group) {
            final Group gr = (Group) item;
            final int childCount = gr.getSize();
            for (int i = 0; i < childCount; i++) {
                final Item it = gr.getItem(i);
                addToTreeNode(newChild, it, depth);
            }
            newChild.setAllowsChildren(true);
        } else {
            newChild.setAllowsChildren(false);
        }
    }

    private boolean isActive(String id) {
        List<MenuDescriptor> l = this.extension.getRemoveMenuList();
        for (MenuDescriptor menuDescriptor : l) {
            if (menuDescriptor.getId().equals(id)) {
                return false;
            }
        }
        return true;
    }

    public void toggleActive(TreePath selectionPath) {
        if (selectionPath == null) {
            return;
        }
        final ActivableMutableTreeNode n = (ActivableMutableTreeNode) selectionPath.getLastPathComponent();

        final Item item = (Item) n.getUserObject();
        if (item instanceof Group) {
            // A Group is always active
            return;
        }
        n.setActive(!n.isActive());
        final String id = item.getId();
        setActive(n.isActive(), id);
    }

    public void setActive(boolean active, String id) {
        if (active) {
            this.extension.removeRemoveMenuForId(id);
        } else {
            this.extension.addRemoveMenu(new MenuDescriptor(id));
        }
        this.extension.setChanged();

        DefaultMutableTreeNode n = getNode(id);
        if (n != null) {
            if (n instanceof ActivableMutableTreeNode) {
                ((ActivableMutableTreeNode) n).setActive(active);
            }

            reload(n);
        }

    }

    @Override
    public boolean isLeaf(Object node) {
        final ActivableMutableTreeNode n = (ActivableMutableTreeNode) node;
        if (n.getUserObject() == null)
            return super.isLeaf(node);
        return !(n.getUserObject() instanceof Group);
    }

    @Override
    public void insertNodeInto(MutableTreeNode newChild, MutableTreeNode parent, int index) {
        Item it = (Item) ((DefaultMutableTreeNode) newChild).getUserObject();
        Group g = (Group) ((DefaultMutableTreeNode) parent).getUserObject();
        this.extension.moveMenuItem(it.getId(), g.getId());
        super.insertNodeInto(newChild, parent, index);
        this.extension.setChanged();
    }

    @SuppressWarnings("rawtypes")
    public void renameMenuItem(String previousId, String newId) {
        DefaultMutableTreeNode root = (DefaultMutableTreeNode) this.getRoot();

        for (Enumeration e = root.breadthFirstEnumeration(); e.hasMoreElements();) {
            final DefaultMutableTreeNode current = (DefaultMutableTreeNode) e.nextElement();

            final String idFromNode = getIdFromNode(current);
            if (idFromNode != null && idFromNode.equals(previousId)) {
                setId(current, newId);

                reload(current);

            }
        }

        this.extension.renameMenuItem(previousId, newId);
        this.extension.setChanged();

    }

    private void setId(DefaultMutableTreeNode node, String newId) {
        Object o = node.getUserObject();
        if (o == null)
            return;
        ((Item) o).setId(newId);

    }

    private static String getIdFromNode(DefaultMutableTreeNode node) {
        Object o = node.getUserObject();
        if (o == null)
            return null;
        return ((Item) o).getId();
    }

    @SuppressWarnings("rawtypes")
    public DefaultMutableTreeNode getNode(String id) {
        DefaultMutableTreeNode root = (DefaultMutableTreeNode) this.getRoot();

        for (Enumeration e = root.breadthFirstEnumeration(); e.hasMoreElements();) {
            final DefaultMutableTreeNode current = (DefaultMutableTreeNode) e.nextElement();

            final String idFromNode = getIdFromNode(current);
            if (idFromNode != null && idFromNode.equals(id)) {
                return current;

            }
        }
        return null;
    }
}