viewermanager2.java

编辑视频文件

/*
 * File:     ViewerManager2.java
 * Project:  MPI Linguistic Application
 * Date:     02 May 2007
 *
 * Copyright (C) 2001-2007  Max Planck Institute for Psycholinguistics
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

/*
 * Created on Sep 22, 2003
 *
 *
 */
package mpi.eudico.client.annotator;

import mpi.eudico.client.annotator.grid.*;

import mpi.eudico.client.annotator.player.*;

import mpi.eudico.client.annotator.search.result.viewer.ElanResultViewer;

import mpi.eudico.client.annotator.svg.GlassPaneSVGViewer;
import mpi.eudico.client.annotator.svg.JMFSVGViewer;
import mpi.eudico.client.annotator.svg.QTSVGViewer;

import mpi.eudico.client.annotator.viewer.*;

import mpi.eudico.client.mediacontrol.Controller;
import mpi.eudico.client.mediacontrol.ControllerListener;
import mpi.eudico.client.mediacontrol.PeriodicUpdateController;
import mpi.eudico.client.mediacontrol.TimeEvent;
import mpi.eudico.client.mediacontrol.TimeLineController;

import mpi.eudico.server.corpora.clom.Tier;
import mpi.eudico.server.corpora.clom.Transcription;

import mpi.eudico.server.corpora.clomimpl.abstr.MediaDescriptor;
import mpi.eudico.server.corpora.clomimpl.abstr.TierImpl;

import mpi.eudico.server.corpora.util.ACMEditListener;
import mpi.eudico.server.corpora.util.ACMEditableDocument;

import java.lang.reflect.Method;

import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;


/**
 * A ViewerManager must manage the viewer world that is created around a
 * Transcription. It takes care of creating, destroying, enabling and
 * disabling viewers and media players ensuring that all connections between
 * controllers and listeners are as they should be.
 * @version Aug 2005 Identity removed
 */
public class ViewerManager2 {
    /** Holds value of property DOCUMENT ME! */
    private final static long SIGNAL_VIEWER_PERIOD = 50; // make these values setable?

    /** Holds value of property DOCUMENT ME! */
    private final static long TIME_LINE_VIEWER_PERIOD = 50;

    /** Holds value of property DOCUMENT ME! */
    private final static long INTERLINEAR_VIEWER_PERIOD = 100;

    /** Holds value of property DOCUMENT ME! */
    private final static long MEDIA_CONTROL_PANEL_PERIOD = 100;

    /** The maximal number of video players in Elan */
    public static final int MAX_NUM_VIDEO_PLAYERS = 2; // will be 4

    /** The maximal number of audio players in Elan */
    public static final int MAX_NUM_AUDIO_PLAYERS = 1;
    private ElanMediaPlayer masterMediaPlayer;
    private ElanMediaPlayer signalSourcePlayer;
    private SignalViewer signalViewer;
    private Transcription transcription;
    private Selection selection;
    private TimeScale timeScale;
    private ActiveAnnotation activeAnnotation;
    private ElanMediaPlayerController mediaPlayerController;
    private AnnotationDensityViewer annotationDensityViewer;
    private MediaPlayerControlSlider mediaPlayerControlSlider;
    private TimePanel timePanel;
    private MultiTierControlPanel multiTierControlPanel;
    private Vector slaveMediaPlayers;
    private Vector disabledMediaPlayers;
    private Hashtable controllers;
    private Vector viewers;
    private Vector enabledViewers;
    private Vector disabledViewers;
    private Tier emptyTier;

    /**
     * Create a ViewerManager for a specific Transcription
     *
     * @param transcription the Transcription used in this ViewerManagers
     *        universe
     */
    public ViewerManager2(Transcription transcription) {
        this.transcription = transcription;

        // as long as no real media player is set as master player use
        // an empty media player.
        masterMediaPlayer = new EmptyMediaPlayer(0);

        // observables for this viewer universe
        selection = new Selection();
        timeScale = new TimeScale();
        activeAnnotation = new ActiveAnnotation();

        // administration objects
        slaveMediaPlayers = new Vector();
        disabledMediaPlayers = new Vector();
        controllers = new Hashtable();
        viewers = new Vector();
        enabledViewers = new Vector();
        disabledViewers = new Vector();

        // control panel singletons
        multiTierControlPanel = new MultiTierControlPanel(transcription);
        ElanLocale.addElanLocaleListener(transcription, multiTierControlPanel);

        try {
            //        emptyTier = new DobesTier(null, null, null, null);
            emptyTier = new TierImpl(null, null, null, null, null);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * DOCUMENT ME!
     *
     * @return the Transcription object for this viewer universe
     */
    public Transcription getTranscription() {
        return transcription;
    }

    /**
     * DOCUMENT ME!
     *
     * @return the Selection object for this viewer universe
     */
    public Selection getSelection() {
        return selection;
    }

    /**
     * DOCUMENT ME!
     *
     * @return the TimeScale object for this viewer universe
     */
    public TimeScale getTimeScale() {
        return timeScale;
    }

    /**
     * DOCUMENT ME!
     *
     * @return the ActiveAnnotation object for this viewer universe
     */
    public ActiveAnnotation getActiveAnnotation() {
        return activeAnnotation;
    }

    /**
     * Makes an ElanMediaPlayer master media player. The current master media
     * player becomes a slave from the new master. The old master media player
     * should be destroyed separately if it is no longer needed.
     *
     * @param player the ElanMediaPlayer that must become master player
     */
    public void setMasterMediaPlayer(ElanMediaPlayer player) {
        if (player == masterMediaPlayer) {
            return;
        }

        // remember the volume level of the current master
        float volume = masterMediaPlayer.getVolume();

        // make sure all current master media player connections are removed
        // disconnect slave players
        for (int i = 0; i < slaveMediaPlayers.size(); i++) {
            masterMediaPlayer.removeController((Controller) slaveMediaPlayers.elementAt(
                    i));
        }

        // disconnect the non-player controllers, TimeLine and PeriodicUpdate
        for (Enumeration en = controllers.elements(); en.hasMoreElements();) {
            masterMediaPlayer.removeController((Controller) en.nextElement());
        }

        // remove the new master player from the slave or disabled list
        // and add the current master player to the slave list
        slaveMediaPlayers.remove(player);
        disabledMediaPlayers.remove(player);
        slaveMediaPlayers.add(masterMediaPlayer);

        // set the master
        masterMediaPlayer = player;

        // connect the new master media player to the viewer universe
        // reconnect slave players
        for (int i = 0; i < slaveMediaPlayers.size(); i++) {
            masterMediaPlayer.addController((Controller) slaveMediaPlayers.elementAt(
                    i));
        }

        // reconnect the non-player controllers, TimeLine and PeriodicUpdate
        for (Enumeration en = controllers.elements(); en.hasMoreElements();) {
            masterMediaPlayer.addController((Controller) en.nextElement());
        }

        // set the player in all existing viewers
        for (Enumeration en = viewers.elements(); en.hasMoreElements();) {
            ((AbstractViewer) en.nextElement()).setPlayer(masterMediaPlayer);
        }

        // set the volume level
        masterMediaPlayer.setVolume(volume);

        for (int i = 0; i < slaveMediaPlayers.size(); i++) {
            ((ElanMediaPlayer) slaveMediaPlayers.elementAt(i)).setVolume(0);
        }
    }

    /**
     * Creates an ElanMediaPlayer and connects it to the master media player
     *
     * @param mediaDescriptor a string representation of the media URL
     *
     * @return an ElanMediaPlayer that is connected to the master media player
     *
     * @throws NoPlayerException
     */
    public ElanMediaPlayer createMediaPlayer(MediaDescriptor mediaDescriptor)
        throws NoPlayerException {
        // ask the player factory to create a player
        ElanMediaPlayer player = PlayerFactory.createElanMediaPlayer(mediaDescriptor);

        if (player == null) {
            return null;
        }

        ElanLocale.addElanLocaleListener(transcription, player);
        player.setRate(masterMediaPlayer.getRate());
        player.setVolume(0);

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

        // update the adminstration
        slaveMediaPlayers.add(player);

        //		if (isSignalImageSource) {
        //			signalSourcePlayer = player;
        //		}
        return player;
    }

    /**
     * Creates an ElanMediaPlayer and connects it to the master media player.
     * It first tries to create a player of the preferred type; if this fails
     * it will try to create a player the default way.
     *
     * @param mediaDescriptor a string representation of the media URL
     * @param preferredMediaFramework the preferred media framework
     *
     * @return an ElanMediaPlayer that is connected to the master media player
     *
     * @throws NoPlayerException
     */
    public ElanMediaPlayer createMediaPlayer(MediaDescriptor mediaDescriptor,
        String preferredMediaFramework) throws NoPlayerException {
        if (preferredMediaFramework == null) {
            return createMediaPlayer(mediaDescriptor);
        }

        // ask the player factory to create a player
        ElanMediaPlayer player = null;

        try {
            if (preferredMediaFramework.equals(PlayerFactory.QT_MEDIA_FRAMEWORK)) {
                player = PlayerFactory.createQTMediaPlayer(mediaDescriptor);
            } else if (preferredMediaFramework.equals(
                        PlayerFactory.JMF_MEDIA_FRAMEWORK)) {
                player = PlayerFactory.createJMFMediaPlayer(mediaDescriptor);
            } else if (preferredMediaFramework.equals(
                        PlayerFactory.NATIVE_WINDOWS_MEDIA_FRAMEWORK)) {
                player = PlayerFactory.createNativeMediaPlayerDS(mediaDescriptor);
            } else {
                return createMediaPlayer(mediaDescriptor); //default
            }
        } catch (NoPlayerException npe) {
            return createMediaPlayer(mediaDescriptor);
        }

        if (player == null) {
            return null;
        }

        ElanLocale.addElanLocaleListener(transcription, player);
        player.setRate(masterMediaPlayer.getRate());
        player.setVolume(0);

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

        // update the adminstration
        slaveMediaPlayers.add(player);

        //		if (isSignalImageSource) {
        //			signalSourcePlayer = player;
        //		}
        return player;
    }

    /**
     * Adds a custom made Elan media player to the list of slave media players
     * and connects it to the master media player.
     *
     * @see #destroyMediaPlayer(ElanMediaPlayer)
     * @param player the palyer to add
     */
    public void addMediaPlayer(ElanMediaPlayer player) {
        if ((player == null) || slaveMediaPlayers.contains(player) ||
                (player == masterMediaPlayer)) {
            return;
        }

        ElanLocale.addElanLocaleListener(transcription, player);
        player.setRate(masterMediaPlayer.getRate());
        player.setVolume(0);

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

        // update the adminstration
        slaveMediaPlayers.add(player);
    }

    /**
     * Removes an ElanMediaPlayer from this viewer universe. Nothing will be
     * done if an attempt is made to remove the master media player
     *
     * @param player the ElanMediaPlayer that must be destroyed
     */
    public void destroyMediaPlayer(ElanMediaPlayer player) {
        if (player == masterMediaPlayer) {
            return;
        }

        // disconnect the player from the master player
        masterMediaPlayer.removeController(player);

        // update the administration, the player is in one of two vectors
        slaveMediaPlayers.remove(player);
        disabledMediaPlayers.remove(player);

        player = null;
    }

    /**
     * Enables an ElanMediaPlayer that was previously disabled
     *
     * @param player the ElanMediaPlayer that must be enabled.
     */
    public void enableMediaPlayer(ElanMediaPlayer player) {
        // only enable a player that is a disabled player
        if (disabledMediaPlayers.contains(player)) {
            // reconnect the player to the master player
            masterMediaPlayer.addController(player);

            // update the administration
            slaveMediaPlayers.add(player);
            disabledMediaPlayers.remove(player);
        }
    }

    /**
     * Temporarily disconnects the player from the master media player. It can
     * be reconnected by calling enableElanMediaPlayer The master media player
     * will not be disabled.
     *
     * @param player the ElanMediaPlayer that must be disabled.
     */
    public void disableMediaPlayer(ElanMediaPlayer player) {
        // only disable a player that is a slave player
        if (slaveMediaPlayers.contains(player)) {
            // disconnect the player from the master player
            masterMediaPlayer.removeController(player);

            // update the administration
            slaveMediaPlayers.remove(player);
            disabledMediaPlayers.add(player);
        }
    }

    /**
     * Enable all players except the master player.
     */
    public void enableDisabledMediaPlayers() {
        Enumeration en = disabledMediaPlayers.elements();

        while (en.hasMoreElements()) {
            // reconnect the player to the master player
            masterMediaPlayer.addController((ElanMediaPlayer) en.nextElement());
        }

        // update the administration
        slaveMediaPlayers.addAll(disabledMediaPlayers);
        disabledMediaPlayers.clear();
    }

    /**
     * Disable all players except the master player.
     */
    public void disableSlaveMediaPlayers() {
        Enumeration en = slaveMediaPlayers.elements();

        while (en.hasMoreElements()) {
            // disconnect the player from the master player
            masterMediaPlayer.removeController((ElanMediaPlayer) en.nextElement());
        }

        // update the administration