basesynthesizerqueueitem.java

这是java 开发的的免费语音播放插件,很值得学习参考!!!!!!!!!!!!111

        Enumeration E;
	if (synth.speakableListeners != null) {
            E = synth.speakableListeners.elements();
            while (E.hasMoreElements()) {
                SpeakableListener sl = (SpeakableListener) E.nextElement();
                sl.speakableCancelled(event);
            }
        }
    }

    /**
     * Utility function that generates a
     * <code>SPEAKABLE_ENDED</code> event and posts it
     * to the event queue.  Eventually
     * <code>fireSpeakableEnded</code> will be called
     * by <code>dispatchSpeechEvent</code> as a result
     * of this action.
     *
     * @see #fireSpeakableEnded
     * @see #dispatchSpeechEvent
     */
    public void postSpeakableEnded() {
	boolean shouldPost;

    // The JSAPI docs say that once a cancelled event is sent, no
    // others will be. This makes sure that a cancelled will never be
    // sent twice. This deals with the race that can occur when an
    // item that is playing is cancelled.
	synchronized(this) {
	    shouldPost = !done;
            done = true;
	}
	if (shouldPost) {
	    SpeechEventUtilities.postSpeechEvent(
		this,
		new SpeakableEvent(source, SpeakableEvent.SPEAKABLE_ENDED));
	}
    }


    /**
     * Utility function that sends a <code>SPEAKABLE_ENDED</code> event
     * to all speakable listeners.
     *
     * @param event the <code>SPEAKABLE_ENDED</code> event
     *
     * @see #postSpeakableEnded
     */
    public void fireSpeakableEnded(SpeakableEvent event) {
        if (listener != null) {
            listener.speakableEnded(event);
        }
        
        Enumeration E;
	if (synth.speakableListeners != null) {
            E = synth.speakableListeners.elements();
            while (E.hasMoreElements()) {
                SpeakableListener sl = (SpeakableListener) E.nextElement();
                sl.speakableEnded(event);
            }
        }
    }

    /**
     * Utility function that generates a
     * <code>SPEAKABLE_PAUSED</code> event and posts it
     * to the event queue.  Eventually
     * <code>fireSpeakablePaused</code> will be called
     * by <code>dispatchSpeechEvent</code> as a result
     * of this action.
     *
     * @see #fireSpeakablePaused
     * @see #dispatchSpeechEvent
     */
    public void postSpeakablePaused() {
        SpeechEventUtilities.postSpeechEvent(
            this,
            new SpeakableEvent(source, SpeakableEvent.SPEAKABLE_PAUSED));
    }

    /**
     * Utility function that sends a <code>SPEAKABLE_PAUSED</code> event
     * to all speakable listeners.
     *
     * @param event the <code>SPEAKABLE_PAUSED</code> event
     *
     * @see #postSpeakablePaused
     */
    public void fireSpeakablePaused(SpeakableEvent event) {
        if (listener != null) {
            listener.speakablePaused(event);
        }
        
        Enumeration E;
	if (synth.speakableListeners != null) {
            E = synth.speakableListeners.elements();
            while (E.hasMoreElements()) {
                SpeakableListener sl = (SpeakableListener) E.nextElement();
                sl.speakablePaused(event);
            }
        }
    }

    /**
     * Utility function that generates a
     * <code>SPEAKABLE_RESUMED</code> event and posts it
     * to the event queue.  Eventually
     * <code>fireSpeakableResumed</code> will be called
     * by <code>dispatchSpeechEvent</code> as a result
     * of this action.
     *
     * @see #fireSpeakableResumed
     * @see #dispatchSpeechEvent
     */
    public void postSpeakableResumed() {
        SpeechEventUtilities.postSpeechEvent(
            this,
            new SpeakableEvent(source, SpeakableEvent.SPEAKABLE_RESUMED));
    }

    /**
     * Utility function that sends a <code>SPEAKABLE_RESUMED</code> event
     * to all speakable listeners.
     *
     * @param event the <code>SPEAKABLE_RESUMED</code> event
     *
     * @see #postSpeakableResumed
     */
    public void fireSpeakableResumed(SpeakableEvent event) {
        if (listener != null) {
            listener.speakableResumed(event);
        }
        
        Enumeration E;
	if (synth.speakableListeners != null) {
            E = synth.speakableListeners.elements();
            while (E.hasMoreElements()) {
                SpeakableListener sl = (SpeakableListener) E.nextElement();
                sl.speakableResumed(event);
            }
        }
    }

    /**
     * Utility function that generates a
     * <code>SPEAKABLE_STARTED</code> event and posts it
     * to the event queue.  Eventually
     * <code>fireSpeakableStarted</code> will be called
     * by <code>dispatchSpeechEvent</code> as a result
     * of this action.
     *
     * @see #fireSpeakableStarted
     * @see #dispatchSpeechEvent
     */
    public void postSpeakableStarted() {
        SpeechEventUtilities.postSpeechEvent(
            this,
            new SpeakableEvent(source, SpeakableEvent.SPEAKABLE_STARTED));
    }

    /**
     * Utility function that sends a <code>SPEAKABLE_STARTED</code> event
     * to all speakable listeners.
     *
     * @param event the <code>SPEAKABLE_STARTED</code> event
     *
     * @see #postSpeakableStarted
     */
    public void fireSpeakableStarted(SpeakableEvent event) {
        if (listener != null) {
            listener.speakableStarted(event);
        }
        
        Enumeration E;
	if (synth.speakableListeners != null) {
            E = synth.speakableListeners.elements();
            while (E.hasMoreElements()) {
                SpeakableListener sl = (SpeakableListener) E.nextElement();
                sl.speakableStarted(event);
            }
        }
    }

    /**
     * Utility function that generates a
     * <code>TOP_OF_QUEUE</code> event and posts it
     * to the event queue.  Eventually
     * <code>fireTopOfQueue</code> will be called
     * by <code>dispatchSpeechEvent</code> as a result
     * of this action.
     *
     * @see #fireTopOfQueue
     * @see #dispatchSpeechEvent
     */
    public void postTopOfQueue() {
        SpeechEventUtilities.postSpeechEvent(
            this,
            new SpeakableEvent(source, SpeakableEvent.TOP_OF_QUEUE));
    }

    /**
     * Utility function that sends a <code>TOP_OF_QUEUE</code> event
     * to all speakable listeners.
     *
     * @param event the <code>TOP_OF_QUEUE</code> event
     *
     * @see #postTopOfQueue
     */
    public void fireTopOfQueue(SpeakableEvent event) {
        if (listener != null) {
            listener.topOfQueue(event);
        }
        
        Enumeration E;
	if (synth.speakableListeners != null) {
            E = synth.speakableListeners.elements();
            while (E.hasMoreElements()) {
                SpeakableListener sl = (SpeakableListener) E.nextElement();
                sl.topOfQueue(event);
            }
        }
    }

    /**
     * Utility function that generates a
     * <code>WORD_STARTED</code> event and posts it
     * to the event queue.  Eventually
     * <code>fireWordStarted</code> will be called
     * by <code>dispatchSpeechEvent</code> as a result
     * of this action.
     *
     * @see #fireWordStarted
     * @see #dispatchSpeechEvent
     */
    public void postWordStarted(String text, int wordStart, int wordEnd) {
        SpeechEventUtilities.postSpeechEvent(
            this,
            new SpeakableEvent(source, SpeakableEvent.WORD_STARTED,
                               text, wordStart, wordEnd));
    }

    /**
     * Utility function that sends a <code>WORD_STARTED</code> event
     * to all speakable listeners.
     *
     * @param event the <code>WORD_STARTED</code> event
     *
     * @see #postWordStarted
     */
    public void fireWordStarted(SpeakableEvent event) {
        if (listener != null) {
            listener.wordStarted(event);
        }
        
        Enumeration E;
	if (synth.speakableListeners != null) {
            E = synth.speakableListeners.elements();
            while (E.hasMoreElements()) {
                SpeakableListener sl = (SpeakableListener) E.nextElement();
                sl.wordStarted(event);
            }
        }
    }

    /**
     * Dispatches a <code>SpeechEvent</code>.
     * The dispatcher should notify all <code>EngineListeners</code>
     * from this method.  The <code>SpeechEvent</code> was added
     * via the various post methods of this class.
     *
     * @param event the <code>SpeechEvent</code> to dispatch
     *
     * @see #postMarkerReached
     * @see #postSpeakableCancelled
     * @see #postSpeakableEnded
     * @see #postSpeakablePaused
     * @see #postSpeakableResumed
     * @see #postSpeakableStarted
     * @see #postTopOfQueue
     * @see #postWordStarted
     */
    public void dispatchSpeechEvent(SpeechEvent event) {
        switch (event.getId()) {
            case SpeakableEvent.MARKER_REACHED:
                fireMarkerReached((SpeakableEvent) event);
                break;
            case SpeakableEvent.SPEAKABLE_CANCELLED:
                fireSpeakableCancelled((SpeakableEvent) event);
                break;
            case SpeakableEvent.SPEAKABLE_ENDED:
                fireSpeakableEnded((SpeakableEvent) event);
                break;
            case SpeakableEvent.SPEAKABLE_PAUSED:
                fireSpeakablePaused((SpeakableEvent) event);
                break;
            case SpeakableEvent.SPEAKABLE_RESUMED:
                fireSpeakableResumed((SpeakableEvent) event);
                break;
            case SpeakableEvent.SPEAKABLE_STARTED:
                fireSpeakableStarted((SpeakableEvent) event);
                break;
            case SpeakableEvent.TOP_OF_QUEUE:
                fireTopOfQueue((SpeakableEvent) event);
                break;
            case SpeakableEvent.WORD_STARTED:
                fireWordStarted((SpeakableEvent) event);
                break;
        }
    }
}