|| || Doxygen's  

---

PlayingDirector Class Reference

This class can be used to control the playing of a video, in video based applications. More...

List of all members.

Public Methods
	PlayingDirector ()
	PlayingDirector (int nrFrames)
	PlayingDirector (int nrFrames, int frameInc, double frameRate)
int	getNrFrames ()
void	setNrFrames (int nrFrames)
	If the director is playing, setNrFrames stops it. More...
int	getCurrentFrame ()
void	setCurrentFrame (int fr)
	If the director is playing, setCurrentFrame stops it. More...
int	getFrameInc ()
void	setFrameInc (int frameInc)
	If the director is playing, setFrameInc stops it. More...
boolean	isRealTime ()
void	setRealTime (boolean rt)
	If the director is playing, setRealTime stops it. More...
double	getFrameRate ()
void	setFrameRate (double fps)
	If the director is playing, setFrameRate stops it. More...
void	addPlayingObserver (PlayingObserver o)
void	removePlayingObserver (PlayingObserver o)
boolean	isRunning ()
void	stop ()
	Stops the director. More...
void	stop (boolean waitStop)
	Stops the director. More...
void	play ()
void	playFrom (int frameNr)
	If a PlayingObserver calls ths method, it can result in a deadlock. More...
void	reset ()
	If a PlayingObserver calls ths method, it can result in a deadlock. More...
void	step ()
void	step (int frameInc)
void	seekTo (int frameNr)
	Asks the director to jump to that frame. More...
void	showCurrentFrame ()
Static Public Methods
PlayingDirector	play (int nrFrames, PlayingObserver o)
	Easy way to create and start a PlayingDirector with just one observer. More...
void	main (String[] args)

---

Detailed Description

This class can be used to control the playing of a video, in video based applications.

This class controls a thread that iterates over a sequence of numbers (say the frame numbers of a sequence). PlayingObservers can be registered to be notified each time a new number arrives. A PlayingObserver can be used, for instance, to display each frame.

A PlayingObserver is notified in two steps: prepareNewFrame and updateNewFrame. prepareNewFrame is called from the PlayingObserver thread, and updateNewFrame is called from the AWT event dispatch thread. If a PlayingObserver has to call some Swing related function (change the interface to display new frame), this call has to be done in the updateNewFrame: Swing is not thread-safe, and all the calls to Swing components have to be done from the AWT event dispatch thread. If the PlayingObserver has to perform some other processing not related to Swing (for instance, retrieve a new frame from the sequence), better put this call in prepareNewFrame. This will prevent the AWT event thread from being too busy and thus the GUI will react better to user input. PlayingObservers don't have to call SwingUtilities.invokeAndWait from prepareNewFrame. It will produce a dead-lock.

When the PlayingDirector reaches a new sequence number, it first calls the prepareNewFrame of all the PlayingObservers (sequentially), and then it tells the AWT event thread to call the updateNewFrame method of all the observers. Once all the updateNewFrame has been called, the PlayingDirector moves to a new sequence number.

start, stop and seek methods of observers are also called from AWT thread.

PlayingDirector assumes that all his public methods are called from the AWT event dispatch thread.

---

Constructor & Destructor Documentation

PlayingDirector::PlayingDirector (    )  [inline]

{ this(0, 1, 25.0); }

PlayingDirector::PlayingDirector (  int    nrFrames )  [inline]

{ this(nrFrames, 1, 25.0); }

PlayingDirector::PlayingDirector (  int    nrFrames, int    frameInc, double    frameRate )  [inline]

{ _nrFrames = nrFrames; _frameInc = frameInc; _frameRate = frameRate; _realTime = false; _curFrame = 0; _playing = false; _observers = new java.util.Vector(); }

---

Member Function Documentation

PlayingDirector PlayingDirector::play (  int    nrFrames, PlayingObserver    o )  [inline, static]

Easy way to create and start a PlayingDirector with just one observer. { PlayingDirector director = new PlayingDirector(nrFrames); director.addPlayingObserver(o); director.play(); return director; }

int PlayingDirector::getNrFrames (    )  [inline]

{ return _nrFrames; }

void PlayingDirector::setNrFrames (  int    nrFrames )  [inline]

If the director is playing, setNrFrames stops it. If a PlayingObserver calls ths method, it can result in a deadlock. { stop(); _nrFrames = nrFrames; }

int PlayingDirector::getCurrentFrame (    )  [inline]

{ return _curFrame; }

void PlayingDirector::setCurrentFrame (  int    fr )  [inline]

If the director is playing, setCurrentFrame stops it. If a PlayingObserver calls ths method, it can result in a deadlock. { _frameSeeker.seek(fr); stop(); }

int PlayingDirector::getFrameInc (    )  [inline]

{ return _frameInc; }

void PlayingDirector::setFrameInc (  int    frameInc )  [inline]

If the director is playing, setFrameInc stops it. If a PlayingObserver calls ths method, it can result in a deadlock. { _frameInc = frameInc; }

boolean PlayingDirector::isRealTime (    )  [inline]

{ return _realTime; }

void PlayingDirector::setRealTime (  boolean    rt )  [inline]

If the director is playing, setRealTime stops it. If a PlayingObserver calls ths method, it can result in a deadlock. { stop(); _realTime = rt; }

double PlayingDirector::getFrameRate (    )  [inline]

{ return _frameRate; }

void PlayingDirector::setFrameRate (  double    fps )  [inline]

If the director is playing, setFrameRate stops it. If a PlayingObserver calls ths method, it can result in a deadlock. { stop(); _frameRate = fps; }

void PlayingDirector::addPlayingObserver (  PlayingObserver    o )  [inline]

{ _observers.add(o); }

void PlayingDirector::removePlayingObserver (  PlayingObserver    o )  [inline]

{ _observers.remove(o); }

boolean PlayingDirector::isRunning (    )  [inline]

{ return _playing; }

void PlayingDirector::stop (    )  [inline]

Stops the director. The call doesn't return till the director has stopped. If a PlayingObserver calls ths method, it can result in a deadlock. { stop(true); }

void PlayingDirector::stop (  boolean    waitStop )  [inline]

Stops the director. if waitStop is true, the call doesn't return till the director has stopped. Otherwise, it asks the director to stop, but returns before it has stopped. If a PlayingObserver calls stop on the director, it has to use waitStop=false, otherwise it becomes a deadlock. { if(_playThread.isAlive()) { stopThread(waitStop); _playing = false; } }

void PlayingDirector::play (    )  [inline]

{ if(!_playThread.isAlive()) { _playing = true; startThread(new PlayingThread()); } }

void PlayingDirector::playFrom (  int    frameNr )  [inline]

If a PlayingObserver calls ths method, it can result in a deadlock. { setCurrentFrame(frameNr); play(); }

void PlayingDirector::reset (    )  [inline]

If a PlayingObserver calls ths method, it can result in a deadlock. { playFrom(0); }

void PlayingDirector::step (    )  [inline]

{ step(_frameInc); }

void PlayingDirector::step (  int    frameInc )  [inline]

{ if(!_playThread.isAlive()) { _curFrame += frameInc; startThread(new PlayOnceThread()); } }

void PlayingDirector::seekTo (  int    frameNr )  [inline]

Asks the director to jump to that frame. When the call returns, it is not guaranteed that the director has already visited that frame. But it is guaranteed that the director will visit it eventually. { _frameSeeker.seek(frameNr); }

void PlayingDirector::showCurrentFrame (    )  [inline]

{ step(0); }

void PlayingDirector::main (  String    args[] )  [inline, static]

{ PlayingDirector p = new PlayingDirector(); p.setNrFrames(100); p.addPlayingObserver(PlayingObserverFactory.makeDebugObserver()); p.addPlayingObserver(PlayingObserverFactory.makeDelayObserver(1000)); p.play(); /*try { Thread.sleep(1000); }catch(InterruptedException ex) {} System.out.println("stopping..."); p.doStop(); System.out.println("stop?");*/ }

---

The documentation for this class was generated from the following file:

• PlayingDirector.java

---