time_node.h

彩信浏览器

/*
 * This file is part of Ambulant Player, www.ambulantplayer.org.
 *
 * Copyright (C) 2003-2007 Stichting CWI, 
 * Kruislaan 413, 1098 SJ Amsterdam, The Netherlands.
 *
 * Ambulant Player is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
 * (at your option) any later version.
 *
 * Ambulant Player 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with Ambulant Player; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/* 
 * @$Id: time_node.h,v 1.49 2007/02/12 14:14:45 jackjansen Exp $ 
 */

#ifndef AMBULANT_SMIL2_TIME_NODE_H
#define AMBULANT_SMIL2_TIME_NODE_H

#include "ambulant/config/config.h"

#include "ambulant/lib/node.h"
#include "ambulant/lib/timer.h"
#include "ambulant/lib/node_navigator.h"
#include "ambulant/common/schema.h"
#include "ambulant/smil2/smil_time.h"
#include "ambulant/smil2/sync_rule.h"
#include "ambulant/smil2/time_attrs.h"
#include "ambulant/smil2/time_state.h"
#include "ambulant/smil2/time_nctx.h"

#include <cassert>
#include <utility>
#include <list>
#include <map>

namespace ambulant {

namespace smil2 {

// fwd declaration.
class time_calc;

// Represents a node in the timing model.

class time_node : public schedulable {
  public:
	typedef time_node_context context_type;
	typedef node_navigator<time_node> nnhelper;
	typedef node_navigator<const time_node> const_nnhelper;
	
	time_node(context_type *ctx, const node *n, time_container_type type = tc_none, bool discrete = false); 
	
	virtual ~time_node();
  	
	// TimeElement DOM interface
	// Currently support only startElement for the root.
	virtual void start();
	virtual void stop();
	virtual void pause();
	virtual void resume();
	virtual void reset();
	
	// driver interface
	virtual void exec(qtime_type timestamp);
	void get_pending_events(std::map<time_type, std::list<time_node*> >& events);
	
	// Sets the timer for this node
	// This node becomes the owner of the timer e.g. should delete it on exit
	// The timegraph builder has already established the clocks network
	virtual void set_timer(lib::timer_control *tmr) { m_timer = tmr;}
	virtual lib::timer_control *get_timer() { return m_timer;}
	
	// Timegarph configuration
	void set_want_activate_event(bool want) { m_want_activate_events = want;}
	void set_want_inbounds_event(bool want) { m_want_inbounds_events = want;}
	void set_want_outofbounds_event(bool want) { m_want_outofbounds_events = want;}
	void set_want_focusin_event(bool want) { m_want_focusin_events = want;}
	void set_want_focusout_event(bool want) { m_want_focusout_events = want;}
	bool wants_activate_event() const { return m_want_activate_events;}
	bool wants_inbounds_event() const { return m_want_inbounds_events;}
	bool wants_outofbounds_event() const { return m_want_outofbounds_events;}
	bool wants_focusin_event() const { return m_want_focusin_events;}
	bool wants_focusout_event() const { return m_want_focusout_events;}
	void want_accesskey(bool want) { m_want_accesskey = want;}
	bool want_accesskey() const { return m_want_accesskey;}

	// Functions that may be overriden by subclasses
	virtual time_node *append_child(time_node *child) {return nnhelper::append_child(this, child);}
	virtual void get_children(std::list<time_node*>& l) { nnhelper::get_children(this, l);}
	virtual void get_children(std::list<const time_node*>& l) const { const_nnhelper::get_children(this, l);}
	virtual time_type get_implicit_dur();
	
	// End sync functions
	virtual bool end_sync_cond_applicable() const { return false;}
	virtual bool end_sync_cond() const { return true;}
	
	// Begin and end conditions evaluator
	virtual bool begin_cond(qtime_type timestamp);
	virtual bool end_cond(qtime_type timestamp);

	// Feedback
	void node_started();

	// Forced transitions
	virtual void reset(qtime_type timestamp, time_node *oproot);
	virtual void reset_children(qtime_type timestamp, time_node *oproot);
	virtual void startup_children(qtime_type timestamp);
	virtual void kill(qtime_type timestamp, time_node *oproot);	
	virtual void kill_children(qtime_type timestamp, time_node *oproot);
	
	// Sync update 
	virtual void sync_update(qtime_type timestamp);
	
	// Begin of media update
	void on_bom(qtime_type timestamp);
	
	// End of media update
	void on_eom(qtime_type timestamp);
	
	// Return true if the node is waiting for on on_eom callback.
	bool want_on_eom();
	
	// Pause of media update
	void on_pom(qtime_type timestamp);
	
	// Resume of media update
	void on_rom(qtime_type timestamp);
	
	// End of simple duration update
	void on_eosd(qtime_type timestamp);
	
	// End of (visual) transition
	void on_transitioned(qtime_type timestamp);
	
	// Raising events
	virtual void raise_begin_event(qtime_type timestamp);
	virtual void raise_repeat_event(qtime_type timestamp);
	virtual void raise_end_event(qtime_type timestamp, time_node *oproot);
	virtual void raise_activate_event(qtime_type timestamp);
	virtual void raise_inbounds_event(qtime_type timestamp);
	virtual void raise_outofbounds_event(qtime_type timestamp);
	virtual void raise_focusin_event(qtime_type timestamp);
	virtual void raise_focusout_event(qtime_type timestamp);
	virtual void raise_accesskey(std::pair<qtime_type, int> accesskey);
	virtual void raise_update_event(qtime_type timestamp);
	
	// Interval manipulators	
	void set_interval(qtime_type timestamp, const interval_type& i);
	void cancel_interval(qtime_type timestamp);
	void update_interval(qtime_type timestamp, const interval_type& i);
	void update_interval_end(qtime_type timestamp, time_type newend);
	void played_interval(qtime_type timestamp);
	void clear_history() { m_history.clear(); }
	bool can_set_interval(qtime_type timestamp, const interval_type& i);
	
	// excl
	void defer_interval(qtime_type timestamp);
	
	// Node activities
	void activate(qtime_type timestamp);
	void repeat(qtime_type timestamp);
	void remove(qtime_type timestamp);
	void fill(qtime_type timestamp);
	void pause(qtime_type timestamp, pause_display d);
	void resume(qtime_type timestamp);
	void check_repeat(qtime_type timestamp);
	
	// Anchors and areas
	void follow_link(qtime_type timestamp);
	
	// Playable commands
	common::playable *create_playable();
	void start_playable(time_type offset = 0);
	void seek_playable(time_type offset);
	void pause_playable(common::pause_display d = common::display_show);
	void resume_playable();
	void repeat_playable();
	void stop_playable();
	time_type get_playable_dur();
	void prepare_playables();
	
	// Animations are special internal playables
	void start_animation(time_type offset);
	void stop_animation();
	
	// Std xml tree navigation interface
	const time_node *down() const { return m_child;}
	const time_node *up() const { return m_parent;}
	const time_node *next() const { return m_next;}

	time_node *down()  { return m_child;}
	time_node *up()  { return m_parent;}
	time_node *next()  { return m_next;}

	void down(time_node *n)  { m_child = n;}
	void up(time_node *n)  { m_parent = n;}
	void next(time_node *n)  { m_next = n;}
	
	const time_node* previous() const {return const_nnhelper::previous(this);}
	time_node* previous() { return nnhelper::previous(this);}
	
	time_node* last_child() { return nnhelper::last_child(this);}
	const time_node* last_child() const { return const_nnhelper::last_child(this);}
	
	time_node* get_root() {return nnhelper::get_root(this);}
	const time_node* get_root() const {return const_nnhelper::get_root(this);}
	
	bool is_descendent_of(time_node *tn) const {return const_nnhelper::is_descendent(this, tn);}
	
	void get_path(std::list<time_node*>& path) { nnhelper::get_path(this, path);}
	void get_path(std::list<const time_node*>& path) { const_nnhelper::get_path(this, path);}
	
	// tree iterators
	typedef tree_iterator<time_node> iterator;
	typedef const_tree_iterator<time_node> const_iterator;
	
    iterator begin() { return iterator(this);}
    const_iterator begin() const { return const_iterator(this);}

    iterator end() { return iterator(0);}
    const_iterator end() const { return const_iterator(0);}
	
	// Returns the underlying DOM node associated with this
	const node* dom_node() const { return m_node;}
	
	// Timing reference node for this.
	// This node uses the clock of the sync node for time notifications.
	// Here it is defined to be the parent unless it is the time root.
	// Could be the time root always (document time).
	const time_node* sync_node() const { return up()?up():this;}
	time_node* sync_node() { return up()?up():this;}
	time_type get_rad() const { return m_rad;}
	time_type get_pad() const { return m_pad;}
	value_type get_simple_time() const;
	time_type get_interval_end() const;
	value_type get_time() const;
	
	// Time type queries and classification
	time_container_type get_type() const { return m_type;}
	const char* get_type_as_str() const { return time_container_type_as_str(m_type);}
	bool is_time_container() const { return m_type != tc_none;}
	bool is_seq() const { return m_type == tc_seq;}
	bool is_par() const { return m_type == tc_par;}
	bool is_excl() const { return m_type == tc_excl;}
#if 1
	// Handling discrete media different than continuous media
	// is a bad idea from a SMIL point of view (the tag name
	// really is documentary only), and practically it
	// caused problems with AmisAmbulant, which wants to
	// pause after putting up a text node to allow the screen
	// reader to do its thing.
	// Code temporarily re-enabled because of bug #1553249.
	bool is_discrete() const { return m_discrete;}
#else
	bool is_discrete() const { return false;}
#endif
	bool is_root() const { return !up();}
	bool is_cmedia() const {return !is_time_container() && !is_discrete();}
	bool is_area() const { return m_attrs.get_tag() == "area";}
	bool is_a() const { return m_attrs.get_tag() == "a";}
	bool is_link() const { return is_area() || is_a();}
	bool is_animation() const;
	bool is_playable() const;

	const time_attrs* get_time_attrs() const { return &m_attrs;}
	bool needs_implicit_dur() const;
	
	// Time graph building functions
	
	// Adds a begin rule to this node.
	// The rule maybe implicit dictated by the model 
	// or due to an explicit begin spec in the DOM.
	// For each rule, the timegraph builder will call 
	// this function in pair with add_dependent() against
	// the node that this rule depends on.
	void add_begin_rule(sync_rule *sr);
	
	// Adds an end rule to this node.
	// The rule maybe implicit dictated by the model 
	// or due to an explicit end spec in the DOM.
	// For each rule, the timegraph builder will call 
	// this function in pair with add_dependent() against
	// the node that this rule depends on.
	void add_end_rule(sync_rule *sr);
	
	// Sets the transOut rule for this node.
	void set_transout_rule(sync_rule *sr);
	
	// Adds a rule that dependents on this time node.
	// The rule will get a timestamped notification from this
	// node when the real or model event specified by the ev
	// argument occurs for this node.
	void add_dependent(sync_rule *sr, sync_event ev); 
			
	// Update dependents
	void on_new_instance(qtime_type timestamp, sync_event ev, time_type instance, time_node *filter=0);
	void on_cancel_instance(qtime_type timestamp, sync_event ev, time_type instance, time_node *filter=0);
	void on_update_instance(qtime_type timestamp, sync_event ev, time_type instance, time_type old_instance, time_node *filter=0);
	void on_add_instance(qtime_type timestamp, sync_event ev, time_type instance, int data = 0, time_node *filter=0);
		
	// Returns the lifetime state handler object of this time node
	time_state* get_state() { return m_state;}
	const time_state* get_state() const { return m_state;}
	
	// Retuns the context of this time node
	context_type* get_context() {return m_context;}
	void set_context(context_type *ctx) { m_context = ctx;}
	
	// Sets the state of this node
	void set_state(time_state_type state, qtime_type timestamp, time_node *oproot);
	// Calls set_state() after checking for excl
	void set_state_ex(time_state_type tst, qtime_type timestamp);