ambulantinterface.h

彩信浏览器

	void set_window_factory(ambulant::common::window_factory* wf);
	void set_datasource_factory(ambulant::net::datasource_factory* df);
	void set_parser_factory(ambulant::lib::global_parser_factory* pf);
	void set_node_factory(ambulant::lib::node_factory* nf);
  private:
	PyObject *py_factories;

	friend PyObject *factoriesObj_New(ambulant::common::factories *itself);
};
#define BGEN_BACK_SUPPORT_factories
inline factories *Py_WrapAs_factories(PyObject *o)
{
	factories *rv = dynamic_cast<factories*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new factories(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class gui_screen : public cpppybridge, public ambulant::common::gui_screen {
public:
	gui_screen(PyObject *itself);
	virtual ~gui_screen();

	void get_size(int* width, int* height);
	bool get_screenshot(const char* type, char* *out_data__out__, size_t* out_data__len__);
	bool set_overlay(const char* type, const char *data__in__, size_t data__len__);
	bool clear_overlay();
  private:
	PyObject *py_gui_screen;

	friend PyObject *gui_screenObj_New(ambulant::common::gui_screen *itself);
};
#define BGEN_BACK_SUPPORT_gui_screen
inline gui_screen *Py_WrapAs_gui_screen(PyObject *o)
{
	gui_screen *rv = dynamic_cast<gui_screen*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new gui_screen(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class gui_player : public factories, public ambulant::common::gui_player {
public:
	gui_player(PyObject *itself);
	virtual ~gui_player();

	void init_playable_factory();
	void init_window_factory();
	void init_datasource_factory();
	void init_parser_factory();
	void init_plugins();
	void play();
	void stop();
	void pause();
	void restart(bool reparse);
	void goto_node(const ambulant::lib::node* n);
	bool is_play_enabled() const;
	bool is_stop_enabled() const;
	bool is_pause_enabled() const;
	bool is_play_active() const;
	bool is_stop_active() const;
	bool is_pause_active() const;
	void before_mousemove(int cursor);
	int after_mousemove();
	void on_char(int c);
	void on_focus_advance();
	void on_focus_activate();
	ambulant::lib::document* get_document() const;
	void set_document(ambulant::lib::document* doc);
	ambulant::common::embedder* get_embedder() const;
	void set_embedder(ambulant::common::embedder* em);
	ambulant::common::player* get_player() const;
	void set_player(ambulant::common::player* pl);
	ambulant::net::url get_url() const;
	ambulant::common::gui_screen* get_gui_screen();
  private:
	PyObject *py_gui_player;

	friend PyObject *gui_playerObj_New(ambulant::common::gui_player *itself);
};
#define BGEN_BACK_SUPPORT_gui_player
inline gui_player *Py_WrapAs_gui_player(PyObject *o)
{
	gui_player *rv = dynamic_cast<gui_player*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new gui_player(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class alignment : public cpppybridge, public ambulant::common::alignment {
public:
	alignment(PyObject *itself);
	virtual ~alignment();

	ambulant::lib::point get_image_fixpoint(ambulant::lib::size image_size) const;
	ambulant::lib::point get_surface_fixpoint(ambulant::lib::size surface_size) const;
  private:
	PyObject *py_alignment;

	friend PyObject *alignmentObj_New(ambulant::common::alignment *itself);
};
#define BGEN_BACK_SUPPORT_alignment
inline alignment *Py_WrapAs_alignment(PyObject *o)
{
	alignment *rv = dynamic_cast<alignment*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new alignment(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class animation_notification : public cpppybridge, public ambulant::common::animation_notification {
public:
	animation_notification(PyObject *itself);
	virtual ~animation_notification();

	void animated();
  private:
	PyObject *py_animation_notification;

	friend PyObject *animation_notificationObj_New(ambulant::common::animation_notification *itself);
};
#define BGEN_BACK_SUPPORT_animation_notification
inline animation_notification *Py_WrapAs_animation_notification(PyObject *o)
{
	animation_notification *rv = dynamic_cast<animation_notification*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new animation_notification(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class gui_window : public cpppybridge, public ambulant::common::gui_window {
public:
	gui_window(PyObject *itself);
	virtual ~gui_window();

	void need_redraw(const ambulant::lib::rect& r);
	void redraw_now();
	void need_events(bool want);
  private:
	PyObject *py_gui_window;

	friend PyObject *gui_windowObj_New(ambulant::common::gui_window *itself);
};
#define BGEN_BACK_SUPPORT_gui_window
inline gui_window *Py_WrapAs_gui_window(PyObject *o)
{
	gui_window *rv = dynamic_cast<gui_window*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new gui_window(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class gui_events : public cpppybridge, public ambulant::common::gui_events {
public:
	gui_events(PyObject *itself);
	virtual ~gui_events();

	void redraw(const ambulant::lib::rect& dirty, ambulant::common::gui_window* window);
	void user_event(const ambulant::lib::point& where, int what);
	void transition_freeze_end(ambulant::lib::rect area);
  private:
	PyObject *py_gui_events;

	friend PyObject *gui_eventsObj_New(ambulant::common::gui_events *itself);
};
#define BGEN_BACK_SUPPORT_gui_events
inline gui_events *Py_WrapAs_gui_events(PyObject *o)
{
	gui_events *rv = dynamic_cast<gui_events*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new gui_events(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class renderer : public gui_events, public ambulant::common::renderer {
public:
	renderer(PyObject *itself);
	virtual ~renderer();

	void set_surface(ambulant::common::surface* destination);
	void set_alignment(const ambulant::common::alignment* align);
	void set_intransition(const ambulant::lib::transition_info* info);
	void start_outtransition(const ambulant::lib::transition_info* info);
	ambulant::common::surface* get_surface();
	void redraw(const ambulant::lib::rect&, ambulant::common::gui_window*) { abort(); }
	void user_event(const ambulant::lib::point&, int) { abort(); }
	void transition_freeze_end(ambulant::lib::rect) { abort(); }
  private:
	PyObject *py_renderer;

	friend PyObject *rendererObj_New(ambulant::common::renderer *itself);
};
#define BGEN_BACK_SUPPORT_renderer
inline renderer *Py_WrapAs_renderer(PyObject *o)
{
	renderer *rv = dynamic_cast<renderer*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new renderer(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class bgrenderer : public gui_events, public ambulant::common::bgrenderer {
public:
	bgrenderer(PyObject *itself);
	virtual ~bgrenderer();

	void set_surface(ambulant::common::surface* destination);
	void keep_as_background();
	void highlight(ambulant::common::gui_window* window);
	void redraw(const ambulant::lib::rect&, ambulant::common::gui_window*) { abort(); }
	void user_event(const ambulant::lib::point&, int) { abort(); }
	void transition_freeze_end(ambulant::lib::rect) { abort(); }
  private:
	PyObject *py_bgrenderer;

	friend PyObject *bgrendererObj_New(ambulant::common::bgrenderer *itself);
};
#define BGEN_BACK_SUPPORT_bgrenderer
inline bgrenderer *Py_WrapAs_bgrenderer(PyObject *o)
{
	bgrenderer *rv = dynamic_cast<bgrenderer*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new bgrenderer(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class surface : public cpppybridge, public ambulant::common::surface {
public:
	surface(PyObject *itself);
	virtual ~surface();

	void show(ambulant::common::gui_events* renderer);
	void renderer_done(ambulant::common::gui_events* renderer);
	void need_redraw(const ambulant::lib::rect& r);
	void need_redraw();
	void need_events(bool want);
	void transition_done();
	void keep_as_background();
	const ambulant::lib::rect& get_rect() const;
	const ambulant::lib::rect& get_clipped_screen_rect() const;
	const ambulant::lib::point& get_global_topleft() const;
	ambulant::lib::rect get_fit_rect(const ambulant::lib::size& src_size, ambulant::lib::rect* out_src_rect, const ambulant::common::alignment* align) const;
	const ambulant::common::region_info* get_info() const;
	ambulant::common::surface* get_top_surface();
	bool is_tiled() const;
	ambulant::common::gui_window* get_gui_window();
	void set_renderer_private_data(ambulant::common::renderer_private_id idd, ambulant::common::renderer_private_data * data);
	ambulant::common::renderer_private_data * get_renderer_private_data(ambulant::common::renderer_private_id idd);
	void highlight(bool on);
	ambulant::common::tile_positions get_tiles(ambulant::lib::size s, ambulant::lib::rect r) const { return surface::get_tiles(s, r); }
  private:
	PyObject *py_surface;
	ambulant::lib::rect get_rect_rvkeepref;
	ambulant::lib::rect get_clipped_screen_rect_rvkeepref;
	ambulant::lib::point get_global_topleft_rvkeepref;

	friend PyObject *surfaceObj_New(ambulant::common::surface *itself);
};
#define BGEN_BACK_SUPPORT_surface
inline surface *Py_WrapAs_surface(PyObject *o)
{
	surface *rv = dynamic_cast<surface*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new surface(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class window_factory : public cpppybridge, public ambulant::common::window_factory {
public:
	window_factory(PyObject *itself);
	virtual ~window_factory();

	ambulant::lib::size get_default_size();
	ambulant::common::gui_window* new_window(const std::string& name, ambulant::lib::size bounds, ambulant::common::gui_events* handler);
	ambulant::common::bgrenderer* new_background_renderer(const ambulant::common::region_info* src);
	void window_done(const std::string& name);
  private:
	PyObject *py_window_factory;

	friend PyObject *window_factoryObj_New(ambulant::common::window_factory *itself);
};
#define BGEN_BACK_SUPPORT_window_factory
inline window_factory *Py_WrapAs_window_factory(PyObject *o)
{
	window_factory *rv = dynamic_cast<window_factory*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new window_factory(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class surface_template : public animation_notification, public ambulant::common::surface_template {
public:
	surface_template(PyObject *itself);
	virtual ~surface_template();

	ambulant::common::surface_template* new_subsurface(const ambulant::common::region_info* info, ambulant::common::bgrenderer* bgrend);
	ambulant::common::surface* activate();
	void animated() { abort(); }
  private:
	PyObject *py_surface_template;

	friend PyObject *surface_templateObj_New(ambulant::common::surface_template *itself);
};
#define BGEN_BACK_SUPPORT_surface_template
inline surface_template *Py_WrapAs_surface_template(PyObject *o)
{
	surface_template *rv = dynamic_cast<surface_template*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new surface_template(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class surface_factory : public cpppybridge, public ambulant::common::surface_factory {
public:
	surface_factory(PyObject *itself);
	virtual ~surface_factory();

	ambulant::common::surface_template* new_topsurface(const ambulant::common::region_info* info, ambulant::common::bgrenderer* bgrend, ambulant::common::window_factory* wf);
  private:
	PyObject *py_surface_factory;

	friend PyObject *surface_factoryObj_New(ambulant::common::surface_factory *itself);
};
#define BGEN_BACK_SUPPORT_surface_factory
inline surface_factory *Py_WrapAs_surface_factory(PyObject *o)
{
	surface_factory *rv = dynamic_cast<surface_factory*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new surface_factory(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class layout_manager : public cpppybridge, public ambulant::common::layout_manager {
public:
	layout_manager(PyObject *itself);
	virtual ~layout_manager();

	ambulant::common::surface* get_surface(const ambulant::lib::node* node);
	ambulant::common::alignment* get_alignment(const ambulant::lib::node* node);
	ambulant::common::animation_notification* get_animation_notification(const ambulant::lib::node* node);
	ambulant::common::animation_destination* get_animation_destination(const ambulant::lib::node* node);
  private:
	PyObject *py_layout_manager;

	friend PyObject *layout_managerObj_New(ambulant::common::layout_manager *itself);
};
#define BGEN_BACK_SUPPORT_layout_manager
inline layout_manager *Py_WrapAs_layout_manager(PyObject *o)
{
	layout_manager *rv = dynamic_cast<layout_manager*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new layout_manager(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class playable : public cpppybridge, public ambulant::common::playable {
public:
	playable(PyObject *itself);
	virtual ~playable();

	void start(double t);
	void stop();
	void pause(ambulant::common::pause_display d);
	void resume();
	void seek(double t);
	void wantclicks(bool want);
	void preroll(double when, double where, double how_much);
	ambulant::common::duration get_dur();
	ambulant::common::playable::cookie_type get_cookie() const;
	ambulant::common::renderer* get_renderer();
  private:
	PyObject *py_playable;

	friend PyObject *playableObj_New(ambulant::common::playable *itself);
};
#define BGEN_BACK_SUPPORT_playable
inline playable *Py_WrapAs_playable(PyObject *o)
{
	playable *rv = dynamic_cast<playable*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new playable(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class playable_notification : public cpppybridge, public ambulant::common::playable_notification {
public:
	playable_notification(PyObject *itself);
	virtual ~playable_notification();

	void started(ambulant::common::playable::cookie_type n, double t);
	void stopped(ambulant::common::playable::cookie_type n, double t);
	void stalled(ambulant::common::playable::cookie_type n, double t);