summaryrefslogtreecommitdiff
path: root/c/clientwrap.c
diff options
context:
space:
mode:
Diffstat (limited to 'c/clientwrap.c')
-rw-r--r--c/clientwrap.c792
1 files changed, 792 insertions, 0 deletions
diff --git a/c/clientwrap.c b/c/clientwrap.c
new file mode 100644
index 00000000..1ea5c9f0
--- /dev/null
+++ b/c/clientwrap.c
@@ -0,0 +1,792 @@
+#include "clientwrap.h"
+#include "client.h"
+#include "frame.h"
+#include "stacking.h"
+#include "focus.h"
+#include <glib.h>
+
+/***************************************************************************
+
+ Define the type 'ClientWrap'
+
+ ***************************************************************************/
+
+#define IS_CWRAP(v) ((v)->ob_type == &ClientWrapType)
+#define IS_VALID_CWRAP(v) ((v)->client != NULL)
+#define CHECK_CWRAP(self, funcname) { \
+ if (!IS_CWRAP(self)) { \
+ PyErr_SetString(PyExc_TypeError, \
+ "descriptor '" funcname "' requires a 'Client' " \
+ "object"); \
+ return NULL; \
+ } \
+ if (!IS_VALID_CWRAP(self)) { \
+ PyErr_SetString(PyExc_ValueError, \
+ "This 'Client' is wrapping a client which no longer "\
+ "exists."); \
+ return NULL; \
+ } \
+}
+
+
+staticforward PyTypeObject ClientWrapType;
+
+/***************************************************************************
+
+ Attribute methods
+
+ ***************************************************************************/
+
+static PyObject *cwrap_window(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "window");
+ if (!PyArg_ParseTuple(args, ":window"))
+ return NULL;
+ return PyInt_FromLong(self->client->window);
+}
+
+static PyObject *cwrap_group(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "group");
+ if (!PyArg_ParseTuple(args, ":group"))
+ return NULL;
+ return PyInt_FromLong(self->client->group);
+}
+
+static PyObject *cwrap_parent(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "parent");
+ if (!PyArg_ParseTuple(args, ":parent"))
+ return NULL;
+ if (self->client->transient_for != NULL)
+ return clientwrap_new(self->client->transient_for);
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyObject *cwrap_children(ClientWrap *self, PyObject *args)
+{
+ PyObject *list;
+ GSList *it;
+ guint i, s;
+
+ CHECK_CWRAP(self, "children");
+ if (!PyArg_ParseTuple(args, ":children"))
+ return NULL;
+ s = g_slist_length(self->client->transients);
+ list = PyList_New(s);
+ for (i = 0, it = self->client->transients; i < s; ++i, it = it->next)
+ PyList_SET_ITEM(list, i, clientwrap_new(it->data));
+ return list;
+}
+
+static PyObject *cwrap_desktop(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "desktop");
+ if (!PyArg_ParseTuple(args, ":desktop"))
+ return NULL;
+ return PyInt_FromLong(self->client->desktop);
+}
+
+static PyObject *cwrap_title(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "title");
+ if (!PyArg_ParseTuple(args, ":title"))
+ return NULL;
+ return PyString_FromString(self->client->title);
+}
+
+static PyObject *cwrap_iconTitle(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "iconTitle");
+ if (!PyArg_ParseTuple(args, ":iconTitle"))
+ return NULL;
+ return PyString_FromString(self->client->icon_title);
+}
+
+static PyObject *cwrap_resName(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "resName");
+ if (!PyArg_ParseTuple(args, ":resName"))
+ return NULL;
+ return PyString_FromString(self->client->res_name);
+}
+
+static PyObject *cwrap_resClass(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "resClass");
+ if (!PyArg_ParseTuple(args, ":resClass"))
+ return NULL;
+ return PyString_FromString(self->client->res_class);
+}
+
+static PyObject *cwrap_role(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "role");
+ if (!PyArg_ParseTuple(args, ":role"))
+ return NULL;
+ return PyString_FromString(self->client->role);
+}
+
+static PyObject *cwrap_type(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "type");
+ if (!PyArg_ParseTuple(args, ":type"))
+ return NULL;
+ return PyInt_FromLong(self->client->type);
+}
+
+static PyObject *cwrap_area(ClientWrap *self, PyObject *args)
+{
+ PyObject *tuple;
+
+ CHECK_CWRAP(self, "area");
+ if (!PyArg_ParseTuple(args, ":area"))
+ return NULL;
+ tuple = PyTuple_New(4);
+ PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(self->client->area.x));
+ PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(self->client->area.y));
+ PyTuple_SET_ITEM(tuple, 2, PyInt_FromLong(self->client->area.width));
+ PyTuple_SET_ITEM(tuple, 3, PyInt_FromLong(self->client->area.height));
+ return tuple;
+}
+
+static PyObject *cwrap_screenArea(ClientWrap *self, PyObject *args)
+{
+ PyObject *tuple;
+
+ CHECK_CWRAP(self, "screenArea");
+ if (!PyArg_ParseTuple(args, ":screenArea"))
+ return NULL;
+ tuple = PyTuple_New(4);
+ PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(self->client->frame->area.x));
+ PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(self->client->frame->area.y));
+ PyTuple_SET_ITEM(tuple, 2,
+ PyInt_FromLong(self->client->frame->area.width));
+ PyTuple_SET_ITEM(tuple, 3,
+ PyInt_FromLong(self->client->frame->area.height));
+ return tuple;
+}
+
+static PyObject *cwrap_strut(ClientWrap *self, PyObject *args)
+{
+ PyObject *tuple;
+
+ CHECK_CWRAP(self, "strut");
+ if (!PyArg_ParseTuple(args, ":strut"))
+ return NULL;
+ tuple = PyTuple_New(4);
+ PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(self->client->strut.left));
+ PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(self->client->strut.top));
+ PyTuple_SET_ITEM(tuple, 2, PyInt_FromLong(self->client->strut.right));
+ PyTuple_SET_ITEM(tuple, 3, PyInt_FromLong(self->client->strut.bottom));
+ return tuple;
+}
+
+static PyObject *cwrap_logicalSize(ClientWrap *self, PyObject *args)
+{
+ PyObject *tuple;
+
+ CHECK_CWRAP(self, "logicalSize");
+ if (!PyArg_ParseTuple(args, ":logicalSize"))
+ return NULL;
+ tuple = PyTuple_New(2);
+ PyTuple_SET_ITEM(tuple, 0,
+ PyInt_FromLong(self->client->logical_size.width));
+ PyTuple_SET_ITEM(tuple, 1,
+ PyInt_FromLong(self->client->logical_size.height));
+ return tuple;
+}
+
+static PyObject *cwrap_minRatio(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "minRatio");
+ if (!PyArg_ParseTuple(args, ":minRatio"))
+ return NULL;
+ return PyFloat_FromDouble(self->client->min_ratio);
+}
+
+static PyObject *cwrap_maxRatio(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "maxRatio");
+ if (!PyArg_ParseTuple(args, ":maxRatio"))
+ return NULL;
+ return PyFloat_FromDouble(self->client->max_ratio);
+}
+
+static PyObject *cwrap_minSize(ClientWrap *self, PyObject *args)
+{
+ PyObject *tuple;
+
+ CHECK_CWRAP(self, "minSize");
+ if (!PyArg_ParseTuple(args, ":minSize"))
+ return NULL;
+ tuple = PyTuple_New(2);
+ PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(self->client->min_size.width));
+ PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(self->client->min_size.height));
+ return tuple;
+}
+
+static PyObject *cwrap_maxSize(ClientWrap *self, PyObject *args)
+{
+ PyObject *tuple;
+
+ CHECK_CWRAP(self, "maxSize");
+ if (!PyArg_ParseTuple(args, ":maxSize"))
+ return NULL;
+ tuple = PyTuple_New(2);
+ PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(self->client->max_size.width));
+ PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(self->client->max_size.height));
+ return tuple;
+}
+
+static PyObject *cwrap_sizeIncrement(ClientWrap *self, PyObject *args)
+{
+ PyObject *tuple;
+
+ CHECK_CWRAP(self, "sizeIncrement");
+ if (!PyArg_ParseTuple(args, ":sizeIncrement"))
+ return NULL;
+ tuple = PyTuple_New(2);
+ PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(self->client->size_inc.width));
+ PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(self->client->size_inc.height));
+ return tuple;
+}
+
+static PyObject *cwrap_baseSize(ClientWrap *self, PyObject *args)
+{
+ PyObject *tuple;
+
+ CHECK_CWRAP(self, "baseSize");
+ if (!PyArg_ParseTuple(args, ":baseSize"))
+ return NULL;
+ tuple = PyTuple_New(2);
+ PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(self->client->base_size.width));
+ PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(self->client->base_size.height));
+ return tuple;
+}
+
+static PyObject *cwrap_gravity(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "gravity");
+ if (!PyArg_ParseTuple(args, ":gravity"))
+ return NULL;
+ return PyInt_FromLong(self->client->gravity);
+}
+
+static PyObject *cwrap_canClose(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "canClose");
+ if (!PyArg_ParseTuple(args, ":canClose"))
+ return NULL;
+ return PyInt_FromLong(self->client->delete_window ? 1 : 0);
+}
+
+static PyObject *cwrap_positionRequested(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "positionRequested");
+ if (!PyArg_ParseTuple(args, ":positionRequested"))
+ return NULL;
+ return PyInt_FromLong(self->client->positioned ? 1 : 0);
+}
+
+static PyObject *cwrap_canFocus(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "canFocus");
+ if (!PyArg_ParseTuple(args, ":canFocus"))
+ return NULL;
+ return PyInt_FromLong(self->client->can_focus ||
+ self->client->focus_notify);
+}
+
+static PyObject *cwrap_urgent(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "urgent");
+ if (!PyArg_ParseTuple(args, ":urgent"))
+ return NULL;
+ return PyInt_FromLong(self->client->urgent ? 1 : 0);
+}
+
+static PyObject *cwrap_focused(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "focused");
+ if (!PyArg_ParseTuple(args, ":focused"))
+ return NULL;
+ return PyInt_FromLong(self->client->focused ? 1 : 0);
+}
+
+static PyObject *cwrap_modal(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "modal");
+ if (!PyArg_ParseTuple(args, ":modal"))
+ return NULL;
+ return PyInt_FromLong(self->client->modal ? 1 : 0);
+}
+
+static PyObject *cwrap_shaded(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "shaded");
+ if (!PyArg_ParseTuple(args, ":shaded"))
+ return NULL;
+ return PyInt_FromLong(self->client->shaded ? 1 : 0);
+}
+
+static PyObject *cwrap_iconic(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "iconic");
+ if (!PyArg_ParseTuple(args, ":iconc"))
+ return NULL;
+ return PyInt_FromLong(self->client->iconic ? 1 : 0);
+}
+
+static PyObject *cwrap_maximizedVertical(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "maximizedVertical");
+ if (!PyArg_ParseTuple(args, ":maximizedVertical"))
+ return NULL;
+ return PyInt_FromLong(self->client->max_vert ? 1 : 0);
+}
+
+static PyObject *cwrap_maximizedHorizontal(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "maximizedHorizontal");
+ if (!PyArg_ParseTuple(args, ":maximizedHorizontal"))
+ return NULL;
+ return PyInt_FromLong(self->client->max_horz ? 1 : 0);
+}
+
+static PyObject *cwrap_skipPager(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "skipPager");
+ if (!PyArg_ParseTuple(args, ":skipPager"))
+ return NULL;
+ return PyInt_FromLong(self->client->skip_pager ? 1 : 0);
+}
+
+static PyObject *cwrap_skipTaskbar(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "skipTaskbar");
+ if (!PyArg_ParseTuple(args, ":skipTaskbar"))
+ return NULL;
+ return PyInt_FromLong(self->client->skip_taskbar ? 1 : 0);
+}
+
+static PyObject *cwrap_fullscreen(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "fullscreen");
+ if (!PyArg_ParseTuple(args, ":fullscreen"))
+ return NULL;
+ return PyInt_FromLong(self->client->fullscreen ? 1 : 0);
+}
+
+static PyObject *cwrap_above(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "above");
+ if (!PyArg_ParseTuple(args, ":above"))
+ return NULL;
+ return PyInt_FromLong(self->client->above ? 1 : 0);
+}
+
+static PyObject *cwrap_below(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "below");
+ if (!PyArg_ParseTuple(args, ":below"))
+ return NULL;
+ return PyInt_FromLong(self->client->below ? 1 : 0);
+}
+
+static PyObject *cwrap_layer(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "layer");
+ if (!PyArg_ParseTuple(args, ":layer"))
+ return NULL;
+ return PyInt_FromLong(self->client->layer);
+}
+
+static PyObject *cwrap_decorations(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "decorations");
+ if (!PyArg_ParseTuple(args, ":decorations"))
+ return NULL;
+ return PyInt_FromLong(self->client->decorations);
+}
+
+static PyObject *cwrap_disabledDecorations(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "disabledDecorations");
+ if (!PyArg_ParseTuple(args, ":disabledDecorations"))
+ return NULL;
+ return PyInt_FromLong(self->client->disabled_decorations);
+}
+
+static PyObject *cwrap_functions(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "functions");
+ if (!PyArg_ParseTuple(args, ":functions"))
+ return NULL;
+ return PyInt_FromLong(self->client->functions);
+}
+
+static PyObject *cwrap_visible(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "visible");
+ if (!PyArg_ParseTuple(args, ":visible"))
+ return NULL;
+ return PyInt_FromLong(self->client->frame->visible ? 1 : 0);
+}
+
+static PyObject *cwrap_decorationSize(ClientWrap *self, PyObject *args)
+{
+ PyObject *tuple;
+
+ CHECK_CWRAP(self, "decorationSize");
+ if (!PyArg_ParseTuple(args, ":decorationSize"))
+ return NULL;
+ tuple = PyTuple_New(4);
+ PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(self->client->frame->size.left));
+ PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(self->client->frame->size.top));
+ PyTuple_SET_ITEM(tuple, 2,
+ PyInt_FromLong(self->client->frame->size.right));
+ PyTuple_SET_ITEM(tuple, 3,
+ PyInt_FromLong(self->client->frame->size.bottom));
+ return tuple;
+}
+
+static PyObject *cwrap_normal(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "normal");
+ if (!PyArg_ParseTuple(args, ":normal"))
+ return NULL;
+ return PyInt_FromLong(client_normal(self->client) ? 1 : 0);
+}
+
+static PyObject *cwrap_setVisible(ClientWrap *self, PyObject *args)
+{
+ int i;
+
+ CHECK_CWRAP(self, "setVisible");
+ if (!PyArg_ParseTuple(args, "i:setVisible", &i))
+ return NULL;
+ if (i)
+ frame_show(self->client->frame);
+ else
+ frame_hide(self->client->frame);
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyObject *cwrap_raiseWindow(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "raiseWindow");
+ if (!PyArg_ParseTuple(args, ":raiseWindow"))
+ return NULL;
+ stacking_raise(self->client);
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyObject *cwrap_lowerWindow(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "lowerWindow");
+ if (!PyArg_ParseTuple(args, ":lowerWindow"))
+ return NULL;
+ stacking_lower(self->client);
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyObject *cwrap_focus(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "focus");
+ if (!PyArg_ParseTuple(args, ":focus"))
+ return NULL;
+ return PyInt_FromLong(client_focus(self->client) ? 1 : 0);
+}
+
+static PyObject *cwrap_unfocus(ClientWrap *self, PyObject *args)
+{
+ CHECK_CWRAP(self, "unfocus");
+ if (!PyArg_ParseTuple(args, ":unfocus"))
+ return NULL;
+ client_unfocus(self->client);
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyObject *cwrap_move(ClientWrap *self, PyObject *args)
+{
+ int x, y;
+ int final = TRUE;
+ CHECK_CWRAP(self, "move");
+ if (!PyArg_ParseTuple(args, "ii|i:unfocus", &x, &y, &final))
+ return NULL;
+ /* get the client's position based on x,y for the frame */
+ frame_frame_gravity(self->client->frame, &x, &y);
+
+ client_configure(self->client, Corner_TopLeft, x, y,
+ self->client->area.width, self->client->area.height,
+ TRUE, final);
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+#define ATTRMETH(n, d) {#n, (PyCFunction)cwrap_##n, METH_VARARGS, #d}
+
+static PyMethodDef ClientWrapMethods[] = {
+ ATTRMETH(window,
+ "c.window() -- Returns the window id for the Client."),
+ ATTRMETH(group,
+ "c.group() -- Returns the group id for the Client."),
+ ATTRMETH(parent,
+ "c.parent() -- Returns the parent Client for the Client, or the "
+ "Client for which this Client is a transient. Returns None if it "
+ "is not a transient."),
+ ATTRMETH(children,
+ "c.parent() -- Returns a list of child Clients for the Client, "
+ "or the Clients transients."),
+ ATTRMETH(desktop,
+ "c.desktop() -- Returns the desktop on which the Client resides, "
+ "or 0xffffffff for 'all desktops'."),
+ ATTRMETH(title,
+ "c.title() -- Returns the Client's title string. This is in "
+ "UTF-8 encoding."),
+ ATTRMETH(iconTitle,
+ "c.iconTitle() -- Returns the Client's icon title string. This "
+ "is in UTF-8 encoding."),
+ ATTRMETH(resName,
+ "c.resName() -- Returns the application's specified resource "
+ "name."),
+ ATTRMETH(resClass,
+ "c.resClass() -- Returns the application's specified resource "
+ "class."),
+ ATTRMETH(role,
+ "c.role() -- Returns the window's role, which should be unique "
+ "for every window of an application, if it is not empty."),
+ ATTRMETH(type,
+ "c.type() -- Returns the window's type, one of the ob.Type_ "
+ "constants. This is the logical type of the window."),
+ ATTRMETH(area,
+ "c.area() -- Returns the area rectangle for the Client in a "
+ "tuple. The tuple's format is (x, y, width, height). This is "
+ "not the area on-screen that the Client and frame occupies, but "
+ "rather, the position and size that the Client has requested, "
+ "before its gravity() and decorations have been applied. You "
+ "should use the c.screenArea() to get the actual on-screen area "
+ "for the Client."),
+ ATTRMETH(screenArea,
+ "c.screenArea() -- Returns the on-screen area rectangle for the "
+ "Client in a tuple. The tuple's format is (x, y, width, height). "
+ "This is the actual position and size of the Client plus its "
+ "decorations."),
+ ATTRMETH(strut,
+ "c.strut() -- Returns the strut requested by the Client in a "
+ "tuple. The format of the tuple is (left, top, right, bottom)."),
+ ATTRMETH(logicalSize,
+ "c.logicalSize() -- Returns the logical size of the Client. This "
+ "is the 'user friendly' size for the Client, such as for an "
+ "xterm, it will be the number of characters in the xterm "
+ "instead of the number of pixels it takes up."),
+ ATTRMETH(minRatio,
+ "c.minRatio() -- Returns the minimum width:height ratio for "
+ "the Client. A value of 0 implies no ratio enforcement."),
+ ATTRMETH(maxRatio,
+ "c.maxRatio() -- Returns the maximum width:height ratio for "
+ "the Client. A value of 0 implies no ratio enforcement."),
+ ATTRMETH(minSize,
+ "c.minSize() -- Returns the minimum size of the Client."),
+ ATTRMETH(maxSize,
+ "c.maxSize() -- Returns the maximum size of the Client."),
+ ATTRMETH(sizeIncrement,
+ "c.sizeIncrement() -- Returns the size increments in which the "
+ "Client must be resized."),
+ ATTRMETH(baseSize,
+ "c.baseSize() -- Returns the base size of the Client, which is "
+ "subtracted from the Client's size before comparing to its "
+ "various sizing constraints."),
+ ATTRMETH(gravity,
+ "c.gravity() -- Returns the gravity for the Client. One of the "
+ "ob.Gravity_ constants."),
+ ATTRMETH(canClose,
+ "c.canClose() -- Returns whether or not the Client provides a "
+ "means for Openbox to request that it close."),
+ ATTRMETH(positionRequested,
+ "c.positionRequested() -- Returns whether or not the Client has "
+ "requested a specified position on screen. When it has it should "
+ "probably not be placed using an algorithm when it is managed."),
+ ATTRMETH(canFocus,
+ "c.canFocus() -- Returns whether or not the Client can be "
+ "given input focus."),
+ ATTRMETH(urgent,
+ "c.urgent() -- Returns the urgent state of the window (on/off)."),
+ ATTRMETH(focused,
+ "c.focused() -- Returns whether or not the Client has the input "
+ "focus."),
+ ATTRMETH(modal,
+ "c.modal() -- Returns whether or not the Client is modal. A "
+ "modal Client implies that it needs to be closed before its "
+ "parent() can be used (focsed) again."),
+ ATTRMETH(shaded,
+ "c.shaded() -- Returns whether or not the Client is shaded. "
+ "Shaded clients are hidden except for their titlebar."),
+ ATTRMETH(iconic,
+ "c.iconic() -- Returns whether or not the Client is iconic. "
+ "Iconic windows are represented only by icons, or possibly "
+ "hidden entirely."),
+ ATTRMETH(maximizedVertical,
+ "c.maximizedVertical() -- Returns whether or not the Client is "
+ "maxized vertically. When a Client is maximized it will expand "
+ "to fill as much of the screen as it can in that direction."),
+ ATTRMETH(maximizedHorizontal,
+ "c.maximizedHorizontal() -- Returns whether or not the Client is "
+ "maxized horizontally. When a Client is maximized it will expand "
+ "to fill as much of the screen as it can in that direction."),
+ ATTRMETH(skipPager,
+ "c.skipPager() -- Returns whether the Client as requested to be "
+ "skipped by pagers."),
+ ATTRMETH(skipTaskbar,
+ "c.skipTaskbar() -- Returns whether the Client as requested to "
+ "be skipped by taskbars."),
+ ATTRMETH(fullscreen,
+ "c.fullscreen() -- Returns whether the Client is in fullscreen "
+ "mode."),
+ ATTRMETH(above,
+ "c.above() -- Returns whether the Client should be stacked above "
+ "other windows of the same type."),
+ ATTRMETH(below,
+ "c.below() -- Returns whether the Client should be stacked below "
+ "other windows of the same type."),
+ ATTRMETH(layer,
+ "c.layer() -- Returns the layer in which the window should be "
+ "stacked. This is one of the ob.Layer_ constants. Windows in "
+ "layers with higher values should be kept above windows in lower "
+ "valued layers."),
+ ATTRMETH(decorations,
+ "c.decorations() -- Returns a mask of decorations which the "
+ "Client will be given. It is made up of the ob.Decor_ constants. "
+ "These can be turned off with the "
+ " disabledDecorations()."),
+ ATTRMETH(disabledDecorations,
+ "c.disabledDecorations() -- returns a mask of decorations which "
+ "are disabled on the Client. This is made up of the ob.Decor_ "
+ "constants."),
+ ATTRMETH(functions,
+ "ob.functions() -- Returns the list of functionality for the "
+ "Client, in a mask made up of the ob.Func_ constants."),
+ ATTRMETH(visible,
+ "ob.visible() -- Returns if the client is currently visible "
+ "or hidden."),
+ ATTRMETH(decorationSize,
+ "c.decorationSize() -- Returns the size of the Client's "
+ "decorations around the Client window, in a tuple. The format of "
+ "the tuple is (left, top, right, bottom)."),
+ ATTRMETH(normal,
+ "c.normal() -- Returns if the window should be treated as a "
+ "normal window. Some windows (desktops, docks, splash screens) "
+ "should have special rules applied to them in a number of "
+ "places regarding focus or user interaction."),
+ ATTRMETH(setVisible,
+ "c.setVisible(show) -- Shows or hides the Client."),
+ ATTRMETH(raiseWindow,
+ "c.raiseWindow() -- Raises the Client to the top of its layer."),
+ ATTRMETH(lowerWindow,
+ "c.lowerWindow() -- Lowers the Client to the bottom of its "
+ "layer."),
+ ATTRMETH(focus,
+ "c.focus() -- Focuses the Client. Returns 1 if the Client will "
+ "be focused, or 0 if it will not."),
+ ATTRMETH(unfocus,
+ "c.unfocus() -- Unfocuses the Client, leaving nothing focused."),
+ ATTRMETH(move,
+ "c.move(x, y) -- Moves the Client to the specified position. The "
+ "top left corner of the Client's decorations is positioned at "
+ "the given x, y."),
+ { NULL, NULL, 0, NULL }
+};
+
+/***************************************************************************
+
+ Type methods/struct
+
+ ***************************************************************************/
+
+/*static PyObject *cwrap_getattr(ClientWrap *self, char *name)
+{
+ CHECK_CWRAP(self, "getattr");
+ return Py_FindMethod(ClientWrapAttributeMethods, (PyObject*)self, name);
+}*/
+
+static void cwrap_dealloc(ClientWrap *self)
+{
+ if (self->client != NULL)
+ self->client->wrap = NULL;
+ PyObject_Del((PyObject*) self);
+}
+
+static PyObject *cwrap_repr(ClientWrap *self)
+{
+ CHECK_CWRAP(self, "repr");
+ return PyString_FromFormat("0x%x", (guint)self->client->window);
+}
+
+static int cwrap_compare(ClientWrap *self, ClientWrap *other)
+{
+ Window w1, w2;
+ if (!IS_VALID_CWRAP(self)) {
+ PyErr_SetString(PyExc_ValueError,
+ "This 'Client' is wrapping a client which no longer "
+ "exists.");
+ }
+
+ w1 = self->client->window;
+ w2 = self->client->window;
+ return w1 > w2 ? 1 : w1 < w2 ? -1 : 0;
+}
+
+static PyTypeObject ClientWrapType = {
+ PyObject_HEAD_INIT(NULL)
+ 0,
+ "Client",
+ sizeof(ClientWrap),
+ 0,
+ (destructor) cwrap_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ (cmpfunc) cwrap_compare, /*tp_compare*/
+ (reprfunc) cwrap_repr, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+ 0, /*tp_hash */
+};
+
+/***************************************************************************
+
+ External methods
+
+ ***************************************************************************/
+
+void clientwrap_startup()
+{
+ ClientWrapType.ob_type = &PyType_Type;
+ ClientWrapType.tp_methods = ClientWrapMethods;
+ PyType_Ready(&ClientWrapType);
+}
+
+void clientwrap_shutdown()
+{
+}
+
+PyObject *clientwrap_new(Client *client)
+{
+ g_assert(client != NULL);
+
+ if (client->wrap != NULL) {
+ /* already has a wrapper! */
+ Py_INCREF((PyObject*) client->wrap);
+ } else {
+ client->wrap = PyObject_New(ClientWrap, &ClientWrapType);
+ client->wrap->client = client;
+ }
+ return (PyObject*) client->wrap;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2026-02-17 11:47:03 +0000