viewermanager2.java

编辑视频文件

            if (((QTMediaPlayer) getMasterMediaPlayer()).getMovie() != null) {
                QTSVGViewer viewer = new QTSVGViewer(transcription);
                viewer.setMediaFileDimension(((QTMediaPlayer) getMasterMediaPlayer()).getMediaFileDimension());
                viewer.setMovie(((QTMediaPlayer) getMasterMediaPlayer()).getMovie());
                ((QTMediaPlayer) getMasterMediaPlayer()).setStopMode(QTMediaPlayer.STOP_WITH_STOP_TIME);
                connect(viewer);
                viewers.add(viewer); //??
                enabledViewers.add(viewer); //??

                return viewer;
            }
        }

        return null;
    }

    /**
     * Creates a SegmentationViewer that is connected to the Viewer universe.
     *
     * @return a SegmentationViewer for the Transcription in this ViewerManager
     */
    public SegmentationViewer createSegmentationViewer() {
        SegmentationViewer viewer = new SegmentationViewer(transcription);
        PeriodicUpdateController controller = getControllerForPeriod(TIME_LINE_VIEWER_PERIOD);
        controllers.put(viewer, controller);
        connect(viewer);

        viewers.add(viewer);
        enabledViewers.add(viewer);

        return viewer;
    }

    /**
     * Creates a TimeSeriesViewer that is connected to the Viewer universe.
     *
     * @return a TimeSeriesViewer for the Transcription in this ViewerManager
     */
    public TimeSeriesViewer createTimeSeriesViewer() {
        TimeSeriesViewer viewer = new TimeSeriesViewer(transcription);
        PeriodicUpdateController controller = getControllerForPeriod(TIME_LINE_VIEWER_PERIOD);
        controllers.put(viewer, controller);
        connect(viewer);

        viewers.add(viewer);
        enabledViewers.add(viewer);

        return viewer;
    }

    /**
     * Registers (Tier-) time line controllers to viewer
     * @param viewer the viewer for which the controllers must be set
     * @param tierNames array of Tier Names
     */
    public void setControllersForViewer(AbstractViewer viewer,
        String[] tierNames) {
        try {
            Tier[] tiers = new Tier[tierNames.length];

            for (int i = 0; i < tierNames.length; i++) {
                tiers[i] = transcription.getTierWithId(tierNames[i]);
            }

            setControllersForViewer(viewer, tiers);
        } catch (Exception e) {
        }
    }

    /**
     * DOCUMENT ME!
     *
     * @param viewer DOCUMENT ME!
     * @param tier DOCUMENT ME!
     */
    public void setTierForViewer(SingleTierViewer viewer, Tier tier) {
        if (viewer instanceof AbstractViewer) {
            setControllersForViewer((AbstractViewer) viewer,
                (tier == null) ? new Tier[0] : new Tier[] { tier });
        }

        viewer.setTier(tier);
    }

    /**
     * Registers (Tier-) time line controllers to viewer
     * @param viewer the viewer for which the controllers must be set
     * @param tiers array of tiers that must be set
     */
    public void setControllersForViewer(AbstractViewer viewer, Tier[] tiers) {
        if (viewer == null) {
            return;
        }

        // disconnect an old controller if it exists
        disconnectController(viewer, true);

        //TODO: connect to all tiers, not just first (-> change storage of controllers)
        // connect the viewer to the right controller
        if ((tiers != null) && (tiers.length > 0)) {
            TimeLineController controller = getControllerForTier(tiers[0]);
            controller.addControllerListener(viewer);
            controllers.put(viewer, controller);

            // set the controller in the started state if player is playing
            if (masterMediaPlayer.isPlaying()) {
                controller.start();
            }
        }
    }

    /**
     * Creates a SingleTierViewerPanel and connects it to the Transcription as
     * an ACMEditListener.
     *
     * @return the new SingleTierViewerPanel
     */
    public SingleTierViewerPanel createSingleTierViewerPanel() {
        SingleTierViewerPanel panel = new SingleTierViewerPanel(this);

        try {
            ((ACMEditableDocument) transcription).addACMEditListener((ACMEditListener) panel);
        } catch (Exception e) {
            e.printStackTrace();
        }

        ElanLocale.addElanLocaleListener(transcription, panel);

        return panel;
    }

    /**
     * Destroys (disconnects) the SingleTierViewerPanel as ACMEditListener from
     * the Transcription.
     *
     * @param panel the SingleTierViewerPanel to be destroyed (disconnected).
     */
    public void destroySingleTierViewerPanel(SingleTierViewerPanel panel) {
        try {
            ((ACMEditableDocument) transcription).removeACMEditListener((ACMEditListener) panel);
        } catch (Exception e) {
            e.printStackTrace();
        }

        ElanLocale.removeElanLocaleListener(panel);
    }

    /**
     * Removes an AbstractViewer completely from the viewer universe
     *
     * @param viewer the AbstractViewer that must be destroyed
     */
    public void destroyViewer(AbstractViewer viewer) {
        disconnect(viewer, true);
        viewers.remove(viewer);
    }

    /**
     * Disconnects am AbstractViewer from the viewer universe in such a manner
     * that it can be reconnected.
     *
     * @param viewer the AbstractViewer that must be disabled
     */
    public void disableViewer(AbstractViewer viewer) {
        if (enabledViewers.contains(viewer)) {
            enabledViewers.remove(viewer);
            disconnect(viewer, false);
            disabledViewers.add(viewer);
        }
    }

    /**
     * Reconnects an AbstractViewer to the viewer universe from which it was
     * temporarily disconnected.
     *
     * @param viewer the AbstractViewer that must be enabled
     */
    public void enableViewer(AbstractViewer viewer) {
        if (disabledViewers.contains(viewer)) {
            disabledViewers.remove(viewer);
            connect(viewer);
            enabledViewers.add(viewer);
        }
    }

    /**
     * Tries to make sure resources are freed, especially the created
     * media players might have to release resources.
     * Preliminary....
     */
    public void cleanUpOnClose() {
        ElanMediaPlayer player;

        for (int i = 0; i < slaveMediaPlayers.size(); i++) {
            player = (ElanMediaPlayer) slaveMediaPlayers.get(i);
            player.cleanUpOnClose();
        }

        for (int i = 0; i < disabledMediaPlayers.size(); i++) {
            player = (ElanMediaPlayer) disabledMediaPlayers.get(i);
            player.cleanUpOnClose();
        }

        if (masterMediaPlayer != null) {
            masterMediaPlayer.cleanUpOnClose();
        }

        for (int i = 0; i < viewers.size(); i++) {
            AbstractViewer viewer = (AbstractViewer) viewers.get(i);
            disconnect(viewer, true);

            if (viewer instanceof ACMEditListener && (transcription != null)) {
                ((ACMEditableDocument) transcription).removeACMEditListener((ACMEditListener) viewer);
            }

            if (viewer instanceof TimeLineViewer) {
                ((TimeLineViewer) viewer).setTranscription(null);
            }

            if (viewer instanceof InterlinearViewer) {
                ((InterlinearViewer) viewer).setTranscription(null);
            }
        }

        enabledViewers.clear();
        viewers.clear();
        disabledViewers.clear();
    }

    /**
     * Connect an AbstractViewer to the Viewer Universe.
     *
     * @param viewer the viewer that must be connected;
     */
    private void connect(AbstractViewer viewer) {
        // observables for all viewers
        viewer.setPlayer(masterMediaPlayer);
        viewer.setSelectionObject(selection);
        selection.addSelectionListener(viewer);
        viewer.setActiveAnnotationObject(activeAnnotation);
        activeAnnotation.addActiveAnnotationListener(viewer);
        ElanLocale.addElanLocaleListener(transcription, viewer);

        viewer.setViewerManager(this);

        // only for viewers that show trancription data
        if (viewer instanceof ACMEditListener) {
            try {
                ((ACMEditableDocument) transcription).addACMEditListener((ACMEditListener) viewer);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        // only for viewers that share the time scale
        if (viewer instanceof TimeScaleUser) {
            ((TimeScaleUser) viewer).setGlobalTimeScale(timeScale);
            timeScale.addTimeScaleListener((TimeScaleListener) viewer);
        }

        // only multi tier viewers are connected to the multi tier control panel
        if (viewer instanceof MultiTierViewer) {
            multiTierControlPanel.addViewer((MultiTierViewer) viewer);
        }

        // if there is a controller associated with this viewer connect them
        Controller controller = (Controller) controllers.get(viewer);

        if (controller != null) {
            controller.addControllerListener((ControllerListener) viewer);

            // make sure the viewer is in sync
            viewer.controllerUpdate(new TimeEvent(controller));
        }
    }

    /**
     * Disconnect an AbstractViewer from the Viewer Universe.
     *
     * @param viewer the viewer that must be disconnected;
     * @param finalDisconnection flag that tells if the viewer might need to be
     *        reconnected
     */
    private void disconnect(AbstractViewer viewer, boolean finalDisconnection) {
        // observables for all viewers
        viewer.setPlayer(null);
        viewer.setSelectionObject(null);
        selection.removeSelectionListener(viewer);
        viewer.setActiveAnnotationObject(null);
        activeAnnotation.removeActiveAnnotationListener(viewer);
        ElanLocale.removeElanLocaleListener(viewer);

        viewer.setViewerManager(null);

        // only for viewers that show trancription data
        // TEMPRORARY? disabled because disconnected viewers are not aware of changes in teh edited
        // document after they wake up. Keeoing them connected looks like the easiest solution.
        // DO NOT disable the same block in the connect method because that takes care of the
        // first time connection.

        /*        if (viewer instanceof ACMEditListener) {
           try {
               ((ACMEditableDocument) transcription).removeACMEditListener((ACMEditListener) viewer);
           } catch (Exception e) {
               e.printStackTrace();
           }
           }
         */

        // only for viewers that share the time scale
        if (viewer instanceof TimeScaleUser) {
            timeScale.removeTimeScaleListener((TimeScaleUser) viewer);
        }

        // only multi tier viewers are disconnected to the multi tier control panel
        if (viewer instanceof MultiTierViewer) {
            multiTierControlPanel.removeViewer((MultiTierViewer) viewer);
        }

        disconnectController(viewer, finalDisconnection);
    }

    /**
     * Break the connection between a viewer and its controller. Removes the
     * associated controller if it has no connected Viewers left after this
     * operation.
     *
     * @param viewer the viewer that must be disconnected from its controller
     * @param finalDisconnection flag that tells if the viewer might need to be
     *        reconnected
     */
    private void disconnectController(AbstractViewer viewer,
        boolean finalDisconnection) {
        //	get the controller for this viewer and remove the viewer as listener
        Controller controller = (Controller) controllers.get(viewer);

        //searchResultViewer might be created yet not connected -> controller == null
        if (controller != null) {
            controller.removeControllerListener(viewer);

            // remove the viewer key from the controllers hashtable if the disconnection is final
            if (finalDisconnection) {
                controllers.remove(viewer);

                // if there are no more listeners for the controller clean it up
                if (controller.getNrOfConnectedListeners() == 0) {
                    removeFromHashTable(controller, controllers);
                    masterMediaPlayer.removeController(controller);
                    controller = null;
                }
            }
        }
    }

    /**
     * Gets a TimeLineController for a Tier. If the Controller already exists
     * it is reused otherwise it is created
     *
     * @param tier the Tier for which the TimeLineController must be created
     *
     * @return the TimeLineController for the Tier
     */
    private TimeLineController getControllerForTier(Tier tier) {
        if (tier == null) {
            return null;
        }

        TimeLineController controller = null;

        // first see if the controller already exists
        if (controllers.containsKey(tier)) {
            controller = (TimeLineController) controllers.get(tier);
        } else {
            // The controller does not exist, create it
            controller = new TimeLineController(tier, masterMediaPlayer);

            // connect the controller to the master media player
            masterMediaPlayer.addController(controller);

            // add the controller to the existing controller list
            controllers.put(tier, controller);
        }

        return controller;
    }

    /**
     * Gets a PeriodicUpdateController for a period. If the Controller already
     * exists it is reused otherwise it is created
     *
     * @param period the period in milli seconds for which the
     *        PeriodicUpdateController must be created
     *
     * @return the PeriodicUpdateController for the period
     */
    private PeriodicUpdateController getControllerForPeriod(long period) {
        PeriodicUpdateController controller = null;
        Long periodKey = new Long(period);

        // first see if the controller already exists
        if (controllers.containsKey(periodKey)) {
            controller = (PeriodicUpdateController) controllers.get(periodKey);
        } else {
            // The controller does not exist, create it
            controller = new PeriodicUpdateController(period);

            // connect the controller to the master media player
            masterMediaPlayer.addController(controller);

            // add the controller to the existing controller list
            controllers.put(periodKey, controller);
        }

        return controller;
    }

    /**
     * Utility to remove all occurences of an object from a Hashtable. There is
     * no direct method for this in the Java API if you do not know the key
     *
     * @param object the Object to be removed
     * @param hashtable the Hastable that contains the Object
     *
     * @return boolean to flag if the Object was actualy removed
     */
    private boolean removeFromHashTable(Object object, Hashtable hashtable) {
        Object key;
        boolean objectRemoved = false;

        for (Enumeration e = hashtable.keys(); e.hasMoreElements();) {
            key = e.nextElement();

            if (controllers.get(key) == object) {
                hashtable.remove(key);
                objectRemoved = true;
            }
        }

        return objectRemoved;
    }
}