ambulantinterface.h

彩信浏览器

/* ==== Declaration of C++ to Python callback module pyambulant ===== */

#include "Python.h"


#define WITH_EXTERNAL_DOM 1
#include "ambulant/lib/node.h"
#include "ambulant/lib/document.h"
#include "ambulant/lib/event.h"
#include "ambulant/lib/event_processor.h"
#include "ambulant/lib/parser_factory.h"
#include "ambulant/lib/sax_handler.h"
#include "ambulant/lib/system.h"
#include "ambulant/lib/timer.h"
#include "ambulant/lib/transition_info.h"
#include "ambulant/common/embedder.h"
#include "ambulant/common/factory.h"
#include "ambulant/common/gui_player.h"
#include "ambulant/common/layout.h"
#include "ambulant/common/playable.h"
#include "ambulant/common/player.h"
#include "ambulant/common/region_dim.h"
#include "ambulant/common/region_info.h"
#include "ambulant/gui/none/none_gui.h"
#include "ambulant/net/datasource.h"
#include "ambulant/net/stdio_datasource.h"
#include "ambulant/net/posix_datasource.h"
#include "ambulant/gui/qt/qt_factory.h"
#include "ambulant/gui/SDL/sdl_factory.h"
#include "ambulant/net/ffmpeg_factory.h"

#include "ambulant/lib/node_navigator.h"


/* ============ Glue classes to maintain object identity ============ */

class cpppybridge {
  public:
    virtual ~cpppybridge() {};
};

#if 1
extern PyTypeObject pycppbridge_Type;

extern cpppybridge *pycppbridge_getwrapper(PyObject *o);
extern void pycppbridge_setwrapper(PyObject *o, cpppybridge *w);

inline bool pycppbridge_Check(PyObject *x)
{
	return PyObject_TypeCheck(x, &pycppbridge_Type);
}

#else
inline bool pycppbridge_Check(PyObject *x) { return false; };
inline cpppybridge *pycppbridge_getwrapper(PyObject *o) { return NULL; };
inline void pycppbridge_setwrapper(PyObject *o, cpppybridge *w) {};
#endif

class node_context : public cpppybridge, public ambulant::lib::node_context {
public:
	node_context(PyObject *itself);
	virtual ~node_context();

	void set_prefix_mapping(const std::string& prefix, const std::string& uri);
	const char * get_namespace_prefix(const ambulant::lib::xml_string& uri) const;
	ambulant::net::url resolve_url(const ambulant::net::url& rurl) const;
	const ambulant::lib::node* get_root() const;
	const ambulant::lib::node* get_node(const std::string& idd) const;
	const custom_test_map* get_custom_tests() const { return NULL; }
  private:
	PyObject *py_node_context;

	friend PyObject *node_contextObj_New(ambulant::lib::node_context *itself);
};
#define BGEN_BACK_SUPPORT_node_context
inline node_context *Py_WrapAs_node_context(PyObject *o)
{
	node_context *rv = dynamic_cast<node_context*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new node_context(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class node : public cpppybridge, public ambulant::lib::node {
public:
	node(PyObject *itself);
	virtual ~node();

	const ambulant::lib::node* down() const;
	const ambulant::lib::node* up() const;
	const ambulant::lib::node* next() const;
	ambulant::lib::node* down();
	ambulant::lib::node* up();
	ambulant::lib::node* next();
	void down(ambulant::lib::node* n);
	void up(ambulant::lib::node* n);
	void next(ambulant::lib::node* n);
	const ambulant::lib::node* previous() const;
	const ambulant::lib::node* get_last_child() const;
	ambulant::lib::node* locate_node(const char* path);
	ambulant::lib::node* get_first_child(const char* name);
	const ambulant::lib::node* get_first_child(const char* name) const;
	ambulant::lib::node* get_root();
	const char * get_container_attribute(const char* name) const;
	ambulant::lib::node* append_child(ambulant::lib::node* child);
	ambulant::lib::node* append_child(const char* name);
	ambulant::lib::node* detach();
	ambulant::lib::node* clone() const;
	void append_data(const char *data__in__, size_t data__len__);
	void append_data(const char* c_str);
	void append_data(const ambulant::lib::xml_string& str);
	void set_attribute(const char* name, const char* value);
	void set_attribute(const char* name, const ambulant::lib::xml_string& value);
	void set_namespace(const ambulant::lib::xml_string& ns);
	const ambulant::lib::xml_string& get_namespace() const;
	const ambulant::lib::xml_string& get_local_name() const;
	const ambulant::lib::q_name_pair& get_qname() const;
	int get_numid() const;
	const ambulant::lib::xml_string& get_data() const;
	ambulant::lib::xml_string get_trimmed_data() const;
	const char * get_attribute(const char* name) const;
	const char * get_attribute(const std::string& name) const;
	void del_attribute(const char* name);
	ambulant::net::url get_url(const char* attrname) const;
	unsigned int size() const;
	std::string get_path_display_desc() const;
	std::string get_sig() const;
	ambulant::lib::xml_string xmlrepr() const;
	const ambulant::lib::node_context* get_context() const;
	void set_context(ambulant::lib::node_context* c);
	void get_children(const_node_list& l) const {ambulant::lib::node_navigator<const ambulant::lib::node>::get_children(this, l);}
	void set_attributes(const char **attrs) { abort(); }
  private:
	PyObject *py_node;
	ambulant::lib::xml_string get_namespace_rvkeepref;
	ambulant::lib::xml_string get_local_name_rvkeepref;
	ambulant::lib::q_name_pair get_qname_rvkeepref;
	ambulant::lib::xml_string get_data_rvkeepref;

	friend PyObject *nodeObj_New(ambulant::lib::node *itself);
};
#define BGEN_BACK_SUPPORT_node
inline node *Py_WrapAs_node(PyObject *o)
{
	node *rv = dynamic_cast<node*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new node(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class node_factory : public cpppybridge, public ambulant::lib::node_factory {
public:
	node_factory(PyObject *itself);
	virtual ~node_factory();

	ambulant::lib::node* new_node(const ambulant::lib::q_name_pair& qn, const ambulant::lib::q_attributes_list& qattrs, const ambulant::lib::node_context* ctx);
	ambulant::lib::node* new_node(const ambulant::lib::node* other);
	ambulant::lib::node *new_node(const char *local_name, const char **attrs = 0, const ambulant::lib::node_context *ctx = 0) { abort(); };
	ambulant::lib::node *new_node(const ambulant::lib::xml_string& local_name, const char **attrs = 0, const ambulant::lib::node_context *ctx = 0) { abort(); };
  private:
	PyObject *py_node_factory;

	friend PyObject *node_factoryObj_New(ambulant::lib::node_factory *itself);
};
#define BGEN_BACK_SUPPORT_node_factory
inline node_factory *Py_WrapAs_node_factory(PyObject *o)
{
	node_factory *rv = dynamic_cast<node_factory*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new node_factory(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class event : public cpppybridge, public ambulant::lib::event {
public:
	event(PyObject *itself);
	virtual ~event();

	void fire();
  private:
	PyObject *py_event;

	friend PyObject *eventObj_New(ambulant::lib::event *itself);
};
#define BGEN_BACK_SUPPORT_event
inline event *Py_WrapAs_event(PyObject *o)
{
	event *rv = dynamic_cast<event*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new event(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class event_processor : public cpppybridge, public ambulant::lib::event_processor {
public:
	event_processor(PyObject *itself);
	virtual ~event_processor();

	void add_event(ambulant::lib::event* pe, ambulant::lib::timer::time_type t, ambulant::lib::event_priority priority);
	void cancel_all_events();
	bool cancel_event(ambulant::lib::event* pe, ambulant::lib::event_priority priority);
	void serve_events();
	ambulant::lib::timer* get_timer() const;
	void stop_processor_thread();
  private:
	PyObject *py_event_processor;

	friend PyObject *event_processorObj_New(ambulant::lib::event_processor *itself);
};
#define BGEN_BACK_SUPPORT_event_processor
inline event_processor *Py_WrapAs_event_processor(PyObject *o)
{
	event_processor *rv = dynamic_cast<event_processor*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new event_processor(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class parser_factory : public cpppybridge, public ambulant::lib::parser_factory {
public:
	parser_factory(PyObject *itself);
	virtual ~parser_factory();

	std::string get_parser_name();
	ambulant::lib::xml_parser* new_parser(ambulant::lib::sax_content_handler*, ambulant::lib::sax_error_handler*) { abort(); }
  private:
	PyObject *py_parser_factory;

	friend PyObject *parser_factoryObj_New(ambulant::lib::parser_factory *itself);
};
#define BGEN_BACK_SUPPORT_parser_factory
inline parser_factory *Py_WrapAs_parser_factory(PyObject *o)
{
	parser_factory *rv = dynamic_cast<parser_factory*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new parser_factory(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class xml_parser : public cpppybridge, public ambulant::lib::xml_parser {
public:
	xml_parser(PyObject *itself);
	virtual ~xml_parser();

	bool parse(const char *buf__in__, size_t buf__len__, bool final);
	void set_content_handler(ambulant::lib::sax_content_handler*) { abort(); }
	void set_error_handler(ambulant::lib::sax_error_handler*) { abort(); }
  private:
	PyObject *py_xml_parser;

	friend PyObject *xml_parserObj_New(ambulant::lib::xml_parser *itself);
};
#define BGEN_BACK_SUPPORT_xml_parser
inline xml_parser *Py_WrapAs_xml_parser(PyObject *o)
{
	xml_parser *rv = dynamic_cast<xml_parser*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new xml_parser(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class system_embedder : public cpppybridge, public ambulant::lib::system_embedder {
public:
	system_embedder(PyObject *itself);
	virtual ~system_embedder();

	void show_file(const ambulant::net::url& href);
  private:
	PyObject *py_system_embedder;

	friend PyObject *system_embedderObj_New(ambulant::lib::system_embedder *itself);
};
#define BGEN_BACK_SUPPORT_system_embedder
inline system_embedder *Py_WrapAs_system_embedder(PyObject *o)
{
	system_embedder *rv = dynamic_cast<system_embedder*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new system_embedder(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class timer_events : public cpppybridge, public ambulant::lib::timer_events {
public:
	timer_events(PyObject *itself);
	virtual ~timer_events();

	void speed_changed();
  private:
	PyObject *py_timer_events;

	friend PyObject *timer_eventsObj_New(ambulant::lib::timer_events *itself);
};
#define BGEN_BACK_SUPPORT_timer_events
inline timer_events *Py_WrapAs_timer_events(PyObject *o)
{
	timer_events *rv = dynamic_cast<timer_events*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new timer_events(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class timer : public cpppybridge, public ambulant::lib::timer {
public:
	timer(PyObject *itself);
	virtual ~timer();

	ambulant::lib::timer::time_type elapsed() const;
	double get_realtime_speed() const;
  private:
	PyObject *py_timer;

	friend PyObject *timerObj_New(ambulant::lib::timer *itself);
};
#define BGEN_BACK_SUPPORT_timer
inline timer *Py_WrapAs_timer(PyObject *o)
{
	timer *rv = dynamic_cast<timer*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new timer(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class timer_control : public timer, public ambulant::lib::timer_control {
public:
	timer_control(PyObject *itself);
	virtual ~timer_control();

	ambulant::lib::timer::time_type elapsed() const;
	ambulant::lib::timer::time_type elapsed(ambulant::lib::timer::time_type pt) const;
	void start(ambulant::lib::timer::time_type t);
	void stop();
	void pause();
	void resume();
	void set_speed(double speed);
	void set_time(ambulant::lib::timer::time_type t);
	double get_speed() const;
	bool running() const;
	double get_realtime_speed() const;
  private:
	PyObject *py_timer_control;

	friend PyObject *timer_controlObj_New(ambulant::lib::timer_control *itself);
};
#define BGEN_BACK_SUPPORT_timer_control
inline timer_control *Py_WrapAs_timer_control(PyObject *o)
{
	timer_control *rv = dynamic_cast<timer_control*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new timer_control(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

class embedder : public system_embedder, public ambulant::common::embedder {
public:
	embedder(PyObject *itself);
	virtual ~embedder();

	void close(ambulant::common::player* p);
	void open(ambulant::net::url newdoc, bool start, ambulant::common::player* old);
	void done(ambulant::common::player* p);
	void starting(ambulant::common::player* p);
	bool aux_open(const ambulant::net::url& href);
	void show_file(const ambulant::net::url& url) { system_embedder::show_file(url); }
  private:
	PyObject *py_embedder;

	friend PyObject *embedderObj_New(ambulant::common::embedder *itself);
};
#define BGEN_BACK_SUPPORT_embedder
inline embedder *Py_WrapAs_embedder(PyObject *o)
{
	embedder *rv = dynamic_cast<embedder*>(pycppbridge_getwrapper(o));
	if (rv) return rv;
	rv = new embedder(o);
	pycppbridge_setwrapper(o, rv);
	return rv;
}

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

	void init_factories();
	void init_playable_factory();
	void init_window_factory();
	void init_datasource_factory();
	void init_parser_factory();
	void init_node_factory();
	ambulant::common::global_playable_factory* get_playable_factory() const;
	ambulant::common::window_factory* get_window_factory() const;
	ambulant::net::datasource_factory* get_datasource_factory() const;
	ambulant::lib::global_parser_factory* get_parser_factory() const;
	ambulant::lib::node_factory* get_node_factory() const;
	void set_playable_factory(ambulant::common::global_playable_factory* pf);