multitiercontrolpanel.java

编辑视频文件

     * Updates the visibleTiers vector and the Vector with the (flattened) tier
     * nodes.
     */
    private void updateDisplayableTiers() {
        Vector dispTiers = new Vector();
        visibleTiers.clear();
        displayableTierNodes.clear();

        if ((sortMode == SORT_BY_HIERARCHY) &&
                (sortedRootNode.getChildCount() > 0)) {
            int level = -1;
            TierTreeNode curNode = (TierTreeNode) sortedRootNode.getFirstChild();
            DefaultMutableTreeNode parent = null;
mainloop: 
            while (level != 0) {
                if (curNode.isVisible()) {
                    visibleTiers.add(curNode.getTier());
                    displayableTierNodes.add(curNode);
                    dispTiers.add(curNode.getTier());

                    if ((curNode.getChildCount() > 0) && curNode.isExpanded()) {
                        curNode = (TierTreeNode) curNode.getFirstChild();
                        level = curNode.getLevel();

                        continue mainloop;
                    } else {
                        // no children or children are not displayable because node is collapsed,
                        // traverse up
                        parent = (DefaultMutableTreeNode) curNode.getParent();
                    }
                } else {
                    // not visible; skip the children of this node, traverse up
                    parent = (DefaultMutableTreeNode) curNode.getParent();
                }

uploop: 
                while (true) {
                    if (parent.getChildAfter(curNode) != null) {
                        curNode = (TierTreeNode) parent.getChildAfter(curNode);

                        continue mainloop;
                    } else if (parent == sortedRootNode) {
                        // the rootnode does not have more children
                        break mainloop;
                    } else {
                        curNode = (TierTreeNode) parent;
                        level = curNode.getLevel();
                        parent = (DefaultMutableTreeNode) curNode.getParent();

                        continue uploop;
                    }
                }
            }
        } else {
            Enumeration nodeEnum = sortedRootNode.children();
            TierTreeNode cn = null;

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

                if (cn.isVisible()) {
                    visibleTiers.add(cn.getTier());
                    displayableTierNodes.add(cn);
                    dispTiers.add(cn.getTier());
                }
            }
        }

        /*
           if (displayableTiers != null) {
               Enumeration e = displayableTiers.elements();
               while (e.hasMoreElements()) {
                   TierImpl t = (TierImpl)e.nextElement();

                   System.out.println("Dis. Tier: " + t.getName());

               }
           }
         */
        setVisibleTiers(dispTiers);
    }

    /**
     * Adds the MultiTier Viewer items to the popup (when neccessary) and
     * enables / disables menu items depending on the characteristics of  the
     * specified tier.
     *
     * @param tier the tier
     */
    private void updatePopup(TierImpl tier) {
        if (timelineMI == null) {
            ButtonGroup multitierViewerGroup = new ButtonGroup();
            timelineMI = new JRadioButtonMenuItem(ELANCommandFactory.getCommandAction(
                        transcription, ELANCommandFactory.SHOW_TIMELINE));
            interlinearMI = new JRadioButtonMenuItem(ELANCommandFactory.getCommandAction(
                        transcription, ELANCommandFactory.SHOW_INTERLINEAR));

            // default
            //timelineMI.setSelected(true);
            multitierViewerGroup.add(timelineMI);
            multitierViewerGroup.add(interlinearMI);
            viewerMenu.add(timelineMI);
            viewerMenu.add(interlinearMI);

            if (viewer instanceof TimeLineViewer) {
                timelineMI.setSelected(true);
            } else if (viewer instanceof InterlinearViewer) {
                interlinearMI.setSelected(true);
            }
        }

        if (tier != null) {
            String name = tier.getName();

            if ((name != null) && (name.length() > 0)) {
                hideMI.setText("<html>" +
                    ElanLocale.getString(
                        "MultiTierControlPanel.Menu.ThisTier.Hide") + " " +
                    "<i>" + name + "</i></html>");
                changeMI.setText("<html>" +
                    ElanLocale.getString(
                        "MultiTierControlPanel.Menu.ThisTier.Change") + " " +
                    "<i>" + name + "</i></html>");
                deleteMI.setText("<html>" +
                    ElanLocale.getString(
                        "MultiTierControlPanel.Menu.ThisTier.Delete") + " " +
                    "<i>" + name + "</i></html>");

                if (sortMode == SORT_BY_HIERARCHY) {
                    colOrExpMI.setText("<html>" +
                        ElanLocale.getString(
                            "MultiTierControlPanel.Menu.ThisTier.CollapseExpand") +
                        " " + "<i>" + name + "</i></html>");
                    colOrExpMI.setEnabled(true);
                } else {
                    colOrExpMI.setText(ElanLocale.getString(
                            "MultiTierControlPanel.Menu.ThisTier.CollapseExpand"));
                    colOrExpMI.setEnabled(false);
                }

                hideMI.setEnabled(true);
                changeMI.setEnabled(true);
                deleteMI.setEnabled(true);
                showHierMI.setEnabled(true);
            }
        } else {
            hideMI.setText(ElanLocale.getString(
                    "MultiTierControlPanel.Menu.ThisTier.Hide"));
            changeMI.setText(ElanLocale.getString(
                    "MultiTierControlPanel.Menu.ThisTier.Change"));
            deleteMI.setText(ElanLocale.getString(
                    "MultiTierControlPanel.Menu.ThisTier.Delete"));
            colOrExpMI.setText(ElanLocale.getString(
                    "MultiTierControlPanel.Menu.ThisTier.CollapseExpand"));
            hideMI.setEnabled(false);
            changeMI.setEnabled(false);
            deleteMI.setEnabled(false);
            colOrExpMI.setEnabled(false);
            showHierMI.setEnabled(false);
        }

        if (sortMode == SORT_BY_HIERARCHY) {
            expandAllMI.setEnabled(true);
            collapseAllMI.setEnabled(true);
        } else {
            expandAllMI.setEnabled(false);
            collapseAllMI.setEnabled(false);
        }
    }

    /**
     * Returns the y positions of the visible tiers.
     *
     * @param tierPositions the y positions of the tiers
     */
    public void setTierPositions(int[] tierPositions) {
        this.tierPositions = tierPositions;

        if (tierPositions.length > 1) {
            tierHeight = tierPositions[1] - tierPositions[0];
        }

        paintBuffer();
    }

    /**
     * DOCUMENT ME!
     *
     * @param e DOCUMENT ME!
     */
    public void mouseClicked(MouseEvent e) {
        if (SwingUtilities.isRightMouseButton(e) || e.isPopupTrigger()) {
            return;
        }

        Point p = e.getPoint();

        if (SwingUtilities.isLeftMouseButton(e) && (e.getClickCount() > 1)) {
            // define the active tier
            int index = getClosestTierIndexForMouseY(p.y);
            TierTreeNode node = (TierTreeNode) displayableTierNodes.get(index);
            setActiveTier(node.getTier());
        }

        paintBuffer();
    }

    /**
     * Start dragging a tier.
     *
     * @param e the mousePressed event
     */
    public void mousePressed(MouseEvent e) {
        //Point p = e.getPoint();
        if (SwingUtilities.isRightMouseButton(e) || e.isPopupTrigger()) {
            // present a menu to set visible tiers
            // maybe the menu drops out of the screen, correct it if needed
            //SwingUtilities.convertPointToScreen(p, this);
            int y = e.getPoint().y;

            int tierIndex = getClosestTierIndexForMouseY(y);

            if (!(tierIndex >= displayableTierNodes.size()) &&
                    (displayableTierNodes.size() > 0)) {
                TierTreeNode node = (TierTreeNode) displayableTierNodes.get(tierIndex);
                TierImpl tier = null;

                if (node != null) {
                    tier = node.getTier();
                    rightClickTier = tier;
                }

                // set the menu right from the panel so it does not hide the labels
                // when this panel is created LayoutManager maybe null
                // the viewer action access the LayoutManager
                updatePopup(tier);
            } else {
                rightClickTier = null;
                updatePopup(null);
            }

            popup.show(this, WIDTH - 5, y);

            return;
        }

        dragIndex = getClosestTierIndexForMouseY(e.getPoint().y);

        if ((dragIndex == 0) && (displayableTierNodes.size() == 0)) {
            return;
        } else {
            dragLabel = (String) tierNames.get(((TierTreeNode) displayableTierNodes.elementAt(
                        dragIndex)).getTier());
            dragging = true;
        }
    }

    /**
     * Drag a tier label.
     *
     * @param e the mouseDragged event
     */
    public void mouseDragged(MouseEvent e) {
        // this part should only be done once

        /*
           if (!dragging) {
               dragging = true;

                       dragIndex = getClosestTierIndexForMouseY(e.getPoint().y);

                       if ((dragIndex == 0) && (displayableTierNodes.size() == 0)) {
                           dragLabel = "";
                       } else {
                           dragLabel = (String) tierNames.get( ((TierTreeNode)displayableTierNodes.elementAt(dragIndex)).getTier() );
                       }
                   }
         */
        if (dragging) {
            dragX = e.getPoint().x - 40;
            dragY = e.getPoint().y;
            repaint();
        }
    }

    /**
     * When this is the end of a drag operation, move a tier or a group of
     * tiers,  depending on the current sorting mode.
     *
     * @param e the mouse release event
     */
    public void mouseReleased(MouseEvent e) {
        if (dragging) {
            if (displayableTierNodes.size() <= 1) {
                dragging = false;
                dragLabel = "";
                repaint();

                return;
            }

            // re-order the visible tiers
            // insert the dragged tier at the release index
            int index = getInsertionIndexForMouseY(e.getPoint().y);

            if (index >= displayableTierNodes.size()) {
                index = displayableTierNodes.size() - 1;
            }

            if ((index != dragIndex) && ((index - 1) != dragIndex)) {
                TierTreeNode node = (TierTreeNode) displayableTierNodes.elementAt(dragIndex);
                TierTreeNode insertBeforeNode = (TierTreeNode) displayableTierNodes.get(index);
                TierTreeNode insertAfterNode = null;

                if ((index - 1) >= 0) {
                    insertAfterNode = (TierTreeNode) displayableTierNodes.get(index -
                            1);
                }

                if (index == (displayableTierNodes.size() - 1)) {
                    insertBeforeNode = null;
                    insertAfterNode = (TierTreeNode) displayableTierNodes.get(index);
                }

                /*
                   System.out.print("drag tier: " + node.getTierName());
                   if (insertAfterNode != null) System.out.print(" - insertaftertier: " + insertAfterNode.getTierName());
                       else System.out.print(" insertaftertier: null");
                   if (insertBeforeNode != null) System.out.println(" - insertbeforetier: " + insertBeforeNode.getTierName());
                       else System.out.println(" insertbeforetier: null");
                   System.out.print("drag parent: " + node.getParent());
                   if (insertAfterNode != null) System.out.print(" - parent after: " + insertAfterNode.getParent());
                   if (insertBeforeNode != null)System.out.println(" - parent before: " + insertBeforeNode.getParent());
                   System.out.println("");
                 */

                //System.out.println("Node: " + node.getTierName() + " after: " + insertAfterNode.getTierName() + " before: " + 
                //(insertBeforeNode == null ? "null" : insertBeforeNode.getTierName()));
                switch (sortMode) {
                case SORT_BY_HIERARCHY:

                    if ((insertAfterNode != null) &&
                            (node.getParent() == insertAfterNode.getParent())) {
                        node.removeFromParent();

                        int afterIndex = insertAfterNode.getParent().getIndex(insertAfterNode);
                        ((DefaultMutableTreeNode) insertAfterNode.getParent()).insert(node,
                            afterIndex + 1);
                    } else if ((insertBeforeNode != null) &&
                            (node.getParent() == insertBeforeNode.getParent())) {
                        int beforeIndex = insertBeforeNode.getParent().getIndex(insertBeforeNode);
                        ((DefaultMutableTreeNode) insertBeforeNode.getParent()).insert(node,
                            beforeIndex);
                    } else if ((insertAfterNode != null) &&
                            (node.getParent() == insertAfterNode.getSharedAncestor(
                                node))) {
                        int curLevel = node.getLevel();
                        DefaultMutableTreeNode sameLevelNode = insertAfterNode;

                        while (sameLevelNode.getLevel() != curLevel) {
                            sameLevelNode = (DefaultMutableTreeNode) sameLevelNode.getParent();