multitiercontrolpanel.java

编辑视频文件

        } else if (command.equals("showThis")) {
            showInTierDependencyFrame(rightClickTier);
        } else if (command.startsWith(TIER_AC)) {
            // a tier visibility checkbox menu item

            /*
               int index = -1;
               try {
                   index = Integer.parseInt(command);
               } catch (NumberFormatException nfe) {}
               if (index < 0 || index >= tiers.size()) {
                   return;
               }
               Tier tier = (Tier) tiers.elementAt(index);
             */
            String tierName = command.substring(TIER_AC.length());

            Tier tier = transcription.getTierWithId(tierName);

            Enumeration nodeEnum = sortedRootNode.preorderEnumeration();

            // skip root node
            nodeEnum.nextElement();

            TierTreeNode node;

            while (nodeEnum.hasMoreElements()) {
                node = (TierTreeNode) nodeEnum.nextElement();

                if (node.getTier() == tier) {
                    node.setVisible(!node.isVisible());

                    break;
                }
            }

            updateDisplayableTiers();
        }
    }

    /**
     * Inform the viewers about the new visible tiers and determine the
     * activeTierIndex.
     *
     * @param visibleTiers the visible tiers
     */
    private void setVisibleTiers(Vector visibleTiers) {
        //this.visibleTiers = visibleTiers;
        //		viewer.setVisibleTiers(visibleTiers);
        for (int i = 0; i < viewers.size(); i++) {
            ((MultiTierViewer) viewers.elementAt(i)).setVisibleTiers(visibleTiers);
        }

        paintBuffer();
    }

    /**
     * Returns the Vector of currently visible tiers. The ordering of the Tiers
     * in the Vector  reflects the order they appear in the
     * MultiTierControlPanel and the connected Viewer.
     *
     * @return a Vector containing the visible Tiers
     */
    public Vector getVisibleTiers() {
        return visibleTiers;
    }

    /**
     * Returns a vector containing the tier names in the order they appear in
     * the panel.
     *
     * @return tier names in a vector in the order they appear on the screen
     */
    public Vector getTierOrder() {
        Vector visibleTierNames = new Vector();

        for (int i = 0; i < visibleTiers.size(); i++) {
            visibleTierNames.add(((Tier) visibleTiers.elementAt(i)).getName());
        }

        return visibleTierNames;
    }

    /**
     * Sets the tiers in a specific order.
     *
     * @param tierNames a Vector containing the ordered names of the tiers
     */
    public void setTierOrder(Vector tierNames) {
        sortMode = UNSORTED; // change the mode to unordered

        if (!unsortedMI.isSelected()) {
            unsortedMI.setSelected(true);
        }

        Vector visTiers = new Vector();
        MenuElement menu = visTiersMenu.getSubElements()[0];
        MenuElement[] items = menu.getSubElements();

        for (int i = 0; i < tierNames.size(); i++) {
            String tierName = (String) tierNames.elementAt(i);

            // add to visible tiers...
            for (int j = 0; j < tiers.size(); j++) {
                if (tierName.equals(((Tier) tiers.elementAt(j)).getName())) {
                    visTiers.add(tiers.elementAt(j));

                    break;
                }
            }
        }

        // update menu items
        for (int k = 0; k < items.length; k++) {
            if (items[k] instanceof JCheckBoxMenuItem) {
                if (tierNames.contains(((JCheckBoxMenuItem) items[k]).getText())) {
                    ((JCheckBoxMenuItem) items[k]).setSelected(true);
                } else {
                    ((JCheckBoxMenuItem) items[k]).setSelected(false);
                }
            }
        }

        visibleTiers = visTiers;
        createSortedTree();

        //setVisibleTiers(visTiers);
    }

    /**
     * Returns the name of the active tier.
     *
     * @return the name of the active tier or null
     */
    public String getActiveTierName() {
        if (activeTier == null) {
            return null;
        }

        return activeTier.getName();
    }

    /**
     * Sets the active tier.
     *
     * @param name the name of the active tier
     */
    public void setActiveTierForName(String name) {
        if (name == null) {
            return;
        }

        for (int i = 0; i < tiers.size(); i++) {
            if (name.equals(((Tier) tiers.elementAt(i)).getName())) {
                setActiveTier((Tier) tiers.elementAt(i));
            }
        }
    }

    /**
     * Sets the mode for the sorting of the tiers.
     *
     * @param mode the sorting mode
     */
    public void setSorting(int mode) {
        int oldSortMode = sortMode;

        if ((mode < UNSORTED) || (mode > SORT_BY_ANNOTATOR)) {
            sortMode = UNSORTED;
        } else {
            sortMode = mode;
        }

        // update the menuitems, if necessary
        switch (sortMode) {
        case UNSORTED:

            if (!unsortedMI.isSelected()) {
                unsortedMI.setSelected(true);
            }

            break;

        case SORT_BY_HIERARCHY:

            if (!sortByHierarchMI.isSelected()) {
                sortByHierarchMI.setSelected(true);
            }

            break;

        case SORT_BY_LINGUISTIC_TYPE:

            if (!sortByTypeMI.isSelected()) {
                sortByTypeMI.setSelected(true);
            }

            break;

        case SORT_BY_PARTICIPANT:

            if (!sortByPartMI.isSelected()) {
                sortByPartMI.setSelected(true);
            }

            break;

        case SORT_BY_ANNOTATOR:

            if (!sortByAnnotMI.isSelected()) {
                sortByAnnotMI.setSelected(true);
            }
        }

        /* When switching from hierarchical to any other sorting,
         * update the visible tiers checkbox menuitems:
         * the expand/collapse feature of the sort_by_hierarchy mode
         * implicitely changes the visibility of tiers.
         * Make this implicit visibility state explicit here.
         */
        if ((oldSortMode == SORT_BY_HIERARCHY) && (sortMode != oldSortMode)) {
            MenuElement menu = visTiersMenu.getSubElements()[0];
            MenuElement[] items = menu.getSubElements();
            Vector visTierNames = new Vector();

            for (int i = 0; i < tiers.size(); i++) {
                Tier t = (Tier) tiers.get(i);

                if (visibleTiers.contains(t)) {
                    visTierNames.add(t.getName());
                }
            }

            for (int i = 0; i < items.length; i++) {
                if (items[i] instanceof JCheckBoxMenuItem) {
                    if (visTierNames.contains(
                                ((JCheckBoxMenuItem) items[i]).getText())) {
                        ((JCheckBoxMenuItem) items[i]).setSelected(true);
                    } else {
                        ((JCheckBoxMenuItem) items[i]).setSelected(false);
                    }
                }
            }
        }

        createSortedTree();
    }

    /**
     * Returns the sorting mode.<br>
     * One of <code>UNSORTED</code>,  <code>SORT_BY_HIERARCHY</code>,
     * <code>SORT_BY_PARTICIPANT</code> or
     * <code>SORT_BY_LINGUISTIC_TYPE</code>.
     *
     * @return the sorting mode
     */
    public int getSorting() {
        return sortMode;
    }

    /**
     * The MultiTierControlPanel is not an ACMEditListener but gets informed of
     * relevant changes by the connected viewer.<br>
     * When a tier is added this panel should update it's list of visible
     * tiers taking into account the current ordering of the tiers and notify
     * the viewer.
     *
     * @param tier the new tier
     */
    public void tierAdded(TierImpl tier) {
        String name;
        JMenuItem menuItem;

        name = tier.getName();

        if (!tierNames.contains(tier)) {
            tierNames.put(tier, name);

            TierTreeNode node = new TierTreeNode(tier);

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

            menuItem = new JCheckBoxMenuItem(name);
            menuItem.setSelected(true);
            menuItem.addActionListener(this);
            menuItem.setActionCommand(TIER_AC + name);
            visTiersMenu.add(menuItem);

            switch (sortMode) {
            case UNSORTED:
                sortedRootNode.add(node);

                break;

            case SORT_BY_HIERARCHY:

                if (tier.getParentTier() == null) {
                    sortedRootNode.add(node);
                } else {
                    Enumeration en = sortedRootNode.preorderEnumeration();

                    // skip root node
                    en.nextElement();

                    TierTreeNode nextNode;

                    while (en.hasMoreElements()) {
                        nextNode = (TierTreeNode) en.nextElement();

                        if (nextNode.getTier() == tier.getParentTier()) {
                            nextNode.add(node);

                            break;
                        }
                    }
                }

                break;

            case SORT_BY_PARTICIPANT:

                String parti = tier.getParticipant();

                // append to the participants group, or to the root
                boolean groupFound = false;
                Enumeration partEnum = sortedRootNode.children();
                TierTreeNode nextNode;
                TierTreeNode lastInGroupNode = null;

                while (partEnum.hasMoreElements()) {
                    nextNode = (TierTreeNode) partEnum.nextElement();

                    if (nextNode.getTier().getParticipant().equals(parti)) {
                        groupFound = true;
                        lastInGroupNode = nextNode;
                    } else {
                        if (groupFound) {
                            ((DefaultMutableTreeNode) lastInGroupNode.getParent()).add(node);

                            break;
                        }
                    }
                }

                if (!groupFound) {
                    sortedRootNode.add(node);
                }

                break;

            case SORT_BY_LINGUISTIC_TYPE:

                LinguisticType type = tier.getLinguisticType();

                // append to the participants group, or to the root
                boolean types