multitiercontrolpanel.java

编辑视频文件

            showHideMoreMI.setActionCommand("showHideMore");
            showHideMoreMI.addActionListener(this);
            visTiersMenu.add(showHideMoreMI);
            visTiersMenu.addSeparator();

            String tierName;
            JMenuItem menuItem;

            for (int i = 0; i < tiers.size(); i++) {
                TierImpl tier = (TierImpl) tiers.elementAt(i);
                tierName = tier.getName();
                tierNames.put(tier, tierName);

                if (tier.getParentTier() == null) {
                    addToRootColors(tier);
                }

                /*
                   System.out.println("Tier: " + tier.getName());
                   System.out.println("\t\tParent: " + tier.getParent());
                   if (tier instanceof TierImpl) {
                       TierImpl tImpl = (TierImpl)tier;
                       System.out.println("\t\tParticipant: " + tImpl.getParticipant());
                       System.out.println("\t\tLinguistic Type: " + tImpl.getLinguisticType());
                       System.out.println("\t\tHas Parent: " + tImpl.hasParentTier());
                       System.out.println("\t\tParent Tier: " + tImpl.getParentTier());
                       System.out.println("\t\tRoot: " + tImpl.getRootTier());
                   }
                 */
                menuItem = new JCheckBoxMenuItem(tierName);
                menuItem.setSelected(true);

                menuItem.setActionCommand(TIER_AC + tierName);

                // use an index because maybe a tier name is not unique?
                // a tiername should be unique...
                //menuItem.setActionCommand(Integer.toString(i));
                menuItem.addActionListener(this);
                visTiersMenu.add(menuItem);

                visibleTiers.add(tier);
            }

            sortTiersMenu = new JMenu();

            ButtonGroup sortGroup = new ButtonGroup();
            unsortedMI = new JRadioButtonMenuItem();
            unsortedMI.setActionCommand("unsorted");
            unsortedMI.addActionListener(this);
            sortGroup.add(unsortedMI);
            sortTiersMenu.add(unsortedMI);
            sortByHierarchMI = new JRadioButtonMenuItem();
            sortByHierarchMI.setActionCommand("sortHier");
            sortByHierarchMI.addActionListener(this);
            sortGroup.add(sortByHierarchMI);
            sortTiersMenu.add(sortByHierarchMI);
            sortByTypeMI = new JRadioButtonMenuItem();
            sortByTypeMI.setActionCommand("sortType");
            sortByTypeMI.addActionListener(this);
            sortGroup.add(sortByTypeMI);
            sortTiersMenu.add(sortByTypeMI);
            sortByPartMI = new JRadioButtonMenuItem();
            sortByPartMI.setActionCommand("sortPart");
            sortByPartMI.addActionListener(this);
            sortGroup.add(sortByPartMI);
            sortTiersMenu.add(sortByPartMI);
            sortByAnnotMI = new JRadioButtonMenuItem();
            sortByAnnotMI.setActionCommand("sortAnn");
            sortByAnnotMI.addActionListener(this);
            sortGroup.add(sortByAnnotMI);
            sortTiersMenu.add(sortByAnnotMI);

            switch (sortMode) {
            case UNSORTED:
                unsortedMI.setSelected(true);

                break;

            case SORT_BY_HIERARCHY:
                sortByHierarchMI.setSelected(true);

                break;

            case SORT_BY_PARTICIPANT:
                sortByPartMI.setSelected(true);

                break;

            case SORT_BY_LINGUISTIC_TYPE:
                sortByTypeMI.setSelected(true);

                break;
            }

            popup.add(sortTiersMenu);
            popup.addSeparator();

            hideMI = new JMenuItem();
            hideMI.setActionCommand("hideThis");
            hideMI.addActionListener(this);
            hideMI.setEnabled(false);
            popup.add(hideMI);
            changeMI = new JMenuItem();
            changeMI.setActionCommand("changeThis");
            changeMI.addActionListener(this);
            changeMI.setEnabled(false);
            popup.add(changeMI);
            deleteMI = new JMenuItem();
            deleteMI.setActionCommand("deleteThis");
            deleteMI.addActionListener(this);
            deleteMI.setEnabled(false);
            popup.add(deleteMI);
            colOrExpMI = new JMenuItem();
            colOrExpMI.setActionCommand("toggleExpandThis");
            colOrExpMI.addActionListener(this);
            colOrExpMI.setEnabled(false);
            popup.add(colOrExpMI);
            showHierMI = new JMenuItem();
            showHierMI.setActionCommand("showThis");
            showHierMI.addActionListener(this);
            showHierMI.setEnabled(false);
            popup.add(showHierMI);

            setVisibleTiers(visibleTiers);

            updateLocale();

            createSortedTree();

            if (visibleTiers.size() > 0) {
                setActiveTier((Tier) visibleTiers.get(0));
            }

            paintBuffer();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * Creates a node hierarchy depending on the current sorting mode.
     */
    private void createSortedTree() {
        // create a list based on the current preferred order
        ArrayList tierList = new ArrayList(visibleTiers);

        for (int i = 0; i < tiers.size(); i++) {
            TierImpl tier = (TierImpl) tiers.elementAt(i);

            if (!tierList.contains(tier)) {
                tierList.add(tier);
            }
        }

        sortedRootNode = new DefaultMutableTreeNode("sortRoot");

        switch (sortMode) {
        case SORT_BY_HIERARCHY:

            HashMap nodes = new HashMap();

            for (int i = 0; i < tierList.size(); i++) {
                TierImpl tier = (TierImpl) tierList.get(i);
                TierTreeNode n = new TierTreeNode(tier);

                if ((activeTier != null) && (activeTier == tier)) {
                    n.setActive(true);
                }

                if (!visibleTiers.contains(tier)) {
                    n.setVisible(false);
                }

                nodes.put(tier, n);
            }

            for (int i = 0; i < tierList.size(); i++) {
                TierImpl tier = (TierImpl) tierList.get(i);

                if (tier.getParentTier() == null) {
                    sortedRootNode.add((TierTreeNode) nodes.get(tier));
                } else {
                    ((TierTreeNode) nodes.get(tier.getParentTier())).add((TierTreeNode) nodes.get(
                            tier));
                }
            }

            break;

        case SORT_BY_PARTICIPANT:

            HashMap participantMap = new HashMap();

            for (int i = 0; i < tierList.size(); i++) {
                TierImpl tier = (TierImpl) tierList.get(i);

                TierTreeNode n = new TierTreeNode(tier);

                if ((activeTier != null) && (activeTier == tier)) {
                    n.setActive(true);
                }

                if (!visibleTiers.contains(tier)) {
                    n.setVisible(false);
                }

                String part = tier.getParticipant();

                if (part.length() == 0) {
                    part = NOT_SPECIFIED;
                }

                if (participantMap.get(part) == null) {
                    ArrayList list = new ArrayList();
                    list.add(n);
                    participantMap.put(part, list);
                } else {
                    ((ArrayList) participantMap.get(part)).add(n);
                }
            }

            if (participantMap.size() > 0) {
                Set keys = participantMap.keySet();
                List names = new ArrayList(keys);
                Collections.sort(names);

                for (int j = 0; j < names.size(); j++) {
                    ArrayList pList = (ArrayList) participantMap.get(names.get(
                                j));

                    for (int k = 0; k < pList.size(); k++) {
                        sortedRootNode.add((TierTreeNode) pList.get(k));
                    }
                }
            }

            break;

        case SORT_BY_ANNOTATOR:

            HashMap annotMap = new HashMap();

            for (int i = 0; i < tierList.size(); i++) {
                TierImpl tier = (TierImpl) tierList.get(i);

                TierTreeNode n = new TierTreeNode(tier);

                if ((activeTier != null) && (activeTier == tier)) {
                    n.setActive(true);
                }

                if (!visibleTiers.contains(tier)) {
                    n.setVisible(false);
                }

                String annot = tier.getAnnotator();

                if ((annot == null) || (annot.length() == 0)) {
                    annot = NOT_SPECIFIED;
                }

                if (annotMap.get(annot) == null) {
                    ArrayList list = new ArrayList();
                    list.add(n);
                    annotMap.put(annot, list);
                } else {
                    ((ArrayList) annotMap.get(annot)).add(n);
                }
            }

            if (annotMap.size() > 0) {
                Set keys = annotMap.keySet();
                List names = new ArrayList(keys);
                Collections.sort(names);

                for (int j = 0; j < names.size(); j++) {
                    ArrayList pList = (ArrayList) annotMap.get(names.get(j));

                    for (int k = 0; k < pList.size(); k++) {
                        sortedRootNode.add((TierTreeNode) pList.get(k));
                    }
                }
            }

            break;

        case SORT_BY_LINGUISTIC_TYPE:

            HashMap typeMap = new HashMap();

            for (int i = 0; i < tierList.size(); i++) {
                TierImpl tier = (TierImpl) tierList.get(i);

                TierTreeNode n = new TierTreeNode(tier);

                if ((activeTier != null) && (activeTier == tier)) {
                    n.setActive(true);
                }

                if (!visibleTiers.contains(tier)) {
                    n.setVisible(false);
                }

                LinguisticType type = tier.getLinguisticType();

                if (type == null) {
                    type = new LinguisticType(NOT_SPECIFIED);
                }

                if (typeMap.get(type) == null) {
                    ArrayList list = new ArrayList();
                    list.add(n);
                    typeMap.put(type, list);
                } else {
                    ((ArrayList) typeMap.get(type)).add(n);
                }
            }

            if (typeMap.size() > 0) {
                //Set vals = typeMap.entrySet();
                Iterator typeIt = typeMap.values().iterator();

                while (typeIt.hasNext()) {
                    ArrayList typeList = (ArrayList) typeIt.next();

                    for (int k = 0; k < typeList.size(); k++) {
                        sortedRootNode.add((TierTreeNode) typeList.get(k));

                        //System.out.println("type sort node added: " + k + " " + ((TierTreeNode)typeList.get(k)).getTierName());
                    }
                }
            }

            break;

        case UNSORTED:
        // fallthrough default order
        default:

            for (int i = 0; i < tierList.size(); i++) {
                TierImpl tier = (TierImpl) tierList.get(i);

                TierTreeNode n = new TierTreeNode(tier);

                if ((activeTier != null) && (activeTier == tier)) {
                    n.setActive(true);
                }

                if (!visibleTiers.contains(tier)) {
                    n.setVisible(false);
                }

                sortedRootNode.add(n);
            }
        }

        // update the visibletiers and displayablenodes vector
        updateDisplayableTiers();
    }

    /**