time_attrs.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_attrs.h,v 1.14 2007/02/12 14:14:45 jackjansen Exp $ 
 */

#ifndef AMBULANT_SMIL2_TIME_ATTRS_H
#define AMBULANT_SMIL2_TIME_ATTRS_H

#include "ambulant/config/config.h"

#include "ambulant/smil2/smil_time.h"
#include "ambulant/common/playable.h"
#include "ambulant/lib/logger.h"
#include "ambulant/lib/node.h"
#include "ambulant/lib/transition_info.h"
#include <string>


namespace ambulant {

namespace smil2 {

using namespace lib;
using namespace common;

enum dur_type {dt_unspecified, dt_definite, dt_indefinite, dt_media};

enum sync_value_type {
	sv_offset, 
	sv_syncbase,
	sv_event, 
	sv_repeat, 
	sv_accesskey, 
	sv_media_marker, 
	sv_wallclock, 
	sv_indefinite
};
std::string repr(sync_value_type sv);

struct sync_value_struct {
	sync_value_type type;
	time_traits::value_type offset;
	std::string base;
	std::string event;
	std::string sparam;
	int iparam;
};

std::string repr(const sync_value_struct& svs);

enum endsync_rule {esr_first, esr_last, esr_all, esr_media, esr_id};

// The last three values are intermediate values
// and don't represent a final fill_behavior.
enum fill_behavior {fill_remove, fill_freeze, fill_hold, 
	fill_transition, 
	fill_auto, fill_default, fill_inherit}; 
std::string repr(fill_behavior f);

// The last two values are intermediate values
// and don't represent a restart_behavior.
enum restart_behavior { restart_always, restart_when_not_active, restart_never,
	restart_default, restart_inherit};
std::string repr(restart_behavior f);

enum actuate { actuate_onload, actuate_onrequest};
std::string repr(actuate f);

class lib::logger;

class time_attrs : public time_traits {
  public:
	time_attrs(const lib::node *n);
	
	bool specified_dur() const { return (m_spflags & SP_DUR) == SP_DUR;}
	bool specified_begin() const { return (m_spflags & SP_BEGIN) == SP_BEGIN;}
	bool specified_end() const { return (m_spflags & SP_END) == SP_END;}
	bool specified_rdur() const { return (m_spflags & SP_RDUR) == SP_RDUR;}
	bool specified_rcount() const { return (m_spflags & SP_RCOUNT) == SP_RCOUNT;}
	bool specified_min() const { return (m_spflags & SP_MIN) == SP_MIN;}
	bool specified_max() const { return (m_spflags & SP_MAX) == SP_MAX;}
	bool specified_endsync() const { return (m_spflags & SP_ENDSYNC) == SP_ENDSYNC;}
	bool specified_fill() const { return (m_spflags & SP_FILL) == SP_FILL;}
	bool specified_restart() const { return (m_spflags & SP_RESTART) == SP_RESTART;}
	
	std::string get_begin() const;
	std::string get_end() const;
	
	bool end_is_indefinite() const;
	bool end_has_event_conditions() const;
	bool has_dur_specifier() const;
		
	const std::string& get_tag() const { return m_tag;}
	const std::string& get_id() const { return m_id;}
	
	///////////////////////////////
	// attr structures and parsing functions
	
	void parse_time_attrs();
	
	struct dur_t {
		dur_type type;
		time_type value;
	} m_dur;
	void parse_dur();
	dur_type get_dur_type() const { return m_dur.type;}
	time_type get_dur() const { return m_dur.value;}
	
	double m_rcount;
	void parse_rcount();
	bool is_rcount_indefinite() const { 
		return m_rcount == std::numeric_limits<double>::max();
	}
	double get_rcount() const { return m_rcount;}
	
	time_type m_rdur;
	void parse_rdur();
	time_type get_rdur() const { return m_rdur;}
	
	
	struct min_t {
		bool media;
		time_type value;
	} m_min;
	void parse_min();
	bool has_media_min() const { return m_min.media;}
	time_type get_min() const { return m_min.value;}
	
	struct max_t {
		bool media;
		time_type value;
	} m_max;
	void parse_max();
	bool has_media_max() const { return m_max.media;}
	time_type get_max() const { return m_max.value;}
	
	// see data struct above
	typedef std::list<sync_value_struct> sync_list;
	sync_list m_blist;
	sync_list m_elist;
	void parse_begin();
	void parse_end();
	void parse_plain_offset(const std::string& s, sync_value_struct& svs, sync_list& sl);
	void parse_wallclock(const std::string& s, sync_value_struct& svs, sync_list& sl);
	void parse_accesskey(const std::string& s, sync_value_struct& svs, sync_list& sl);
	void parse_nmtoken_offset(const std::string& s, sync_value_struct& svs, sync_list& sl); 
	const sync_list& get_begin_list() const { return m_blist;}
	const sync_list& get_end_list() const { return m_elist;}
	//
	struct endsync {
		endsync_rule rule;
		std::string ident;
	} m_endsync;
	void parse_endsync();
	endsync_rule get_endsync_rule() const { return m_endsync.rule;}
	const std::string& get_endsync_id() const { return m_endsync.ident;}
	
	//
	fill_behavior m_fill;
	void parse_fill();
	fill_behavior get_default_fill();
	fill_behavior modulated_fill(fill_behavior fb);
	fill_behavior get_fill() const { return m_fill;}
	
	//
	restart_behavior m_restart;
	void parse_restart();
	restart_behavior get_default_restart();
	restart_behavior get_restart() const { return m_restart;}

	//
	actuate m_actuate;
	void parse_actuate();
	actuate get_actuate() const { return m_actuate;}
	
	// Time manipulations
	double m_speed;
	double m_accelerate;
	double m_decelerate;
	bool m_auto_reverse;
	void parse_time_manipulations();
	bool has_time_manipulations() const;
	double get_speed() const { return m_speed;}
	double get_accelerate() const { return m_accelerate;}
	double get_decelerate() const { return m_decelerate;}
	bool auto_reverse() const { return m_auto_reverse;}
	
	// Transitions
	const lib::transition_info *m_trans_in;
	const lib::transition_info *m_trans_out;
	void parse_transitions();
	const lib::transition_info *get_trans_in() const { return m_trans_in;}
	const lib::transition_info *get_trans_out() const { return m_trans_out;}
	time_type get_trans_in_dur() const { return m_trans_in->m_dur;}
	time_type get_trans_out_dur() const { return m_trans_out->m_dur;}
	
  private:
	void parse_sync_list(const std::list<std::string>& strlist, sync_list& svslist);

	// keep for now a ref / should be removed
	const lib::node *m_node;
	std::string m_id;
	std::string m_tag;
	typedef std::string::size_type size_type;
	
	// flags indicating specified attributes
	long m_spflags;
	void set_specified(int ind) {m_spflags |= ind;}
	enum { SP_DUR = 1, SP_BEGIN = SP_DUR << 1, SP_END = SP_BEGIN << 1, SP_RDUR = SP_END << 1, 
		SP_RCOUNT = SP_RDUR << 1, SP_MIN = SP_RCOUNT << 1, SP_MAX = SP_MIN << 1,
		SP_ENDSYNC = SP_MAX << 1, SP_FILL = SP_ENDSYNC << 1, SP_RESTART = SP_FILL << 1};
	
	const char *time_spec_id(const sync_list& sl) { return (&sl==&m_blist)?"begin":"end";}
	
	lib::logger *m_logger;
};

enum interrupt_type {int_stop, int_pause, int_defer, int_never};

struct priority_attrs {
	interrupt_type higher;
	interrupt_type peers;
	interrupt_type lower;
	common::pause_display display;
	
	priority_attrs() : higher(int_pause), peers(int_stop), lower(int_defer), display(common::display_show) {}
	static priority_attrs* create_instance(const lib::node *n);
	static interrupt_type interrupt_from_str(const std::string& spec);
	static common::pause_display display_from_str(const std::string& spec);
};

class schedulable : public time_traits {
  public:
	virtual ~schedulable(){}
	
	virtual const time_attrs* get_time_attrs() const = 0;
	
	// Return unresolved when unknown
	virtual time_type get_implicit_dur() = 0;
	virtual time_type get_last_dur() const = 0;
};

} // namespace smil2
 
} // namespace ambulant

#endif // AMBULANT_SMIL2_TIME_ATTRS_H