ambulantinterface.h

彩信浏览器

	void unstalled(ambulant::common::playable::cookie_type n, double t);
	void clicked(ambulant::common::playable::cookie_type n, double t);
	void pointed(ambulant::common::playable::cookie_type n, double t);
	void transitioned(ambulant::common::playable::cookie_type n, double t);
  private:
	PyObject *py_playable_notification;

	friend PyObject *playable_notificationObj_New(ambulant::common::playable_notification *itself);
};
#define BGEN_BACK_SUPPORT_playable_notification
inline playable_notification *Py_WrapAs_playable_notification(PyObject *o)
{
	playable_notification *rv = dynamic_cast<playable_notification*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new playable_notification(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

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

	ambulant::common::playable* new_playable(ambulant::common::playable_notification* context, ambulant::common::playable::cookie_type cookie, const ambulant::lib::node* node, ambulant::lib::event_processor* evp);
	ambulant::common::playable* new_aux_audio_playable(ambulant::common::playable_notification* context, ambulant::common::playable::cookie_type cookie, const ambulant::lib::node* node, ambulant::lib::event_processor* evp, ambulant::net::audio_datasource* src);
  private:
	PyObject *py_playable_factory;

	friend PyObject *playable_factoryObj_New(ambulant::common::playable_factory *itself);
};
#define BGEN_BACK_SUPPORT_playable_factory
inline playable_factory *Py_WrapAs_playable_factory(PyObject *o)
{
	playable_factory *rv = dynamic_cast<playable_factory*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new playable_factory(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class global_playable_factory : public playable_factory, public ambulant::common::global_playable_factory {
public:
	global_playable_factory(PyObject *itself);
	virtual ~global_playable_factory();

	void add_factory(ambulant::common::playable_factory* rf);
	ambulant::common::playable* new_playable(ambulant::common::playable_notification*, int, const ambulant::lib::node*, ambulant::lib::event_processor*) { abort(); }
	ambulant::common::playable* new_aux_audio_playable(ambulant::common::playable_notification *context, int, const ambulant::lib::node *node, ambulant::lib::event_processor *evp, ambulant::net::audio_datasource *src) { abort(); }
  private:
	PyObject *py_global_playable_factory;

	friend PyObject *global_playable_factoryObj_New(ambulant::common::global_playable_factory *itself);
};
#define BGEN_BACK_SUPPORT_global_playable_factory
inline global_playable_factory *Py_WrapAs_global_playable_factory(PyObject *o)
{
	global_playable_factory *rv = dynamic_cast<global_playable_factory*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new global_playable_factory(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

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

	void document_loaded(ambulant::lib::document* doc);
	void document_started();
	void document_stopped();
	void node_started(const ambulant::lib::node* n);
	void node_stopped(const ambulant::lib::node* n);
	void node_focussed(const ambulant::lib::node* n);
  private:
	PyObject *py_player_feedback;

	friend PyObject *player_feedbackObj_New(ambulant::common::player_feedback *itself);
};
#define BGEN_BACK_SUPPORT_player_feedback
inline player_feedback *Py_WrapAs_player_feedback(PyObject *o)
{
	player_feedback *rv = dynamic_cast<player_feedback*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new player_feedback(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

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

	void initialize();
	ambulant::lib::timer* get_timer();
	ambulant::lib::event_processor* get_evp();
	void start();
	void stop();
	void pause();
	void resume();
	bool is_playing() const;
	bool is_pausing() const;
	bool is_done() const;
	int after_mousemove();
	void before_mousemove(int cursor);
	void on_char(int ch);
	void on_focus_advance();
	void on_focus_activate();
	void set_feedback(ambulant::common::player_feedback* fb);
	bool goto_node(const ambulant::lib::node* n);
	bool highlight(const ambulant::lib::node* n);
  private:
	PyObject *py_player;

	friend PyObject *playerObj_New(ambulant::common::player *itself);
};
#define BGEN_BACK_SUPPORT_player
inline player *Py_WrapAs_player(PyObject *o)
{
	player *rv = dynamic_cast<player*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new player(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

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

	std::string get_name() const;
	ambulant::lib::rect get_rect() const;
	ambulant::common::fit_t get_fit() const;
	ambulant::lib::color_t get_bgcolor() const;
	bool get_transparent() const;
	ambulant::common::zindex_t get_zindex() const;
	bool get_showbackground() const;
	bool is_subregion() const;
	double get_soundlevel() const;
	ambulant::common::sound_alignment get_soundalign() const;
	ambulant::common::tiling get_tiling() const;
	const char * get_bgimage() const;
  private:
	PyObject *py_region_info;

	friend PyObject *region_infoObj_New(ambulant::common::region_info *itself);
};
#define BGEN_BACK_SUPPORT_region_info
inline region_info *Py_WrapAs_region_info(PyObject *o)
{
	region_info *rv = dynamic_cast<region_info*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new region_info(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class animation_destination : public region_info, public ambulant::common::animation_destination {
public:
	animation_destination(PyObject *itself);
	virtual ~animation_destination();

	ambulant::common::region_dim get_region_dim(const std::string& which, bool fromdom) const;
	ambulant::lib::color_t get_region_color(const std::string& which, bool fromdom) const;
	ambulant::common::zindex_t get_region_zindex(bool fromdom) const;
	double get_region_soundlevel(bool fromdom) const;
	ambulant::common::sound_alignment get_region_soundalign(bool fromdom) const;
	void set_region_dim(const std::string& which, const ambulant::common::region_dim& rd);
	void set_region_color(const std::string& which, ambulant::lib::color_t clr);
	void set_region_zindex(ambulant::common::zindex_t z);
	void set_region_soundlevel(double level);
	void set_region_soundalign(ambulant::common::sound_alignment sa);
	std::string get_name() const { return region_info::get_name(); }
	ambulant::lib::rect get_rect() const { return region_info::get_rect(); }
	ambulant::common::fit_t get_fit() const { return region_info::get_fit(); }
	ambulant::lib::color_t get_bgcolor() const { return region_info::get_bgcolor(); }
	bool get_transparent() const { return region_info::get_transparent(); }
	ambulant::common::zindex_t get_zindex() const { return region_info::get_zindex(); }
	bool get_showbackground() const { return region_info::get_showbackground(); }
	bool is_subregion() const { return region_info::is_subregion(); }
	double get_soundlevel() const { return region_info::get_soundlevel(); }
	ambulant::common::sound_alignment get_soundalign() const { return region_info::get_soundalign(); }
	ambulant::common::tiling get_tiling() const { return region_info::get_tiling(); }
	const char* get_bgimage() const { return region_info::get_bgimage(); }
  private:
	PyObject *py_animation_destination;

	friend PyObject *animation_destinationObj_New(ambulant::common::animation_destination *itself);
};
#define BGEN_BACK_SUPPORT_animation_destination
inline animation_destination *Py_WrapAs_animation_destination(PyObject *o)
{
	animation_destination *rv = dynamic_cast<animation_destination*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new animation_destination(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class datasource : public cpppybridge, public ambulant::net::datasource {
public:
	datasource(PyObject *itself);
	virtual ~datasource();

	void start(ambulant::lib::event_processor* evp, ambulant::lib::event* callback);
	void stop();
	bool end_of_file();
	int size() const;
	void readdone(int len);
	long add_ref() { return 1; }
	long release() { return 1;}
	long get_ref_count() const { return 1; }
	char *get_read_ptr() { abort(); return NULL;}
  private:
	PyObject *py_datasource;

	friend PyObject *datasourceObj_New(ambulant::net::datasource *itself);
};
#define BGEN_BACK_SUPPORT_datasource
inline datasource *Py_WrapAs_datasource(PyObject *o)
{
	datasource *rv = dynamic_cast<datasource*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new datasource(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class pkt_datasource : public cpppybridge, public ambulant::net::pkt_datasource {
public:
	pkt_datasource(PyObject *itself);
	virtual ~pkt_datasource();

	void start(ambulant::lib::event_processor* evp, ambulant::lib::event* callback);
	void stop();
	bool end_of_file();
	long add_ref() { return 1; }
	long release() { return 1;}
	long get_ref_count() const { return 1; }
	char *get_read_ptr() { abort(); return NULL;}
	ambulant::net::ts_packet_t get_ts_packet_t() { abort(); }
  private:
	PyObject *py_pkt_datasource;

	friend PyObject *pkt_datasourceObj_New(ambulant::net::pkt_datasource *itself);
};
#define BGEN_BACK_SUPPORT_pkt_datasource
inline pkt_datasource *Py_WrapAs_pkt_datasource(PyObject *o)
{
	pkt_datasource *rv = dynamic_cast<pkt_datasource*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new pkt_datasource(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class raw_datasource_factory : public cpppybridge, public ambulant::net::raw_datasource_factory {
public:
	raw_datasource_factory(PyObject *itself);
	virtual ~raw_datasource_factory();

	ambulant::net::datasource* new_raw_datasource(const ambulant::net::url& url);
  private:
	PyObject *py_raw_datasource_factory;

	friend PyObject *raw_datasource_factoryObj_New(ambulant::net::raw_datasource_factory *itself);
};
#define BGEN_BACK_SUPPORT_raw_datasource_factory
inline raw_datasource_factory *Py_WrapAs_raw_datasource_factory(PyObject *o)
{
	raw_datasource_factory *rv = dynamic_cast<raw_datasource_factory*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new raw_datasource_factory(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class audio_datasource_factory : public cpppybridge, public ambulant::net::audio_datasource_factory {
public:
	audio_datasource_factory(PyObject *itself);
	virtual ~audio_datasource_factory();

	ambulant::net::audio_datasource* new_audio_datasource(const ambulant::net::url& url, const ambulant::net::audio_format_choices& fmt, ambulant::net::timestamp_t clip_begin, ambulant::net::timestamp_t clip_end);
  private:
	PyObject *py_audio_datasource_factory;

	friend PyObject *audio_datasource_factoryObj_New(ambulant::net::audio_datasource_factory *itself);
};
#define BGEN_BACK_SUPPORT_audio_datasource_factory
inline audio_datasource_factory *Py_WrapAs_audio_datasource_factory(PyObject *o)
{
	audio_datasource_factory *rv = dynamic_cast<audio_datasource_factory*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new audio_datasource_factory(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class pkt_audio_datasource_factory : public cpppybridge, public ambulant::net::pkt_audio_datasource_factory {
public:
	pkt_audio_datasource_factory(PyObject *itself);
	virtual ~pkt_audio_datasource_factory();

	ambulant::net::pkt_audio_datasource* new_pkt_audio_datasource(const ambulant::net::url& url, const ambulant::net::audio_format_choices& fmt, ambulant::net::timestamp_t clip_begin, ambulant::net::timestamp_t clip_end);
  private:
	PyObject *py_pkt_audio_datasource_factory;

	friend PyObject *pkt_audio_datasource_factoryObj_New(ambulant::net::pkt_audio_datasource_factory *itself);
};
#define BGEN_BACK_SUPPORT_pkt_audio_datasource_factory
inline pkt_audio_datasource_factory *Py_WrapAs_pkt_audio_datasource_factory(PyObject *o)
{
	pkt_audio_datasource_factory *rv = dynamic_cast<pkt_audio_datasource_factory*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new pkt_audio_datasource_factory(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class video_datasource_factory : public cpppybridge, public ambulant::net::video_datasource_factory {
public:
	video_datasource_factory(PyObject *itself);
	virtual ~video_datasource_factory();

	ambulant::net::video_datasource* new_video_datasource(const ambulant::net::url& url, ambulant::net::timestamp_t clip_begin, ambulant::net::timestamp_t clip_end);
  private:
	PyObject *py_video_datasource_factory;

	friend PyObject *video_datasource_factoryObj_New(ambulant::net::video_datasource_factory *itself);
};
#define BGEN_BACK_SUPPORT_video_datasource_factory
inline video_datasource_factory *Py_WrapAs_video_datasource_factory(PyObject *o)
{
	video_datasource_factory *rv = dynamic_cast<video_datasource_factory*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new video_datasource_factory(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class audio_parser_finder : public cpppybridge, public ambulant::net::audio_parser_finder {
public:
	audio_parser_finder(PyObject *itself);
	virtual ~audio_parser_finder();

	ambulant::net::audio_datasource* new_audio_parser(const ambulant::net::url& url, const ambulant::net::audio_format_choices& hint, ambulant::net::audio_datasource* src);
  private:
	PyObject *py_audio_parser_finder;

	friend PyObject *audio_parser_finderObj_New(ambulant::net::audio_parser_finder *itself);
};
#define BGEN_BACK_SUPPORT_audio_parser_finder
inline audio_parser_finder *Py_WrapAs_audio_parser_finder(PyObject *o)
{
	audio_parser_finder *rv = dynamic_cast<audio_parser_finder*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new audio_parser_finder(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class audio_filter_finder : public cpppybridge, public ambulant::net::audio_filter_finder {
public:
	audio_filter_finder(PyObject *itself);
	virtual ~audio_filter_finder();

	ambulant::net::audio_datasource* new_audio_filter(ambulant::net::audio_datasource* src, const ambulant::net::audio_format_choices& fmts);
  private:
	PyObject *py_audio_filter_finder;

	friend PyObject *audio_filter_finderObj_New(ambulant::net::audio_filter_finder *itself);
};
#define BGEN_BACK_SUPPORT_audio_filter_finder
inline audio_filter_finder *Py_WrapAs_audio_filter_finder(PyObject *o)
{
	audio_filter_finder *rv = dynamic_cast<audio_filter_finder*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new audio_filter_finder(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class audio_decoder_finder : public cpppybridge, public ambulant::net::audio_decoder_finder {
public:
	audio_decoder_finder(PyObject *itself);
	virtual ~audio_decoder_finder();

	ambulant::net::audio_datasource* new_audio_decoder(ambulant::net::pkt_audio_datasource* src, const ambulant::net::audio_format_choices& fmts);
  private:
	PyObject *py_audio_decoder_finder;

	friend PyObject *audio_decoder_finderObj_New(ambulant::net::audio_decoder_finder *itself);
};
#define BGEN_BACK_SUPPORT_audio_decoder_finder
inline audio_decoder_finder *Py_WrapAs_audio_decoder_finder(PyObject *o)
{
	audio_decoder_finder *rv = dynamic_cast<audio_decoder_finder*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new audio_decoder_finder(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}