multitiercontrolpanel.java

编辑视频文件

                        }

                        node.removeFromParent();

                        int afterIndex = sameLevelNode.getParent().getIndex(sameLevelNode);
                        ((DefaultMutableTreeNode) sameLevelNode.getParent()).insert(node,
                            afterIndex + 1);
                    }

                    break;

                case SORT_BY_PARTICIPANT:

                    // first try within group
                    if ((insertAfterNode != null) &&
                            (insertBeforeNode != null)) {
                        if (insertAfterNode.getTier().getParticipant().equals(node.getTier()
                                                                                      .getParticipant())) {
                            node.removeFromParent();

                            int afterIndex = insertAfterNode.getParent()
                                                            .getIndex(insertAfterNode);
                            ((DefaultMutableTreeNode) insertAfterNode.getParent()).insert(node,
                                afterIndex + 1);

                            break;
                        } else if (insertBeforeNode.getTier().getParticipant()
                                                       .equals(node.getTier()
                                                                       .getParticipant())) {
                            int beforeIndex = insertBeforeNode.getParent()
                                                              .getIndex(insertBeforeNode);
                            ((DefaultMutableTreeNode) insertBeforeNode.getParent()).insert(node,
                                beforeIndex);

                            break;
                        }
                    }

                    if (insertAfterNode != null) {
                        if (insertAfterNode.getTier().getParticipant().equals(node.getTier()
                                                                                      .getParticipant())) {
                            node.removeFromParent();

                            int afterIndex = insertAfterNode.getParent()
                                                            .getIndex(insertAfterNode);
                            ((DefaultMutableTreeNode) insertAfterNode.getParent()).insert(node,
                                afterIndex + 1);
                        } else {
                            // move group
                            String afterPartName = insertAfterNode.getTier()
                                                                  .getParticipant();
                            String dragPartName = node.getTier().getParticipant();
                            TierTreeNode lastNode = insertAfterNode;

                            while ((lastNode.getNextNode() != null) &&
                                    ((TierTreeNode) lastNode.getNextNode()).getTier()
                                         .getParticipant().equals(afterPartName)) {
                                lastNode = (TierTreeNode) lastNode.getNextNode();
                            }

                            ArrayList moveGroup = new ArrayList();
                            Enumeration en = sortedRootNode.preorderEnumeration();
                            en.nextElement();

                            TierTreeNode nn;

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

                                if (nn.getTier().getParticipant().equals(dragPartName)) {
                                    moveGroup.add(nn);
                                }
                            }

                            for (int i = moveGroup.size() - 1; i >= 0; i--) {
                                ((DefaultMutableTreeNode) moveGroup.get(i)).removeFromParent();
                            }

                            int afterIndex = lastNode.getParent().getIndex(lastNode);

                            for (int i = moveGroup.size() - 1; i >= 0; i--) {
                                ((DefaultMutableTreeNode) lastNode.getParent()).insert((DefaultMutableTreeNode) moveGroup.get(
                                        i), afterIndex + 1);
                            }
                        }
                    } else if (insertBeforeNode != null) {
                        if (insertBeforeNode.getTier().getParticipant().equals(node.getTier()
                                                                                       .getParticipant())) {
                            int beforeIndex = insertBeforeNode.getParent()
                                                              .getIndex(insertBeforeNode);
                            ((DefaultMutableTreeNode) insertBeforeNode.getParent()).insert(node,
                                beforeIndex);
                        } else {
                            // move group , before node should be the first node
                            String dragPartName = node.getTier().getParticipant();
                            ArrayList moveGroup = new ArrayList();
                            Enumeration en = sortedRootNode.preorderEnumeration();
                            en.nextElement();

                            TierTreeNode nn;

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

                                if (nn.getTier().getParticipant().equals(dragPartName)) {
                                    moveGroup.add(nn);
                                }
                            }

                            for (int i = moveGroup.size() - 1; i >= 0; i--) {
                                ((DefaultMutableTreeNode) moveGroup.get(i)).removeFromParent();
                            }

                            int beforeIndex = insertBeforeNode.getParent()
                                                              .getIndex(insertBeforeNode);

                            for (int i = moveGroup.size() - 1; i >= 0; i--) {
                                ((DefaultMutableTreeNode) insertBeforeNode.getParent()).insert((DefaultMutableTreeNode) moveGroup.get(
                                        i), beforeIndex);
                            }
                        }
                    }

                    break;

                case SORT_BY_LINGUISTIC_TYPE:

                    // first try to move within group
                    if ((insertAfterNode != null) &&
                            (insertBeforeNode != null)) {
                        if (insertAfterNode.getTier().getLinguisticType()
                                               .equals(node.getTier()
                                                               .getLinguisticType())) {
                            node.removeFromParent();

                            int afterIndex = insertAfterNode.getParent()
                                                            .getIndex(insertAfterNode);
                            ((DefaultMutableTreeNode) insertAfterNode.getParent()).insert(node,
                                afterIndex + 1);

                            break;
                        } else if (insertBeforeNode.getTier().getLinguisticType()
                                                       .equals(node.getTier()
                                                                       .getLinguisticType())) {
                            int beforeIndex = insertBeforeNode.getParent()
                                                              .getIndex(insertBeforeNode);
                            ((DefaultMutableTreeNode) insertBeforeNode.getParent()).insert(node,
                                beforeIndex);

                            break;
                        }
                    }

                    if (insertAfterNode != null) {
                        if (insertAfterNode.getTier().getLinguisticType()
                                               .equals(node.getTier()
                                                               .getLinguisticType())) {
                            // move within group 
                            node.removeFromParent();

                            int afterIndex = insertAfterNode.getParent()
                                                            .getIndex(insertAfterNode);
                            ((DefaultMutableTreeNode) insertAfterNode.getParent()).insert(node,
                                afterIndex + 1);
                        } else {
                            // move group
                            LinguisticType insertType = insertAfterNode.getTier()
                                                                       .getLinguisticType();
                            LinguisticType dragType = node.getTier()
                                                          .getLinguisticType();
                            TierTreeNode lastNode = insertAfterNode;

                            while ((lastNode.getNextNode() != null) &&
                                    ((TierTreeNode) lastNode.getNextNode()).getTier()
                                         .getLinguisticType().equals(insertType)) {
                                lastNode = (TierTreeNode) lastNode.getNextNode();
                            }

                            ArrayList moveGroup = new ArrayList();
                            Enumeration en = sortedRootNode.preorderEnumeration();
                            en.nextElement();

                            TierTreeNode nn;

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

                                if (nn.getTier().getLinguisticType().equals(dragType)) {
                                    moveGroup.add(nn);
                                }
                            }

                            for (int i = moveGroup.size() - 1; i >= 0; i--) {
                                ((DefaultMutableTreeNode) moveGroup.get(i)).removeFromParent();
                            }

                            int afterIndex = lastNode.getParent().getIndex(lastNode);

                            for (int i = moveGroup.size() - 1; i >= 0; i--) {
                                ((DefaultMutableTreeNode) lastNode.getParent()).insert((DefaultMutableTreeNode) moveGroup.get(
                                        i), afterIndex + 1);
                            }
                        }
                    } else if (insertBeforeNode != null) {
                        if (insertBeforeNode.getTier().getLinguisticType()
                                                .equals(node.getTier()
                                                                .getLinguisticType())) {
                            // move within group
                            int beforeIndex = insertBeforeNode.getParent()
                                                              .getIndex(insertBeforeNode);
                            ((DefaultMutableTreeNode) insertBeforeNode.getParent()).insert(node,
                                beforeIndex);
                        } else {
                            // move group , before node should be the first node
                            LinguisticType dragType = node.getTier()
                                                          .getLinguisticType();
                            ArrayList moveGroup = new ArrayList();
                            Enumeration en = sortedRootNode.preorderEnumeration();
                            en.nextElement();

                            TierTreeNode nn;

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

                                if (nn.getTier().getLinguisticType().equals(dragType)) {
                                    moveGroup.add(nn);
                                }
                            }

                            for (int i = moveGroup.size() - 1; i >= 0; i--) {
                                ((DefaultMutableTreeNode) moveGroup.get(i)).removeFromParent();
                            }

                            int beforeIndex = insertBeforeNode.getParent()
                                                              .getIndex(insertBeforeNode);

                            for (int i = moveGroup.size() - 1; i >= 0; i--) {
                                ((DefaultMutableTreeNode) insertBeforeNode.getParent()).insert((DefaultMutableTreeNode) moveGroup.get(
                                        i), beforeIndex);
                            }
                        }
                    }

                    break;

                case UNSORTED:

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

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

                    break;

                default:
                    return;
                }

                updateDisplayableTiers();
            }

            dragging = false;
            dragLabel = "";
            paintBuffer();
        }
    }

    private int getClosestTierIndexForMouseY(int y) {
        if ((tierPositions.length == 0) || (displayableTierNodes.size() == 0)) {
            return 0;
        }

        int index;

        for (index = 0; index < displayableTierNodes.size(); index++) {
            if (y < tierPositions[index]) {
                break;
            }
        }

        if (index > 0) {
            index--;

            if ((index == displayableTierNodes.size()) && (index != 0)) {
                index--;
            }
        }

        // determine to which label the mouse is closest
        float d1 = Math.abs(y - tierPositions[index]);
        float d2 = Float.MAX_VALUE;

        if ((index + 1) < displayableTierNodes.size()) {
            d2 = Math.abs(y - tierPositions[index + 1]);
        }

        if (d2 < d1) {
            index++;
        }

        return index;
    }

    private int getInsertionIndexForMouseY(int y) {
        int index = 0;

        if (displayableTierNodes.size() > 0) {
            for (index = 0; index < displayableTierNodes.size(); index++) {
                if (y < tierPositions[index]) {
                    break;
                }
            }
        }

        return index;
    }

    /**
     * Handle action events from menu's.
     *
     * @param e DOCUMENT ME!
     */
    public void actionPerformed(ActionEvent e) {
        String command = e.getActionCommand();

        if (command.equals("hideAll")) {
            hideAllTiers();
        } else if (command.equals("showAll")) {
            showAllTiers();
        } else if (command.equals("showHideMore")) {
            new VisibilityDialog(transcription, visibleTiers);
        } else if (command.equals("unsorted")) {
            setSorting(UNSORTED);
        } else if (command.equals("sortHier")) {
            setSorting(SORT_BY_HIERARCHY);
        } else if (command.equals("sortPart")) {
            setSorting(SORT_BY_PARTICIPANT);
        } else if (command.equals("sortType")) {
            setSorting(SORT_BY_LINGUISTIC_TYPE);
        } else if (command.equals("sortAnn")) {
            setSorting(SORT_BY_ANNOTATOR);
        } else if (command.equals("expandAll")) {
            expandAllNodes();
        } else if (command.equals("collapseAll")) {
            collapseAllNodes();
        } else if (command.equals("hideThis")) {
            hideTier(rightClickTier);
        } else if (command.equals("changeThis")) {
            changeTier(rightClickTier);
        } else if (command.equals("deleteThis")) {
            deleteTier(rightClickTier);
        } else if (command.equals("toggleExpandThis")) {
            toggleExpandedState(rightClickTier);