--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/include/mb_backend.h	Wed Dec 01 12:25:56 2010 +0800
@@ -0,0 +1,196 @@
+#ifndef __MB_BACKEND_H_
+#define __MB_BACKEND_H_
+
+#include "mb_redraw_man.h"
+#include "mb_timer.h"
+#include "mb_observer.h"
+#include "mb_img_ldr.h"
+
+#include "mb_config.h"
+
+#ifdef X_BACKEND
+#include "mb_X_supp.h"
+#endif
+
+#ifdef DFB_BACKEND
+#inclde "mb_dfb_supp.h"
+#endif
+
+struct _mb_rt;
+typedef struct _mb_rt mb_rt_t;
+
+struct _mb_timer_man;
+struct _mb_timer_factory;
+struct _mb_IO_man;
+struct _mb_IO_factory;
+
+/*! \brief Type of IO that registered with an IO manager.
+ */
+enum _MB_IO_TYPE {MB_IO_DUMMY, MB_IO_R, MB_IO_W, MB_IO_RW};
+
+typedef struct _mb_timer_man mb_timer_man_t;
+typedef struct _mb_timer_factory mb_timer_factory_t;
+typedef struct _mb_IO_man mb_IO_man_t;
+typedef struct _mb_IO_factory mb_IO_factory_t;
+typedef enum _MB_IO_TYPE MB_IO_TYPE;
+
+/*! \brief Function signature of callback functions for IO requests.
+ */
+typedef void (*mb_IO_cb_t)(int hdl, int fd, MB_IO_TYPE type, void *data);
+
+/*! \brief The backend engine mb_backend_t is used to define the
+ *         interface to realize the MB.
+ *
+ * A backend is used to receive events from the system. The MB does
+ * not define the backend by itself.  Instead, it define an interface
+ * which allow the lower layer to implement the event system. Each
+ * backend need to provides the following events.
+ *
+ * - keyboard event
+ * - timer event
+ * - image loader(?)
+ * - render manager(?)
+ */
+typedef struct {
+    mb_rt_t *(*rt_new)(const char *display, int w,int h);
+    mb_rt_t *(*rt_new_with_win)(MB_DISPLAY display, MB_WINDOW win);
+    
+    void (*rt_free)(mb_rt_t *rt);
+    void (*rt_free_keep_win)(mb_rt_t *rt);
+    /*! \brief Request the backend to start monitoring a file descriptor.
+     *
+     * This is used only when the backend is responsible for event loop.
+     */
+    int (*add_event)(mb_rt_t *rt, int fd, MB_IO_TYPE type,
+		     mb_IO_cb_t f,void *arg);
+    /*! \brief Request the backend to stop monitoring a file descriptor.
+     *
+     * This is used only when the backend is responsible for event loop.
+     */
+    void (*remove_event)(mb_rt_t *rt, int hdl);
+    /*! \brief Event Loop
+     *
+     * This is called when main application does not handle event
+     * loop.  Or, it should register an IO factory (i.e \ref
+     * mb_IO_factory_t) with the backend.
+     */
+    void (*event_loop)(mb_rt_t *rt);
+
+    /*! \brief Flush requests to screen server if existed */
+    int (*flush)(mb_rt_t *rt);
+    
+    subject_t *(*kbevents)(mb_rt_t *rt);
+    redraw_man_t *(*rdman)(mb_rt_t *rt);
+    mb_timer_man_t *(*timer_man)(mb_rt_t *rt);
+    observer_factory_t *(*observer_factory)(mb_rt_t *rt);
+    mb_img_ldr_t *(*loader)(mb_rt_t *rt);
+    
+    /*
+     * Following two methods are used to integrate a backend to
+     * event loop of main application.
+     */
+    void (*reg_IO_factory)(mb_IO_factory_t *io_man);
+    void (*reg_timer_factory)(mb_timer_factory_t *tm_man);
+} mb_backend_t;
+
+#define mb_runtime_new(disp, w, h)	\
+    mb_dfl_backend.rt_new((disp), (w), (h))
+#define mb_runtime_new_with_win(disp, win)	\
+    mb_dfl_backend.rt_new_with_win((disp), (win))
+#define mb_reg_IO_factory(io_fact)	\
+    mb_dfl_backend.reg_IO_factory(io_fact)
+#define mb_reg_timer_factory(tm_fact)	\
+    mb_dfl_backend.reg_timer_factory(tm_fact)
+
+/*
+ * This is defined by backend implementations.  For example, X_supp.c
+ * or dfb_supp.c should defined a backend.
+ */
+extern mb_backend_t mb_dfl_backend;
+
+#define mb_runtime_free(rt)			\
+    mb_dfl_backend.rt_free(rt)
+#define mb_runtime_free_keep_win(rt)		\
+    mb_dfl_backend.rt_free_keep_win(rt)
+#define mb_runtime_add_event(rt, fd, type, cb, arg)		\
+    mb_dfl_backend.add_event((rt), (fd), (type), (cb), (arg))
+#define mb_runtime_remove_event(hdl)		\
+    mb_dfl_backend.remove_event((rt), (hdl))
+#define mb_runtime_event_loop(rt)		\
+    mb_dfl_backend.event_loop(rt)
+#define mb_runtime_flush(rt)			\
+    mb_dfl_backend.flush(rt)
+#define mb_runtime_kbevents(rt)			\
+    mb_dfl_backend.kbevents(rt)
+#define mb_runtime_rdman(rt)			\
+    mb_dfl_backend.rdman(rt)
+#define mb_runtime_timer_man(rt)		\
+    mb_dfl_backend.timer_man(rt)
+#define mb_runtime_observer_factory(rt)		\
+    mb_dfl_backend.observer_factory(rt)
+#define mb_runtime_loader(rt)			\
+    mb_dfl_backend.loader(rt)
+
+
+/*! \brief IO Manager
+ */
+struct _mb_IO_man {
+    int (*reg)(struct _mb_IO_man *io_man,
+	       int fd, MB_IO_TYPE type, mb_IO_cb_t cb, void *data);
+    void (*unreg)(struct _mb_IO_man *io_man,
+		  int io_hdl);
+};
+
+/*! \brief Factory of IO managers.
+ */
+struct _mb_IO_factory {
+    mb_IO_man_t *(*io_man_new)(void);
+    void (*io_man_free)(mb_IO_man_t *io_man);
+};
+
+#define mb_io_man_reg(io_man, fd, type, cb, data)	\
+    (io_man)->reg(io_man, fd, type, cb, data)
+#define mb_io_man_unreg(io_man, io_hdl)		\
+    (io_man)->unreg(io_man, io_hdl)
+#define mb_io_man_new(io_fact) (io_fact)->io_man_new()
+#define mb_io_man_free(io_fact, io_man) (io_fact)->io_man_free(io_man)
+
+/*! \brief Function signature of callback functions for timers.
+ */
+typedef void (*mb_timer_cb_t)(int hdl,
+			      const mb_timeval_t *tmo,
+			      const mb_timeval_t *now,
+			      void *data);
+
+/*! \brief Timer manager
+ */
+struct _mb_timer_man {
+    /*! \brief Setup a timeout callback.
+     *
+     * \return -1 for error.
+     */
+    int (*timeout)(struct _mb_timer_man *tm_man,
+		   mb_timeval_t *tmout, /* tiemout (wall time) */
+		   mb_timer_cb_t cb, void *data);
+    /*! \brief Remove a timeout request.
+     *
+     * \param tm_hdl is the handle returned by _mb_timer_man::timeout.
+     */
+    void (*remove)(struct _mb_timer_man *tm_man, int tm_hdl);
+};
+
+/*! \brief Factory of timer manager.
+ */
+struct _mb_timer_factory {
+    mb_timer_man_t *(*timer_man_new)(void);
+    void (*timer_man_free)(mb_timer_man_t *timer_man);
+};
+
+#define mb_timer_man_timeout(tm_man, tmout, cb, data)	\
+    (tm_man)->timeout((tm_man), (tmout), (cb), (data))
+#define mb_timer_man_remove(tm_man, tm_hdl)	\
+    (tm_man)->remove((tm_man), (tm_hdl))
+#define mb_timer_man_new(tm_fact) (tm_fact)->timer_man_new()
+#define mb_timer_man_free(tm_fact, tm_man) (tm_fact)->timer_man_free(tm_man)
+
+#endif /* __MB_BACKEND_H_ */