timegraph.cpp

彩信浏览器

		// To do this we need to consider its freeze behaviour and its context
		AM_DBG m_logger->debug("%s[%s] transOut with fill: %s start:%ld ms before remove", 
			ta->get_tag().c_str(), ta->get_id().c_str(), repr(ta->get_fill()).c_str(), offset());
		if(ta->get_fill() == fill_remove) {
			sync_rule *sr = new transout_rule(tn, tn_end, offset);
			tn->set_transout_rule(sr);
		} else if(ta->get_fill() == fill_freeze) {
			// XXXX This is a hack to make the default work, at least
			// What really should happen depends on the parent, etc.
			sync_rule *sr = new transout_rule(tn, tn_end, offset);
			tn->set_transout_rule(sr);
		} // else not implemented yet
	}
}

// Adds to the provided time node all begin rules 
void timegraph::add_begin_sync_rules(time_node *tn) {
	// get node begin list
	const time_attrs::sync_list& list = 
		tn->get_time_attrs()->get_begin_list();
	time_attrs::sync_list::const_iterator it;
	time_node *parent = tn->up();
	
	if(!parent) {
		// root is special
		return;
	}
		
	if(list.empty()) {
		// add implicit begin rule
		sync_rule *sr = create_impl_syncbase_begin_rule(tn);
		tn->add_begin_rule(sr);
		return;
	}
	
	// add any specified begin offsets rules
	for(it = list.begin(); it!= list.end(); it++) {
		const sync_value_struct& svs = *it;
		if((svs.type == sv_offset || svs.type == sv_indefinite) && 
			(!parent->is_seq() || (parent->is_seq() && svs.offset>=0))) {
			sync_rule *sr = create_impl_syncbase_rule(tn, svs.offset);
			tn->add_begin_rule(sr);
			if(parent->is_seq()) break;
		} 
	}
	
	if(parent->is_seq()) {
		// For children of a sequence, the only legal value for 
		// begin is a single non-negative offset value.
		return;
	}
	
	// add any specified begin syncbase rules
	for(it = list.begin(); it!= list.end(); it++) {
		const sync_value_struct& svs = *it;
		if(svs.type == sv_syncbase) {
			time_node *base = get_node_with_id(svs.base, tn);
			if(!base) continue;
			if(svs.event == "begin") {
				sync_rule *sr = new model_rule(base, tn_begin, svs.offset);
				tn->add_begin_rule(sr);
			} else if(svs.event == "end") {
				sync_rule *sr = new model_rule(base, tn_end, svs.offset);
				tn->add_begin_rule(sr);
			}
		}
	}
	
	// add any specified begin event rules
	for(it = list.begin(); it!= list.end(); it++) {
		const sync_value_struct& svs = *it;
		if(svs.type == sv_event) {
			time_node *base = svs.base.empty()?tn:get_node_with_id(svs.base, tn);
			if(!base) continue;
			sync_event event = sync_event_from_str(svs.event);
			if(event == tn_activate_event)
				base->set_want_activate_event(true);
			else if (event == tn_focusin_event)
				base->set_want_focusin_event(true);
			else if (event == tn_focusout_event)
				base->set_want_focusout_event(true);
			else if (event == tn_inbounds_event)
				base->set_want_inbounds_event(true);
			else if (event == tn_outofbounds_event)
				base->set_want_outofbounds_event(true);
			sync_rule *sr = new event_rule(base, event, svs.offset);
			tn->add_begin_rule(sr);
		} else if(svs.type == sv_repeat) {
			time_node *base = svs.base.empty()?tn:get_node_with_id(svs.base, tn);
			if(!base) continue;
			sync_rule *sr = new event_rule(base, tn_repeat_event, svs.offset, svs.iparam);
			tn->add_begin_rule(sr);
		} else if(svs.type == sv_accesskey) {
			tn->want_accesskey(true);
			sync_rule *sr = new event_rule(m_root, accesskey_event, svs.offset, svs.iparam);
			tn->add_begin_rule(sr);
		} else if(svs.type == sv_media_marker) {
			sync_rule *sr = new event_rule(tn, tn_marker_event, svs.offset, svs.sparam);
			tn->add_begin_rule(sr);
		}
	}
}

// Adds to the provided time node all end rules 
void timegraph::add_end_sync_rules(time_node *tn) {
	// get node end list
	const time_attrs::sync_list& list = 
		tn->get_time_attrs()->get_end_list();
	time_attrs::sync_list::const_iterator it;
	time_node *parent = tn->up();
	
	// root is special
	if(!parent) return;
	
	if(list.empty()) return;
	
	// add any specified end offsets rules
	for(it = list.begin(); it!= list.end(); it++) {
		const sync_value_struct& svs = *it;
		if(svs.type == sv_offset) {
			sync_rule *sr = create_impl_syncbase_rule(tn, svs.offset);
			tn->add_end_rule(sr);
		}
	}
	
	// add any specified end syncbase rules
	for(it = list.begin(); it!= list.end(); it++) {
		const sync_value_struct& svs = *it;
		if(svs.type == sv_syncbase) {
			time_node *base = get_node_with_id(svs.base, tn);
			if(!base) continue;
			if(svs.event == "begin") {
				sync_rule *sr = new model_rule(base, tn_begin, svs.offset);
				tn->add_end_rule(sr);
			} else if(svs.event == "end") {
				sync_rule *sr = new model_rule(base, tn_end, svs.offset);
				tn->add_end_rule(sr);
			}
		}
	}
	
	// add any specified end event rules
	for(it = list.begin(); it!= list.end(); it++) {
		const sync_value_struct& svs = *it;
		if(svs.type == sv_event) {
			time_node *base = svs.base.empty()?tn:get_node_with_id(svs.base, tn);
			if(!base) continue;
			sync_event event = sync_event_from_str(svs.event);
			if(event == tn_activate_event)
				base->set_want_activate_event(true);
			else if (event == tn_focusin_event)
				base->set_want_focusin_event(true);
			else if (event == tn_focusout_event)
				base->set_want_focusout_event(true);
			else if (event == tn_inbounds_event)
				base->set_want_inbounds_event(true);
			else if (event == tn_outofbounds_event)
				base->set_want_outofbounds_event(true);
			sync_rule *sr = new event_rule(base, event, svs.offset);
			tn->add_end_rule(sr);
		} else if(svs.type == sv_repeat) {
			time_node *base = svs.base.empty()?tn:get_node_with_id(svs.base, tn);
			if(!base) continue;
			sync_rule *sr = new event_rule(base, tn_repeat_event, svs.offset, svs.iparam);
			tn->add_end_rule(sr);
		} else if(svs.type == sv_accesskey) {
			tn->want_accesskey(true);
			sync_rule *sr = new event_rule(m_root, accesskey_event, svs.offset, svs.iparam);
			tn->add_end_rule(sr);
		} else if(svs.type == sv_media_marker) {
			sync_rule *sr = new event_rule(tn, tn_marker_event, svs.offset, svs.sparam);
			tn->add_end_rule(sr);
		}
	}
	
}

sync_rule*
timegraph::create_impl_syncbase_begin_rule(time_node *tn) {
	time_node *parent = tn->up();
	assert(parent!=0);
	sync_rule *sr = 0;
	if(parent->is_par()) {
		sr = new offset_rule(parent, tn_begin, 0);
	} else if(parent->is_seq()) {
		time_node *previous = tn->previous();
		if(!previous) {
			sr = new offset_rule(parent, tn_begin, 0);
		} else {
			sr = new model_rule(previous, tn_end, 0);
		}
	} else if(parent->is_excl()) {
		sr = new offset_rule(parent, tn_begin, time_type::indefinite());
	} else {
		// area, animation
		sr = new offset_rule(parent, tn_begin, 0);
	}
	return sr;
}

sync_rule*
timegraph::create_impl_syncbase_rule(time_node *tn, time_type offset) {
	time_node *parent = tn->up();
	assert(parent!=0);
	sync_rule *sr = 0;
	if(parent->is_par()) {
		sr = new offset_rule(parent, tn_begin, offset);
	} else if(parent->is_seq()) {
		time_node *previous = tn->previous();
		if(!previous) {
			sr = new offset_rule(parent, tn_begin, offset);
		} else {
			sr = new model_rule(previous, tn_end, offset);
		}
	} else if(parent->is_excl()) {
		sr = new offset_rule(parent, tn_begin, offset);
	} else {
		// area, animation
		sr = new offset_rule(parent, tn_begin, offset);
	}
	return sr;
}

time_node* 
timegraph::get_node_with_id(const std::string& ident) const {
	std::map<std::string, time_node*>::const_iterator it = m_id2tn.find(ident);
	return (it != m_id2tn.end())?(*it).second:0;
}

time_node* 
timegraph::get_node_with_id(const std::string& ident, time_node *tn) const {
	std::map<std::string, time_node*>::const_iterator it = m_id2tn.find(ident);
	if(it != m_id2tn.end()) return (*it).second;
	// check also for special logical syncbases 
	if(ident == "prev") return tn->previous();
	return 0;
}

const lib::node* 
timegraph::select_switch_child(const node* sn) const {
	std::list<const node*> cl;
	std::list<const node*>::const_iterator it;
	sn->get_children(cl);
	for(it=cl.begin();it!=cl.end();it++) {
		test_attrs ta(*it);
		if(!ta.selected()) {
			AM_DBG m_logger->debug("Filtering out node: %s[%s]", 
				ta.get_tag().c_str(), ta.get_id().c_str());
		} else return (*it);
	}
	return 0;
}