merge the C branch into HEAD

1 files changed, 433 insertions, 0 deletions

diff --git a/c/screenwrap.c b/c/screenwrap.c
new file mode 100644
index 00000000..9ef14d8d
--- /dev/null
+++ b/c/screenwrap.c
@@ -0,0 +1,433 @@
+#include "screenwrap.h"
+#include "openbox.h"
+#include "screen.h"
+#include "kbind.h"
+#include "mbind.h"
+
+ScreenWrap *screenwrap_instance;
+
+/***************************************************************************
+ 
+   Define the type 'ScreenWrap'
+
+ ***************************************************************************/
+
+#define IS_SWRAP(v)  ((v)->ob_type == &ScreenWrapType)
+#define CHECK_SWRAP(self, funcname) { \
+    if (!IS_SWRAP(self)) { \
+        PyErr_SetString(PyExc_TypeError, \
+			"descriptor '" funcname "'  a 'Screen' object"); \
+	return NULL; \
+    } \
+}
+
+staticforward PyTypeObject ScreenWrapType;
+
+/***************************************************************************
+ 
+   Attribute methods
+ 
+ ***************************************************************************/
+
+static PyObject *swrap_number(ScreenWrap *self, PyObject *args)
+{
+    CHECK_SWRAP(self, "number");
+    if (!PyArg_ParseTuple(args, ":number"))
+	return NULL;
+    return PyInt_FromLong(ob_screen);
+}
+
+static PyObject *swrap_rootWindow(ScreenWrap *self, PyObject *args)
+{
+    CHECK_SWRAP(self, "rootWindow");
+    if (!PyArg_ParseTuple(args, ":rootWindow"))
+	return NULL;
+    return PyInt_FromLong(ob_root);
+}
+
+static PyObject *swrap_state(ScreenWrap *self, PyObject *args)
+{
+    CHECK_SWRAP(self, "state");
+    if (!PyArg_ParseTuple(args, ":state"))
+	return NULL;
+    return PyInt_FromLong(ob_state);
+}
+
+static PyObject *swrap_numDesktops(ScreenWrap *self, PyObject *args)
+{
+    CHECK_SWRAP(self, "numDesktops");
+    if (!PyArg_ParseTuple(args, ":numDesktops"))
+	return NULL;
+    return PyInt_FromLong(screen_num_desktops);
+}
+
+static PyObject *swrap_desktop(ScreenWrap *self, PyObject *args)
+{
+    CHECK_SWRAP(self, "desktop");
+    if (!PyArg_ParseTuple(args, ":desktop"))
+	return NULL;
+    return PyInt_FromLong(screen_desktop);
+}
+
+static PyObject *swrap_physicalSize(ScreenWrap *self, PyObject *args)
+{
+    PyObject *tuple;
+
+    CHECK_SWRAP(self, "physicalSize");
+    if (!PyArg_ParseTuple(args, ":physicalSize"))
+	return NULL;
+    tuple = PyTuple_New(2);
+    PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(screen_physical_size.width));
+    PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(screen_physical_size.height));
+    return tuple;
+}
+
+static PyObject *swrap_showingDesktop(ScreenWrap *self, PyObject *args)
+{
+    CHECK_SWRAP(self, "showingDesktop");
+    if (!PyArg_ParseTuple(args, ":showingDesktop"))
+	return NULL;
+    return PyInt_FromLong(screen_showing_desktop ? 1 : 0);
+}
+
+static PyObject *swrap_desktopLayout(ScreenWrap *self, PyObject *args)
+{
+    PyObject *tuple;
+
+    CHECK_SWRAP(self, "desktopLayout");
+    if (!PyArg_ParseTuple(args, ":desktopLayout"))
+	return NULL;
+    tuple = PyTuple_New(4);
+    PyTuple_SET_ITEM(tuple, 0,
+		     PyInt_FromLong(screen_desktop_layout.orientation));
+    PyTuple_SET_ITEM(tuple, 1,
+		     PyInt_FromLong(screen_desktop_layout.start_corner));
+    PyTuple_SET_ITEM(tuple, 2,
+		     PyInt_FromLong(screen_desktop_layout.rows));
+    PyTuple_SET_ITEM(tuple, 3,
+		     PyInt_FromLong(screen_desktop_layout.columns));
+    return tuple;
+}
+
+static PyObject *swrap_desktopNames(ScreenWrap *self, PyObject *args)
+{
+    PyObject *list;
+    guint s, i;
+
+    CHECK_SWRAP(self, "desktopNames");
+    if (!PyArg_ParseTuple(args, ":desktopNames"))
+	return NULL;
+    s = screen_desktop_names->len;
+    list = PyList_New(s);
+    for (i = 0; i < s; ++i)
+	PyList_SET_ITEM(list, i, PyString_FromString
+			(g_ptr_array_index(screen_desktop_names, i)));
+    return list;
+}
+
+static PyObject *swrap_area(ScreenWrap *self, PyObject *args)
+{
+    PyObject * tuple;
+    Rect *r;
+    guint i;
+
+    CHECK_SWRAP(self, "area");
+    if (!PyArg_ParseTuple(args, "i:area", &i))
+	return NULL;
+    r = screen_area(i);
+    if (r == NULL) {
+	PyErr_SetString(PyExc_IndexError,
+			"the requested desktop was not valid");
+	return NULL;
+    }
+    tuple = PyTuple_New(4);
+    PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(r->x));
+    PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(r->y));
+    PyTuple_SET_ITEM(tuple, 2, PyInt_FromLong(r->width));
+    PyTuple_SET_ITEM(tuple, 3, PyInt_FromLong(r->height));
+    return tuple;
+}
+
+static PyObject *swrap_strut(ScreenWrap *self, PyObject *args)
+{
+    PyObject *tuple;
+    Strut *s;
+    guint i;
+
+    CHECK_SWRAP(self, "strut");
+    if (!PyArg_ParseTuple(args, "i:strut", &i))
+	return NULL;
+    s = screen_strut(i);
+    if (s == NULL) {
+	PyErr_SetString(PyExc_IndexError,
+			"the requested desktop was not valid");
+	return NULL;
+    }
+    tuple = PyTuple_New(4);
+    PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(s->left));
+    PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(s->top));
+    PyTuple_SET_ITEM(tuple, 2, PyInt_FromLong(s->right));
+    PyTuple_SET_ITEM(tuple, 3, PyInt_FromLong(s->bottom));
+    return tuple;
+}
+
+static PyObject *swrap_grabKey(ScreenWrap *self, PyObject *args)
+{
+    PyObject *item, *tuple;
+    GList *keylist = NULL, *it;
+    int i, s;
+    gboolean grab = FALSE;
+
+    CHECK_SWRAP(self, "grabKey");
+    if (!PyArg_ParseTuple(args, "O:grabKey", &tuple))
+	return NULL;
+
+    if (PyTuple_Check(tuple)) {
+	s = PyTuple_GET_SIZE(tuple);
+	if (s > 0) {
+	    for (i = 0; i < s; ++i) {
+		item = PyTuple_GET_ITEM(tuple, i);
+		if (!PyString_Check(item))
+		    break;
+		keylist = g_list_append(keylist,
+					g_strdup(PyString_AsString(item)));
+	    }
+	    if (i == s)
+		grab = kbind_add(keylist);
+
+	    for (it = keylist; it != NULL; it = it->next)
+		g_free(it->data);
+	    g_list_free(it);
+
+	    if (grab) {
+		Py_INCREF(Py_None);
+		return Py_None;
+	    } else {
+		PyErr_SetString(PyExc_ValueError,
+				"the key could not be grabbed");
+		return NULL;
+	    }
+	}
+    }
+
+    PyErr_SetString(PyExc_TypeError, "expected a tuple of strings");
+    return NULL;
+}
+
+static PyObject *swrap_clearKeyGrabs(ScreenWrap *self, PyObject *args)
+{
+    CHECK_SWRAP(self, "clearKeyGrabs");
+    if (!PyArg_ParseTuple(args, ":clearKeyGrabs"))
+	return NULL;
+    kbind_clearall();
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *swrap_grabKeyboard(ScreenWrap *self, PyObject *args)
+{
+    int grab;
+
+    CHECK_SWRAP(self, "grabKeyboard");
+    if (!PyArg_ParseTuple(args, "i:grabKeyboard", &grab))
+	return NULL;
+    if (!kbind_grab_keyboard(grab)) {
+	PyErr_SetString(PyExc_RuntimeError, "failed to grab keyboard");
+	return NULL;
+    }
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *swrap_grabButton(ScreenWrap *self, PyObject *args)
+{
+    char *name;
+    char *context_str;
+    GQuark context;
+
+    CHECK_SWRAP(self, "grabButton");
+    if (!PyArg_ParseTuple(args, "ss:grabKey", &name, &context_str))
+	return NULL;
+
+    context = g_quark_try_string(context_str);
+
+    if (!context) {
+	PyErr_SetString(PyExc_ValueError, "invalid context");
+	return NULL;
+    }
+
+    if (mbind_add(name, context)) {
+	Py_INCREF(Py_None);
+	return Py_None;
+    } else {
+	PyErr_SetString(PyExc_ValueError,
+			"the button could not be grabbed");
+	return NULL;
+    }
+}
+
+static PyObject *swrap_clearButtonGrabs(ScreenWrap *self, PyObject *args)
+{
+    CHECK_SWRAP(self, "clearButtonGrabs");
+    if (!PyArg_ParseTuple(args, ":clearButtonGrabs"))
+	return NULL;
+    mbind_clearall();
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *swrap_grabPointer(ScreenWrap *self, PyObject *args)
+{
+    int grab;
+
+    CHECK_SWRAP(self, "grabPointer");
+    if (!PyArg_ParseTuple(args, "i:grabPointer", &grab))
+	return NULL;
+    if (!mbind_grab_pointer(grab)) {
+	PyErr_SetString(PyExc_RuntimeError, "failed to grab pointer");
+	return NULL;
+    }
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyMethodDef ScreenWrapAttributeMethods[] = {
+    {"number", (PyCFunction)swrap_number, METH_VARARGS,
+     "Screen.number() -- Returns the number of the screen on the X server on "
+     "which this Openbox instance is running."},
+    {"rootWindow", (PyCFunction)swrap_rootWindow, METH_VARARGS,
+     "Screen.rootWindow() -- Returns the window id of the root window."},
+    {"state", (PyCFunction)swrap_state, METH_VARARGS,
+     "Screen.state() -- Returns the running state of Openbox. One of the "
+     "ob.State_ constants."},
+    {"numDesktops", (PyCFunction)swrap_numDesktops, METH_VARARGS,
+     "Screen.numDesktops() -- Returns the number of desktops available."},
+    {"desktop", (PyCFunction)swrap_desktop, METH_VARARGS,
+     "Screen.desktop() -- Returns the currently visible desktop."},
+    {"physicalSize", (PyCFunction)swrap_physicalSize, METH_VARARGS,
+     "Screen.physicalSize() -- Returns the physical size (in pixels) of the "
+     "display in a tuple. The tuple is formatted as (width, height)."},
+    {"showingDesktop", (PyCFunction)swrap_showingDesktop, METH_VARARGS,
+     "Screen.showingDesktop() -- Returns if in showing-the-desktop mode or "
+     "not."},
+    {"desktopNames", (PyCFunction)swrap_desktopNames, METH_VARARGS,
+     "Screen.desktopNames() -- Returns a list of the names of all the "
+     "desktops, and possibly for desktops beyond those. The names are encoded "
+     "as UTF-8."},
+    {"desktopLayout", (PyCFunction)swrap_desktopLayout, METH_VARARGS,
+     "Screen.desktopLayout() -- Returns the layout of the desktops, as "
+     "specified by a compliant pager, in a tuple. The format of the tuple is "
+     "(orientation, corner, rows, columns). Where, orientation is one of the "
+     "ob.Orientation_ constants, corner is one of the ob.Corner_ constants, "
+     "and rows and columns specify the size of the layout. The rows and "
+     "columns will always include all the desktops."},
+    {"area", (PyCFunction)swrap_area, METH_VARARGS,
+     "Screen.area(d) -- Returns the usuable area on the Screen for a desktop, "
+     "in the form of a tuple. The tuples format is (x, y, width, height). The "
+     "desktop must be in the range of desktops on the screen, or 0xffffffff "
+     "to get a combined area for 'all desktops'."},
+    {"strut", (PyCFunction)swrap_area, METH_VARARGS,
+     "Screen.strut(d) -- Returns the combined strut of all clients on a "
+     "desktop, in the form of a tuple. The tuples format is "
+     "(left, top, right, bottom). The desktop must be in the range of "
+     "desktops on the screen, or 0xffffffff to get a combined strut for "
+     "'all desktops'."},
+    {"grabKey", (PyCFunction)swrap_grabKey, METH_VARARGS,
+     "Screen.grabKey(('Mod1-C-a', 'd')) -- Grabs a key chain so that key "
+     "events for it will occur. The argument must be a tuple of one or "
+     "more elements. Each key element is made up of "
+     "Modifier-Modifier-...-Key, where Modifier is one of Mod1, Mod2, "
+     "Mod3, Mod4, Mod5, S (for Shift), or C (for Control)."},
+    {"clearKeyGrabs", (PyCFunction)swrap_clearKeyGrabs, METH_VARARGS,
+     "Screen.clearKeyGrabs() -- Removes all key grabs that have been done "
+     "with grabKey()."},
+    {"grabKeyboard", (PyCFunction)swrap_grabKeyboard, METH_VARARGS,
+     "Screen.grabKeyboard(grab) -- Grabs or ungrabs the entire keyboard. When "
+     "the keyboard is grabbed, all key presses will be sent to the "
+     "hooks.keyboard hook. (grabbed keys will go to the hooks.events hook "
+     "too. "},
+    {"grabButton", (PyCFunction)swrap_grabButton, METH_VARARGS,
+     "Screen.grabButton('C-1', \"frame\") -- Grabs a pointer button "
+     "for the given context. The context must be one of the ob.Context_* "
+     "constants. The button definition is made up of "
+     "Modifier-Modifier-...-Button, where Modifier is one of Mod1, Mod2, "
+     "Mod3, Mod4, Mod5, S (for Shift), or C (for Control)."},
+    {"clearButtonGrabs", (PyCFunction)swrap_clearButtonGrabs, METH_VARARGS,
+     "Screen.clearButtonGrabs() -- Removes all button grabs that have been "
+     "done with grabButton()."},
+    {"grabPointer", (PyCFunction)swrap_grabPointer, METH_VARARGS,
+     "grabPointer(grab) -- Grabs or ungrabs the pointer device. When the "
+     "pointer is grabbed, all pointer events will be sent to the "
+     "hooks.pointer  hook. (grabbed buttons will NOT go to the hooks.events "
+     "hook while the pointer is grabbed)."},
+    {NULL, NULL, 0, NULL}
+};
+
+/***************************************************************************
+ 
+   Type methods/struct
+ 
+ ***************************************************************************/
+
+static PyObject *swrap_getattr(ScreenWrap *self, char *name)
+{
+    CHECK_SWRAP(self, "getattr");
+    return Py_FindMethod(ScreenWrapAttributeMethods, (PyObject*)self, name);
+}
+
+static void swrap_dealloc(ScreenWrap *self)
+{
+    PyObject_Del((PyObject*) self);
+}
+
+static PyTypeObject ScreenWrapType = {
+    PyObject_HEAD_INIT(NULL)
+    0,
+    "Screen",
+    sizeof(ScreenWrap),
+    0,
+    (destructor) swrap_dealloc,     /*tp_dealloc*/
+    0,                              /*tp_print*/
+    (getattrfunc) swrap_getattr,    /*tp_getattr*/
+    0,                              /*tp_setattr*/
+    0,                              /*tp_compare*/
+    0,                              /*tp_repr*/
+    0,                              /*tp_as_number*/
+    0,                              /*tp_as_sequence*/
+    0,                              /*tp_as_mapping*/
+    0,                              /*tp_hash */
+};
+
+/***************************************************************************
+ 
+   External methods
+ 
+ ***************************************************************************/
+
+void screenwrap_startup()
+{
+    PyObject *ob, *obdict;
+    ScreenWrap *swrap;
+
+    ScreenWrapType.ob_type = &PyType_Type;
+    ScreenWrapType.tp_doc = "Wraps information and functionality global to an "
+	"instance of Openbox.";
+    PyType_Ready(&ScreenWrapType);
+    swrap = PyObject_New(ScreenWrap, &ScreenWrapType);
+
+    /* get the ob module/dict */
+    ob = PyImport_ImportModule("ob"); /* new */
+    g_assert(ob != NULL);
+    obdict = PyModule_GetDict(ob); /* borrowed */
+    g_assert(obdict != NULL);
+
+    PyDict_SetItemString(obdict, "Screen", (PyObject*)swrap);
+    Py_DECREF(swrap);
+    Py_DECREF(ob);
+}
+
+void screenwrap_shutdown()
+{
+}
+
+