tstrackmanager.java

编辑视频文件

     *
     * @param sourceConfig the configuration of the source file
     * @param track the track object
     *
     * @see #removeTrack(TSSourceConfiguration, TSTrackConfiguration)
     */
    public void removeTrack(TSSourceConfiguration sourceConfig,
        TimeSeriesTrack track) {
        if ((sourceConfig == null) || (track == null)) {
            return;
        }

        // check if the track has been removed from the source configuration
        if (sourceConfig.getObject(track.getName()) != null) {
            sourceConfig.removeObject(track.getName());
        }

        tracks.remove(track);

        notifyListeners(new TimeSeriesChangeEvent(track,
                TimeSeriesChangeEvent.DELETE, TimeSeriesChangeEvent.TRACK));
    }

    /**
     * Called when a track configuration has changed.
     *
     * @param trackConfig the track configuration
     */
    public void trackChanged(TSTrackConfiguration trackConfig) {
        if (trackConfig == null) {
            return;
        }

        // check if the track is in the list
        AbstractTSTrack track = null;
        Object tr = trackConfig.getObject(trackConfig.getTrackName());

        if (tr instanceof AbstractTSTrack) {
            track = (AbstractTSTrack) tr;

            if (tracks.contains(track)) {
                notifyListeners(new TimeSeriesChangeEvent(track,
                        TimeSeriesChangeEvent.CHANGE,
                        TimeSeriesChangeEvent.TRACK));
            }
        } else {
            Iterator objIt = trackConfig.objectKeySet().iterator();

            while (objIt.hasNext()) {
                Object key = objIt.next();
                Object oo = trackConfig.getObject(key);

                if (oo instanceof AbstractTSTrack) {
                    track = (AbstractTSTrack) oo;

                    if (tracks.contains(track)) {
                        notifyListeners(new TimeSeriesChangeEvent(track,
                                TimeSeriesChangeEvent.CHANGE,
                                TimeSeriesChangeEvent.TRACK));
                    }
                }
            }
        }
    }

    /**
     * Called when a track has changed.
     *
     * @param track the track
     */
    public void trackChanged(TimeSeriesTrack track) {
        if (track == null) {
            return;
        }

        if (tracks.contains(track)) {
            // notify listeners; listeners might have to check what has changed
            notifyListeners(new TimeSeriesChangeEvent(track,
                    TimeSeriesChangeEvent.CHANGE, TimeSeriesChangeEvent.TRACK));
        }
    }

    /**
     * Generic request to send a notification to listeners
     *
     * @param type ADD, CHANGE, DELETE
     */
    public void tsSourceChanged(int type) {
        notifyListeners(new TimeSeriesChangeEvent(this, type,
                TimeSeriesChangeEvent.TS_SOURCE));
        encoder.encodeAndSave(transcription, trackSourceConfigs.values());
    }

    /**
     * Adds a timeseries source configuration object to the manager. Any track
     * objects found through this source configuration will be added to the
     * list of managed tracks.
     *
     * @param configuration a configuration object associated with a single
     *        source (file)
     */
    public void addTrackSource(TSSourceConfiguration configuration) {
        if (configuration != null) {
            trackSourceConfigs.put(configuration.getSource(), configuration);

            // add tracks to the list
            Iterator keyIt = configuration.objectKeySet().iterator();

            while (keyIt.hasNext()) {
                Object key = keyIt.next();
                Object o = configuration.getObject(key);

                if (o instanceof TimeSeriesTrack) {
                    tracks.add(o);
                } else if (o instanceof TSTrackConfiguration) { // default

                    TSTrackConfiguration tstc = (TSTrackConfiguration) o;
                    Object tr = tstc.getObject(tstc.getTrackName());

                    if (tr instanceof TimeSeriesTrack) {
                        tracks.add(tr); // default situation
                    } else {
                        Iterator objIt = tstc.objectKeySet().iterator();

                        while (objIt.hasNext()) {
                            Object ke = objIt.next();
                            Object oo = tstc.getObject(ke);

                            if (oo instanceof TimeSeriesTrack) {
                                tracks.add(oo);
                            }
                        }
                    }
                }
            }

            if (syncPlayer == null) {
                TimeSeriesViewer tsViewer = ELANCommandFactory.getViewerManager(transcription)
                                                              .createTimeSeriesViewer();

                //ELANCommandFactory.getViewerManager(transcription).disableViewer(tsViewer);
                tsViewer.setTrackManager(this);
                syncPlayer = new TSViewerPlayer(tsViewer,
                        ELANCommandFactory.getViewerManager(transcription)
                                          .getMasterMediaPlayer()
                                          .getMediaDuration());
                syncPlayer.setTrackManager(this); // adds the sources
                ELANCommandFactory.getViewerManager(transcription)
                                  .addMediaPlayer(syncPlayer);
                ELANCommandFactory.getLayoutManager(transcription).add(syncPlayer);
                ELANCommandFactory.getViewerManager(transcription)
                                  .destroyMediaPlayer(syncPlayer);
            }

            notifyListeners(new TimeSeriesChangeEvent(configuration,
                    TimeSeriesChangeEvent.ADD, TimeSeriesChangeEvent.TS_SOURCE));
            encoder.encodeAndSave((TranscriptionImpl) transcription,
                trackSourceConfigs.values());
        }
    }

    /**
     * Removes a source configuration from the managers map
     *
     * @param configuration a configuration object
     *
     * @see #removeTrackSource(String)
     */
    public void removeTrackSource(TSSourceConfiguration configuration) {
        if (configuration != null) {
            removeTrackSource(configuration.getSource());
        }
    }

    /**
     * Removes a timeseries source configuration object from the manager. Any
     * track objects found through this source configuration will be removed
     * from the list of managed tracks.
     *
     * @param source name of the configuration (=path)
     */
    public void removeTrackSource(String source) {
        if (source != null) {
            TSSourceConfiguration configuration = (TSSourceConfiguration) trackSourceConfigs.remove(source);

            if (configuration != null) {
                Iterator keyIt = configuration.objectKeySet().iterator();

                while (keyIt.hasNext()) {
                    Object key = keyIt.next();
                    Object o = configuration.getObject(key);

                    if (o instanceof TimeSeriesTrack) {
                        tracks.remove(o);
                    } else if (o instanceof TSTrackConfiguration) { // default

                        TSTrackConfiguration tstc = (TSTrackConfiguration) o;
                        Object tr = tstc.getObject(tstc.getTrackName());

                        if (tr instanceof TimeSeriesTrack) {
                            tracks.remove(tr); // default situation
                        } else {
                            Iterator objIt = tstc.objectKeySet().iterator();

                            while (objIt.hasNext()) {
                                Object ke = objIt.next();
                                Object oo = tstc.getObject(ke);

                                if (oo instanceof TimeSeriesTrack) {
                                    tracks.remove(oo);
                                }
                            }
                        }
                    }

                    notifyListeners(new TimeSeriesChangeEvent(o,
                            TimeSeriesChangeEvent.DELETE,
                            TimeSeriesChangeEvent.TRACK));
                }
            }

            notifyListeners(new TimeSeriesChangeEvent(configuration,
                    TimeSeriesChangeEvent.DELETE,
                    TimeSeriesChangeEvent.TS_SOURCE));

            if (trackSourceConfigs.isEmpty()) {
                if (syncPlayer != null) {
                    ELANCommandFactory.getLayoutManager(transcription).remove(syncPlayer);
                    ELANCommandFactory.getViewerManager(transcription)
                                      .destroyViewer(syncPlayer.getViewer());
                    ELANCommandFactory.getViewerManager(transcription)
                                      .destroyMediaPlayer(syncPlayer);
                    syncPlayer = null;
                }
            }
        }

        encoder.encodeAndSave(transcription, trackSourceConfigs.values());
    }

    /**
     * Called after a change in configuration settings.
     *
     * @param configuration the changed configuration
     */
    public void trackSourceChanged(TSSourceConfiguration configuration) {
        if (configuration == null) {
            return;
        }

        // check if the config is in the list
        if (trackSourceConfigs.get(configuration.getSource()) != null) {
            // check if the time origins of the tracks in this config need to be updated
            int origin = configuration.getTimeOrigin();
            AbstractTSTrack track = null;

            Iterator keyIt = configuration.objectKeySet().iterator();

            while (keyIt.hasNext()) {
                Object key = keyIt.next();
                Object o = configuration.getObject(key);

                if (o instanceof AbstractTSTrack) {
                    track = (AbstractTSTrack) o;

                    if (track.getTimeOffset() != origin) {
                        track.setTimeOffset(origin);
                        notifyListeners(new TimeSeriesChangeEvent(track,
                                TimeSeriesChangeEvent.CHANGE,
                                TimeSeriesChangeEvent.TRACK));
                    }
                } else if (o instanceof TSTrackConfiguration) { // default

                    TSTrackConfiguration tstc = (TSTrackConfiguration) o;
                    Object tr = tstc.getObject(tstc.getTrackName());

                    if (tr instanceof AbstractTSTrack) {
                        track = (AbstractTSTrack) tr;

                        if (track.getTimeOffset() != origin) {
                            track.setTimeOffset(origin);
                            notifyListeners(new TimeSeriesChangeEvent(track,
                                    TimeSeriesChangeEvent.CHANGE,
                                    TimeSeriesChangeEvent.TRACK));
                        }
                    } else {
                        Iterator objIt = tstc.objectKeySet().iterator();

                        while (objIt.hasNext()) {
                            Object ke = objIt.next();
                            Object oo = tstc.getObject(ke);

                            if (oo instanceof AbstractTSTrack) {
                                track = (AbstractTSTrack) oo;

                                if (track.getTimeOffset() != origin) {
                                    track.setTimeOffset(origin);
                                    notifyListeners(new TimeSeriesChangeEvent(
                                            track,
                                            TimeSeriesChangeEvent.CHANGE,
                                            TimeSeriesChangeEvent.TRACK));
                                }
                            }
                        }
                    }
                }
            }

            notifyListeners(new TimeSeriesChangeEvent(configuration,
                    TimeSeriesChangeEvent.CHANGE,
                    TimeSeriesChangeEvent.TS_SOURCE));
            encoder.encodeAndSave(transcription, trackSourceConfigs.values());
        }
    }

    /**
     * Adds a listener to the list of time series change listeners.
     *
     * @param li the listener
     */
    public void addTimeSeriesChangeListener(TimeSeriesChangeListener li) {
        if (listeners == null) {
            listeners = new ArrayList();
        }

        listeners.add(li);
    }

    /**
     * Removes the listeners from the list
     *
     * @param li the listener
     */
    public void removeTimeSeriesChangeListener(TimeSeriesChangeListener li) {
        if (listeners != null) {
            listeners.remove(li);
        }
    }

    /**
     * Dispatches the event to all interested in time series change events
     *
     * @param event the time series change event
     */
    private void notifyListeners(TimeSeriesChangeEvent event) {
        if (listeners != null) {
            for (int i = 0; i < listeners.size(); i++) {
                ((TimeSeriesChangeListener) listeners.get(i)).timeSeriesChanged(event);
            }
        }
    }

    /**
     * Dispatches events to the registered listeners.
     *
     * @param event DOCUMENT ME!
     */
    public void timeSeriesChanged(TimeSeriesChangeEvent event) {
        if (event.getEditSourceType() == TimeSeriesChangeEvent.TRACK) {
            if (event.getSource() instanceof TSTrackConfiguration) {
                TSTrackConfiguration trc = (TSTrackConfiguration) event.getSource();
                Object tr = trc.getObject(trc.getTrackName());

                if (event.getEditType() == TimeSeriesChangeEvent.ADD) {
                    if (!tracks.contains(tr)) {
                        tracks.add(tr);
                    }
                } else if (event.getEditType() == TimeSeriesChangeEvent.DELETE) {
                    tracks.remove(tr);
                }
            }
        }

        notifyListeners(event);
        encoder.encodeAndSave(transcription, trackSourceConfigs.values());
    }
}