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

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * 
 * Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.
 * 
 * The contents of this file are subject to the terms of the GNU General Public License Version 3
 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a
 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific
 * language governing permissions and limitations under the License.
 * 
 * When distributing the software, include this License Header Notice in each file.
 */
 
 package org.openconcerto.ui.group;

import org.openconcerto.utils.Tuple2;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * Allow to customize UI layout.
 * 
 * @author guillaume
 */
public class Group extends Item {

    public static Group copy(final Group g, final Group newParent) {
        return new Group(g, newParent);
    }

    private static final Comparator<Tuple2<Item, Integer>> COMPARATOR = new Comparator<Tuple2<Item, Integer>>() {
        @Override
        public int compare(final Tuple2<Item, Integer> o1, final Tuple2<Item, Integer> o2) {
            int c = o1.get1().compareTo(o2.get1());
            if (c == 0) {
                c = o1.get0().getId().compareTo(o2.get0().getId());
            }
            return c;
        }
    };

    private int order;
    private final List<Tuple2<Item, Integer>> list;

    private String tabId;

    public Group(final String id) {
        this(id, LayoutHints.DEFAULT_GROUP_HINTS);
    }

    public Group(final String id, final LayoutHints hint) {
        super(id, hint);
        this.order = 100;
        this.list = new ArrayList<Tuple2<Item, Integer>>();
    }

    public Group(final Group g, final Group newParent) {
        super(g, newParent);
        this.order = g.order;
        this.list = new ArrayList<Tuple2<Item, Integer>>(g.list.size());
        for (final Tuple2<Item, Integer> t : g.list) {
            final Item copy = Item.copy(t.get0(), this);
            this.list.add(new Tuple2<Item, Integer>(copy, t.get1()));
        }
    }

    public final Group toImmutable() {
        return this.toImmutable(true);
    }

    public final Group toImmutable(final boolean onlyDesc) {
        if (this.isFrozen())
            return this;

        final Group res;
        if (onlyDesc) {
            res = copy(this, null);
            res.freeze();
        } else {
            final List<String> p = this.getAbsolutePath();
            final Group copy = copy(this.getRoot(), null);
            copy.freeze();
            res = copy.followPath(p, false);
        }
        assert res.isFrozen();
        return res;
    }

    @Override
    protected synchronized void _freeze() {
        super._freeze();
        for (final Tuple2<Item, Integer> child : this.list) {
            child.get0()._freeze();
        }
    }

    public Item addItem(final String string) {
        final Item res = new Item(string);
        this.add(res);
        return res;
    }

    public Item addItem(final String string, final LayoutHints hint) {
        final Item res = new Item(string, hint);
        this.add(res);
        return res;
    }

    public void add(final Item item) {
        add(item, this.order);
    }

    public void add(final Item item, final int order) {
        checkFrozen("add");
        item.setParent(this);
        this.list.add(new Tuple2<Item, Integer>(item, order));
        Collections.sort(this.list, COMPARATOR);
        if (this.order <= order) {
            this.order = (order / 100) * 100 + 100;
        }
    }

    public final int getSize() {
        return this.list.size();
    }

    public final boolean isEmpty() {
        return this.list.isEmpty();
    }

    public Item getItem(final int index) {
        return this.list.get(index).get0();
    }

    public Integer getOrder(final int index) {
        return this.list.get(index).get1();
    }

    public boolean contains(final String id) {
        return getDescFromID(id) != null;
    }

    public final Collection<Group> getDescendantGroups() {
        final List<Group> res = new ArrayList<Group>();
        this.getDescendantGroups(res);
        return res;
    }

    protected void getDescendantGroups(final Collection<Group> res) {
        for (final Tuple2<Item, Integer> t : this.list) {
            if (t.get0() instanceof Group) {
                Group g = (Group) t.get0();
                res.add(g);
                g.getDescendantGroups(res);
            }
        }
    }

    @Override
    public final Collection<Item> getDescendantItems() {
        final List<Item> res = new ArrayList<Item>();
        this.getDescendantItems(res);
        return res;
    }

    @Override
    protected void getDescendantItems(final Collection<Item> res) {
        for (final Tuple2<Item, Integer> t : this.list) {
            t.get0().getDescendantItems(res);
        }
    }

    @Override
    public Item getDescFromID(final String id, final int maxLevel) {
        final Item res = super.getDescFromID(id, maxLevel);
        if (res != null || maxLevel == 0)
            return res;
        final int size = this.getSize();
        final int nextLevel = maxLevel < 0 ? maxLevel : maxLevel - 1;
        for (int i = 0; i < size; i++) {
            final Item desc = this.getItem(i).getDescFromID(id, nextLevel);
            if (desc != null) {
                return desc;
            }
        }
        return null;
    }

    /**
     * Get a descendant group.
     * 
     * @param path a list of IDs.
     * @param create <code>true</code> if missing descendant should be created.
     * @return the descendant, or <code>null</code> if <code>create</code> is <code>false</code> and
     *         the descendant is missing.
     */
    public final Group followPath(final List<String> path, final boolean create) {
        final int size = path.size();
        Group g = this;
        for (int i = 0; i < size; i++) {
            final String id = path.get(i);
            final Item child = g.getChildFromID(id);
            if (child instanceof Group) {
                g = (Group) child;
            } else if (child != null) {
                throw new IllegalStateException("ID exists but isn't a group : " + child);
            } else if (create) {
                final Group ng = new Group(id);
                g.add(ng);
                g = ng;
            } else {
                return null;
            }
        }
        return g;
    }

    public void remove(final String itemId) {
        this.remove(this, itemId);
    }

    private void remove(final Group group, final String id) {
        checkFrozen("remove");
        final int size = group.getSize();
        for (int i = 0; i < size; i++) {
            final Item b = group.getItem(i);
            if (b.getId().equals(id)) {
                this.list.remove(i);
                return;
            }
            if (b instanceof Group) {
                remove((Group) b, id);
            }
        }

    }

    public Integer getOrder(final String id) {
        final int size = this.getSize();
        for (int i = 0; i < size; i++) {
            final Tuple2<Item, Integer> b = this.list.get(i);
            if (b.get0().getId().equals(id)) {
                return b.get1();
            }
        }
        return null;
    }

    public int getIndex(final String id) {
        final int size = this.getSize();
        for (int i = 0; i < size; i++) {
            final Tuple2<Item, Integer> b = this.list.get(i);
            if (b.get0().getId().equals(id)) {
                return i;
            }
        }
        return -1;
    }

    public String printTree() {
        final StringBuilder b = new StringBuilder();
        printTree(b, 0, 1);
        return b.toString();
    }

    @Override
    protected void printTree(final StringBuilder builder, final int localOrder, final int level) {
        for (int i = 0; i < level - 1; i++) {
            builder.append("  ");
        }
        builder.append("+-+ ");
        builder.append(localOrder + " " + this.getId() + " [" + this.getLocalHint() + "]\n");
        for (final Tuple2<Item, Integer> tuple : this.list) {
            tuple.get0().printTree(builder, tuple.get1(), level + 1);
        }
    }

    public String printTwoColumns() {
        final StringBuilder b = new StringBuilder("==== Group " + this.getId() + " ====\n");
        printColumns(b, 2, 0, 0, 1);
        return b.toString();
    }

    @Override
    protected int printColumns(final StringBuilder builder, final int width, int x, final int localOrder, final int level) {
        if (this.getLocalHint().isSeparated()) {
            x = 0;
            builder.append(" -------\n");
        }
        if (isEmpty()) {
            // print a leaf
            x = super.printColumns(builder, width, x, localOrder, level);
        } else {
            // Subgroup
            for (final Tuple2<Item, Integer> tuple : this.list) {
                final Item subGroup = tuple.get0();
                final Integer subGroupOrder = tuple.get1();
                x = subGroup.printColumns(builder, width, x, subGroupOrder, level + 1);
            }
        }
        return x;
    }

    @Override
    public boolean equalsDesc(Object obj) {
        if (this == obj)
            return true;
        if (!super.equalsDesc(obj))
            return false;
        if (getClass() != obj.getClass())
            return false;
        final Group other = (Group) obj;
        final int size = this.list.size();
        if (size != other.list.size())
            return false;
        for (int i = 0; i < size; i++) {
            final Tuple2<Item, Integer> thisChild = this.list.get(i);
            final Tuple2<Item, Integer> oChild = other.list.get(i);
            if (!thisChild.get1().equals(oChild.get1()) || !thisChild.get0().equalsDesc(oChild.get0()))
                return false;
        }
        return true;
    }

    public void setTabId(String tabId) {
        this.tabId = tabId;
    }

    public String getTabId() {
        return this.tabId;
    }
}