dg_player.cpp

彩信浏览器

	wi->v->redraw();
	delete wi->v;
	m_hoster.destroy_os_window(wi->h);
	delete wi;
	AM_DBG m_logger->debug("windows: %d", m_windows.size());
}

common::bgrenderer*
gui::dg::dg_player::new_background_renderer(const common::region_info *src) {
	return new dg_bgrenderer(src);
}

gui::dg::viewport* gui::dg::dg_player::create_viewport(int w, int h, HWND hwnd) {
	AM_DBG m_logger->debug("dg_player::create_viewport(%d, %d)", w, h);
	PostMessage(hwnd, WM_SET_CLIENT_RECT, w, h);
	viewport *v = new gui::dg::viewport(w, h, hwnd);
	v->redraw();
	return v;
}

gui::dg::dg_player::wininfo*
gui::dg::dg_player::get_wininfo(HWND hwnd) {
	wininfo *winfo = 0;
	std::map<std::string, wininfo*>::iterator it;
	for(it=m_windows.begin();it!=m_windows.end();it++) {
		wininfo *wi = (*it).second;
		if(wi->h = hwnd) {winfo = wi;break;}
	}
	return winfo;
}

common::gui_window *
gui::dg::dg_player::get_window(HWND hwnd) {
	wininfo *wi = get_wininfo(hwnd);
	return wi?wi->w:0;
}

HWND
gui::dg::dg_player::get_main_window() {
	// XXXX Unsure that this is correct: we just return any window
	std::map<std::string, wininfo*>::iterator it = m_windows.begin();
	if (it == m_windows.end()) return NULL;
	return (*it).second->h;
}

////////////////////
// common::playable_factory implementation

common::playable *
gui::dg::dg_playable_factory::new_playable(
	common::playable_notification *context,
	common::playable_notification::cookie_type cookie,
	const lib::node *node,
	lib::event_processor *const evp) {
	
	common::gui_window *window = NULL; // get_window(node);
	assert(window);
	common::playable *p = 0;
	lib::xml_string tag = node->get_qname().second;
	if(tag == "text") {
		p = new dg_text_renderer(context, cookie, node, evp, m_factory, window);
	} else if(tag == "img") {
		p = new dg_img_renderer(context, cookie, node, evp, m_factory, window, m_dgplayer);
	} else if(tag == "audio") {
		p = new dg_audio_renderer(context, cookie, node, evp, window, 0/*m_worker_processor*/);
	} else if(tag == "video") {
		p = new dg_area(context, cookie, node, evp, window);
	} else if(tag == "area") {
		p = new dg_area(context, cookie, node, evp, window);
	} else if(tag == "brush") {
		p = new dg_brush(context, cookie, node, evp, window);
	} else {
		p = new dg_area(context, cookie, node, evp, window);
	}
	return p;
}

common::playable *
gui::dg::dg_playable_factory::new_aux_audio_playable(
		common::playable_notification *context,
		common::playable_notification::cookie_type cookie,
		const lib::node *node,
		lib::event_processor *evp,
		net::audio_datasource *src)
{
	return NULL;
}
void gui::dg::dg_player::set_intransition(common::playable *p, const lib::transition_info *info) { 
	AM_DBG lib::logger::get_logger()->debug("set_intransition : %s", repr(info->m_type).c_str());
	lib::timer_control *timer = new lib::timer_control_impl(m_timer, 1.0, false);
	dg_transition *tr = make_transition(info->m_type, p, timer);
	m_trmap[p] = tr;
	tr->init(p->get_renderer()->get_surface(), false, info);
	tr->first_step();
	if(!m_update_event) schedule_update();
}

void gui::dg::dg_player::start_outtransition(common::playable *p, const lib::transition_info *info) {  
	lib::logger::get_logger()->debug("start_outtransition : %s", repr(info->m_type).c_str());
	lib::timer_control *timer = new lib::timer_control_impl(m_timer, 1.0, false);
	dg_transition *tr = make_transition(info->m_type, p, timer);
	m_trmap[p] = tr;
	tr->init(p->get_renderer()->get_surface(), true, info);
	tr->first_step();
	if(!m_update_event) schedule_update();
}

bool gui::dg::dg_player::has_transitions() const {
	return !m_trmap.empty();
}

void gui::dg::dg_player::update_transitions() {
	m_trmap_cs.enter();
	for(trmap_t::iterator it=m_trmap.begin();it!=m_trmap.end();it++) {
		if(!(*it).second->next_step()) {
			delete (*it).second;
			m_trmap.erase(it);
			break;
		}
	}
	m_trmap_cs.leave();
}

void gui::dg::dg_player::clear_transitions() {
	m_trmap_cs.enter();
	for(trmap_t::iterator it=m_trmap.begin();it!=m_trmap.end();it++)
		delete (*it).second;
	m_trmap.clear();
	m_trmap_cs.leave();
}

gui::dg::dg_transition *gui::dg::dg_player::get_transition(common::playable *p) {
	trmap_t::iterator it = m_trmap.find(p);
	return (it != m_trmap.end())?(*it).second:0;
}

void gui::dg::dg_player::stopped(common::playable *p) {
	m_trmap_cs.enter();
	trmap_t::iterator it = m_trmap.find(p);
	if(it != m_trmap.end()) {
		delete (*it).second;
		m_trmap.erase(it);
	}
	m_trmap_cs.leave();
}

void gui::dg::dg_player::paused(common::playable *p) {
	trmap_t::iterator it = m_trmap.find(p);
	if(it != m_trmap.end()) {
		(*it).second->pause();
	}
}

void gui::dg::dg_player::resumed(common::playable *p) {
	trmap_t::iterator it = m_trmap.find(p);
	if(it != m_trmap.end()) {
		(*it).second->resume();
	}
}

void gui::dg::dg_player::update_callback() {
	if(!m_update_event) return;
	if(has_transitions()) {
		update_transitions();
		schedule_update();
	} else {
		m_update_event = 0;
	}
}

void gui::dg::dg_player::schedule_update() {
	if(!m_player) return;
	m_update_event = new lib::no_arg_callback_event<dg_player>(this, 
		&dg_player::update_callback);
	m_worker_processor->add_event(m_update_event, 50, lib::ep_low);
}

////////////////////////
// Layout helpers with a lot of hacks

typedef common::surface_template iregion;
typedef common::surface_impl region;

static const region* 
get_top_layout(smil2::smil_layout_manager *layout, const lib::node* n) {
	iregion *ir = layout->get_region(n);
	if(!ir) return 0;
	const region *r = (const region*) ir;
	while(r->get_parent()) r = r->get_parent();
	return r;
}

static const char*
get_top_layout_name(smil2::smil_layout_manager *layout, const lib::node* n) {
	const region* r = get_top_layout(layout, n);
	if(!r) return 0;
	const common::region_info *ri = r->get_info();
	return ri?ri->get_name().c_str():0;
}

#if 0
common::gui_window *
gui::dg::dg_player::get_window(const lib::node* n) {
	typedef common::surface_template region;
	smil2::smil_layout_manager *layout = m_player->get_layout();
	const char *tlname = get_top_layout_name(layout, n);
	if(tlname) {
		std::map<std::string, wininfo*>::iterator it;
		it = m_windows.find(tlname);
		if(it != m_windows.end())
			return (*it).second->w;
	}
	std::map<std::string, wininfo*>::iterator it = m_windows.begin();
	assert(it != m_windows.end());
	wininfo* winfo = (*it).second;
	return winfo->w;
}
#endif
void gui::dg::dg_player::show_file(const net::url& href) {
#ifndef _WIN32_WCE
	std::string s = href.get_url();
	ShellExecute(GetDesktopWindow(), text_str("open"), textptr(s.c_str()), NULL, NULL, SW_SHOWNORMAL);
#else
	SHELLEXECUTEINFO si;
	memset(&si, 0, sizeof(si));
	si.cbSize = sizeof(si);
	si.lpVerb = text_str("open"); 
	std::string s = href.get_url();
	si.lpFile = textptr(s.c_str()).c_wstr(); 
	si.nShow = SW_SHOWNORMAL; 
	ShellExecuteEx(&si);
#endif
}

void gui::dg::dg_player::done(common::player *p) {
	m_timer->pause();
	m_update_event = 0;
	clear_transitions();
	if(!m_frames.empty()) {
		frame *pf = m_frames.top();
		m_frames.pop();
		m_windows = pf->windows;
		m_player = pf->player;
		delete pf;
		assert(0); // resume();
		std::map<std::string, wininfo*>::iterator it;
		for(it=m_windows.begin();it!=m_windows.end();it++) {
			dg_window *dgwin = (dg_window *)(*it).second->w;
			dgwin->need_redraw();
		}		
	}
}

void gui::dg::dg_player::close(common::player *p) {
	PostMessage(get_main_window(), WM_CLOSE, 0, 0);
}

void gui::dg::dg_player::open(net::url newdoc, bool startnewdoc, common::player *old) {
	if(old) {
		// Replace the current document
		PostMessage(get_main_window(), WM_REPLACE_DOC, 
			startnewdoc?1:0, LPARAM(new std::string(newdoc.get_url()))); 
		return;
	}
	
	// Parse the provided URL. 
	lib::document *doc = lib::document::create_from_url(this, newdoc);
	if(!doc) {
		m_logger->show("Failed to parse document %s", newdoc.get_url().c_str());
		return;
	}
	
	// Push the old frame on the stack
	if(m_player) {
		pause();
		frame *pf = new frame();
		pf->windows = m_windows;
		pf->player = m_player;
		m_windows.clear();
		m_player = 0;
		m_frames.push(pf);
	}
	
	// Create a player instance
	AM_DBG m_logger->debug("Creating player instance for: %s", newdoc.get_url().c_str());
	m_player = new smil2::smil_player(doc, this, this);
	if(startnewdoc) play();
}