jcarr
/
xstartplacement
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
xstartplacement/devilspie/script_functions.c

2660 lines
53 KiB
C
Raw Permalink Normal View History

day 1
2024-11-24 06:57:05 -06:00
/**
* This file is part of devilspie2
* Copyright (C) 2011-2019 Andreas Rönnquist
* Copyright (C) 2019-2021 Darren Salt
*
* devilspie2 is free software: you can redistribute it and/or
* modify it under the terms of the GNU General Public License as published
* by the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* devilspie2 is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with devilspie2.
* If not, see <http://www.gnu.org/licenses/>.
*/
#include "glib.h"
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <errno.h>
#define WNCK_I_KNOW_THIS_IS_UNSTABLE
#include <libwnck/libwnck.h>
#include <X11/Xlib.h>
#include <X11/Xatom.h>
#include <gdk/gdk.h>
#include <gdk/gdkx.h>
#include <locale.h>
#include <limits.h>
#include "intl.h"
#include <lua.h>
#include <lualib.h>
#include <lauxlib.h>
#include <X11/extensions/Xrandr.h>
#if (GTK_MAJOR_VERSION >= 3)
#define HAVE_GTK3
#endif
#include "compat.h"
#include "script_functions.h"
#include "script.h"
#include "xutils.h"
#include "error_strings.h"
#define DEPRECATED() fprintf(stderr, "warning: deprecated function %s called\n", __func__ + 2);
/**
*
*/
WnckWindow *current_window = NULL;
static Bool current_time_cb(Display *display, XEvent *xevent, XPointer arg)
{
Window wnd = GPOINTER_TO_UINT(arg);
if (xevent->type == PropertyNotify &&
xevent->xproperty.window == wnd &&
xevent->xproperty.atom == my_wnck_atom_get("WM_NAME"))
return True;
return False;
}
/**
* Get current X11 timestamp.
*
* Unfortunately, gtk_get_current_event_time() does not work here
* because we cannot assume we are inside an event.
*
* Getting this timestamp is tricky. According to a comment in the ICCCM
* specification (https://tronche.com/gui/x/icccm/sec-2.html#s-2.1):
*
* A zero-length append to a property is a way to obtain a
* timestamp for this purpose; the timestamp is in the
* corresponding PropertyNotify event.
*
* So here we are zero-length appending to the "WM_NAME" property.
*/
static guint32 current_time(void)
{
WnckWindow *window;
gulong wnd;
Display *dpy;
Atom prop;
XEvent xevent;
window = get_current_window();
if (!window)
return GDK_CURRENT_TIME;
dpy = gdk_x11_get_default_xdisplay();
wnd = wnck_window_get_xid(window);
prop = my_wnck_atom_get("WM_NAME");
XChangeProperty(dpy, wnd, prop, XA_STRING, 8, PropModeAppend, NULL, 0);
/* Wait for the event to succeed */
XIfEvent(dpy, &xevent, current_time_cb, GUINT_TO_POINTER(wnd));
return xevent.xproperty.time;
}
/**
* Check for the correct parameter count.
* Failure will log a lua error and return False.
* Success returns True.
*/
static Bool check_param_count(lua_State *lua, const char *funcname, int expected)
{
int top = lua_gettop(lua);
gchar* error_message;
if (top != expected) {
error_message = num_indata_expected_errors[expected];
if (error_message == NULL) {
error_message = failed_string;
}
luaL_error(lua, "%s: %s", funcname, error_message);
return False;
}
return True;
}
/**
* Check for the correct parameter count, one of two expected values.
* Failure will log a lua error and return False.
* Success returns True.
*/
static Bool check_param_counts(lua_State *lua, const char *funcname, int expected1, int expected2)
{
int top = lua_gettop(lua);
gchar* error_message;
if (top != expected1 && top != expected2) {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
error_message = g_strdup_printf(n_or_m_indata_expected_error, expected1, expected2);
#pragma GCC diagnostic pop
luaL_error(lua, "%s: %s", funcname, error_message);
g_free(error_message);
return False;
}
return True;
}
/**
* Check for the correct parameter count in a range of expected values.
* Failure will log a lua error and return False.
* Success returns True.
*/
static Bool check_param_counts_range(lua_State *lua, char *funcname, int expected_min, int expected_max)
{
int top = lua_gettop(lua);
gchar* error_message;
if (top < expected_min || top > expected_max) {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
error_message = g_strdup_printf(n_to_m_indata_expected_error, expected_min, expected_max);
#pragma GCC diagnostic pop
luaL_error(lua, "%s: %s", funcname, error_message);
g_free(error_message);
return False;
}
return True;
}
static gboolean default_use_utf8 = False;
gboolean c_use_utf8(lua_State *lua)
{
if (!check_param_counts(lua, "use_utf8", 0, 1)) {
return 0;
}
gboolean v = default_use_utf8;
int top = lua_gettop(lua);
if (top) {
int type = lua_type(lua, 1);
if (type != LUA_TBOOLEAN) {
luaL_error(lua, "use_utf8: %s", boolean_expected_as_indata_error);
return 0;
}
int value = lua_toboolean(lua, 1);
v = (gboolean)(value);
}
lua_pushboolean(lua, default_use_utf8);
default_use_utf8 = v;
return 1;
}
static gboolean adjusting_for_decoration = FALSE;
int c_set_adjust_for_decoration(lua_State *lua)
{
if (!check_param_counts(lua, "set_adjust_for_decoration", 0, 1)) {
return 0;
}
gboolean v = TRUE;
if (lua_gettop(lua)) {
int type = lua_type(lua, 1);
if (type != LUA_TBOOLEAN) {
luaL_error(lua, "set_adjust_for_decoration: %s", boolean_expected_as_indata_error);
return 0;
}
int value = lua_toboolean(lua, 1);
v = (gboolean)(value);
}
adjusting_for_decoration = v;
return 0;
}
/**
* returns the window name
*/
int c_get_window_name(lua_State *lua)
{
if (!check_param_count(lua, "get_window_name", 0)) {
return 0;
}
WnckWindow *window = get_current_window();
const char *test = window ? wnck_window_get_name(window) : "";
lua_pushstring(lua, test);
// one item returned (the window name as a string)
return 1;
}
/**
* c_get_window_name always returns a string, even if a window hasn't
* got a name - use this function to determine if a window really has
* a name or not.
* returns a boolean true or false
*/
int c_get_window_has_name(lua_State *lua)
{
if (!check_param_count(lua, "get_window_has_name", 0)) {
return 0;
}
WnckWindow *window = get_current_window();
gboolean has_name = window ? wnck_window_has_name(window) : FALSE;
lua_pushboolean(lua, has_name);
return 1;
}
/**
* Internal code for calculating the new position of the window
* Returns -1 on parameter error, +1 (TRUE) on success (or if emulating), else 0 (FALSE)
*/
static int do_set_window_position_internal(lua_State *restrict lua, const char *const fn, int *restrict px, int *restrict py, gboolean with_size)
{
int monitor = with_size ? 5 : 3;
if (!check_param_counts(lua, fn, monitor - 1, monitor)) {
return -1;
}
int top = lua_gettop(lua);
for (int i = 1; i <= top; ++i)
if (lua_type(lua, i) != LUA_TNUMBER) {
luaL_error(lua, "%s: %s", fn, number_expected_as_indata_error);
return -1;
}
*px = lua_tonumber(lua, 1);
*py = lua_tonumber(lua, 2);
if (top == monitor) {
monitor = lua_tonumber (lua, monitor) - 1;
if (monitor < MONITOR_ALL || monitor >= get_monitor_count())
monitor = 0; // FIXME: primary monitor; show warning?
} else
monitor = MONITOR_NONE;
if (devilspie2_emulate)
return TRUE;
WnckWindow *window = get_current_window();
if (!window)
return FALSE;
if (monitor != MONITOR_NONE) {
/* +ve x: relative to left
* -ve x: relative to right (bitwise NOT)
* +ve y: relative to top
* -ve y: relative to bottom (bitwise NOT)
*/
GdkRectangle bounds, geom;
wnck_window_get_geometry(window, &geom.x, &geom.y, &geom.width, &geom.height);
monitor = get_monitor_or_workspace_geometry(monitor, window, &bounds);
if (monitor == MONITOR_NONE)
return FALSE;
if (*px < 0)
*px = bounds.x + bounds.width - ~*px - geom.width;
else
*px += bounds.x;
if (*py < 0)
*py = bounds.y + bounds.height - ~*py - geom.height;
else
*py += bounds.y;
}
return TRUE;
}
/**
* Set the Window Geometry
* set_window_geometry(x,y,xsize,ysize,[monitor_index]);
*/
int c_set_window_geometry(lua_State *lua)
{
int x, y;
int ret = do_set_window_position_internal(lua, "set_window_geometry", &x, &y, TRUE);
if (ret < 0)
return 0;
else if (ret > 0) {
int xsize = lua_tonumber(lua, 3);
int ysize = lua_tonumber(lua, 4);
WnckWindow *window = get_current_window();
if (window) {
set_window_geometry(window, x, y, xsize, ysize, adjusting_for_decoration);
}
}
lua_pushboolean(lua, ret);
return 1;
}
/**
* Set the Window Geometry2
* set_window_geometry2(x,y,xsize,ysize,[monitor_index]);
*/
int c_set_window_geometry2(lua_State *lua)
{
int x, y;
int ret = do_set_window_position_internal(lua, "set_window_geometry2", &x, &y, TRUE);
if (ret < 0)
return 0;
else if (ret > 0) {
int xsize = lua_tonumber(lua, 3);
int ysize = lua_tonumber(lua, 4);
WnckWindow *window = get_current_window();
if (window) {
XMoveResizeWindow(gdk_x11_get_default_xdisplay(),
wnck_window_get_xid(window),
x, y,
xsize, ysize);
}
}
lua_pushboolean(lua, ret);
return 1;
}
/**
* Set the position of the window
*/
int c_set_window_position(lua_State *lua)
{
int x, y;
int ret = do_set_window_position_internal(lua, "set_window_position", &x, &y, FALSE);
if (ret < 0)
return 0;
else if (ret > 0) {
WnckWindow *window = get_current_window();
if (window) {
if (adjusting_for_decoration)
adjust_for_decoration(window, &x, &y, NULL, NULL);
wnck_window_set_geometry(window,
WNCK_WINDOW_GRAVITY_CURRENT,
WNCK_WINDOW_CHANGE_X + WNCK_WINDOW_CHANGE_Y,
x, y, -1, -1);
}
}
lua_pushboolean(lua, ret);
return 1;
}
/**
*
*/
int c_set_window_position2(lua_State *lua)
{
int x, y;
int ret = do_set_window_position_internal(lua, "set_window_position2", &x, &y, FALSE);
if (ret < 0)
return 0;
else if (ret > 0) {
WnckWindow *window = get_current_window();
if (window) {
XMoveWindow(GDK_DISPLAY_XDISPLAY(gdk_display_get_default()),
wnck_window_get_xid(window),
x, y);
}
}
lua_pushboolean(lua, ret);
return 1;
}
/**
* Sets the size of the window
*/
int c_set_window_size(lua_State *lua)
{
if (!check_param_count(lua, "set_window_size", 2)) {
return 0;
}
int type1 = lua_type(lua, 1);
int type2 = lua_type(lua, 2);
if ((type1 != LUA_TNUMBER) || (type2 != LUA_TNUMBER)) {
luaL_error(lua,"set_window_size: %s", number_expected_as_indata_error);
return 0;
}
int x = lua_tonumber(lua,1);
int y = lua_tonumber(lua,2);
if (!devilspie2_emulate) {
WnckWindow *window = get_current_window();
if (window) {
devilspie2_error_trap_push();
if (adjusting_for_decoration)
adjust_for_decoration (window, NULL, NULL, &x, &y);
wnck_window_set_geometry(window,
WNCK_WINDOW_GRAVITY_CURRENT,
WNCK_WINDOW_CHANGE_WIDTH + WNCK_WINDOW_CHANGE_HEIGHT,
-1, -1, x, y);
if (devilspie2_error_trap_pop()) {
gchar *temperror=
g_strdup_printf("set_window_size: %s", failed_string);
g_printerr("%s", temperror);
g_free(temperror);
}
}
}
return 0;
}
#define NUM_STRUTS 12
static gulong *get_default_struts(Display *dpy)
{
int screen = DefaultScreen(dpy);
int width, height;
static gulong struts[NUM_STRUTS];
memset (struts, 0, sizeof(struts));
#ifdef HAVE_XRANDR
// If we have xrandr (we probably do), get the maximum screen size
int x; // throwaway
XRRGetScreenSizeRange (dpy, RootWindow(dpy, screen),
&x, &x, &width, &height);
#else
// Otherwise, fall back to the current size
width = DisplayWidth(dpy, screen);
height = DisplayHeight(dpy, screen);
#endif
struts[5] = struts[7] = height;
struts[9] = struts[11] = width;
return struts;
}
/**
* Sets the window strut
*/
int c_set_window_strut(lua_State *lua)
{
int top = lua_gettop(lua);
if (top < 4) {
luaL_error(lua,"set_window_strut: %s", at_least_four_indata_expected_error);
return 0;
}
if (top > NUM_STRUTS)
top = NUM_STRUTS;
if (!devilspie2_emulate) {
Display *dpy = gdk_x11_get_default_xdisplay();
gulong *struts = get_default_struts(dpy);
for (int i = 0; i < top; i++) {
struts[i] = lua_tonumber(lua, i + 1);
}
WnckWindow *window = get_current_window();
if (window) {
XChangeProperty(dpy,
wnck_window_get_xid(window),
XInternAtom(dpy, "_NET_WM_STRUT_PARTIAL", False), XA_CARDINAL,
32,
PropModeReplace,
(unsigned char*)struts,
NUM_STRUTS);
XSync(dpy, False);
}
}
return 0;
}
/**
* Gets the window strut
*/
int c_get_window_strut(lua_State *lua)
{
if (!check_param_count(lua, "get_window_strut", 0)) {
return 0;
}
WnckWindow *window = get_current_window();
if (!window)
return 0;
Display *dpy = gdk_x11_get_default_xdisplay();
gulong *struts = NULL;
int len = 0;
gboolean ret = my_wnck_get_cardinal_list (wnck_window_get_xid(window),
XInternAtom(dpy, "_NET_WM_STRUT_PARTIAL", False),
&struts, &len);
/* if that fails, try reading the older, deprecated property */
if (!ret)
ret = my_wnck_get_cardinal_list (wnck_window_get_xid(window),
XInternAtom(dpy, "_NET_WM_STRUT", False),
&struts, &len);
if (len) {
int i;
if (len > NUM_STRUTS)
len = NUM_STRUTS;
lua_createtable(lua, NUM_STRUTS, 0);
for (i = 0; i < len; ++i) {
lua_pushinteger(lua, struts[i]);
lua_rawseti(lua, -2, i + 1);
}
g_free(struts);
// pad out with default values if necessary
if (len < NUM_STRUTS) {
struts = get_default_struts(dpy);
for (; i < NUM_STRUTS; ++i) {
lua_pushinteger(lua, struts[i]);
lua_rawseti(lua, -2, i + 1);
}
}
return 1;
}
return 0;
}
/**
* Sets the window on top of all others and locks it "always on top"
*/
int c_make_always_on_top(lua_State *lua)
{
if (!check_param_count(lua, "make_always_on_top", 0)) {
return 0;
}
if (!devilspie2_emulate) {
WnckWindow *window = get_current_window();
if (window) {
wnck_window_make_above(window);
}
}
return 0;
}
/**
* sets the window on top of all the others
*/
int c_set_on_top(lua_State *lua)
{
if (!check_param_count(lua, "set_on_top", 0)) {
return 0;
}
if (!devilspie2_emulate) {
WnckWindow *window = get_current_window();
if (window)
XRaiseWindow(gdk_x11_get_default_xdisplay(), wnck_window_get_xid(window));
}
return 0;
}
/**
* sets the window below all the others
*/
int c_set_on_bottom(lua_State *lua)
{
if (!check_param_count(lua, "set_on_bottom", 0)) {
return 0;
}
if (!devilspie2_emulate) {
WnckWindow *window = get_current_window();
if (window)
XLowerWindow(gdk_x11_get_default_xdisplay(), wnck_window_get_xid(window));
}
return 0;
}
/**
* returns the application name
*/
int c_get_application_name(lua_State *lua)
{
if (!check_param_count(lua, "get_application_name", 0)) {
return 0;
}
const char *application_name = "";
WnckWindow *window = get_current_window();
if (window) {
WnckApplication *application=
wnck_window_get_application(get_current_window());
if (application)
application_name = wnck_application_get_name(application);
}
// one item returned - the application name as a string.
lua_pushstring(lua, application_name);
return 1;
}
/**
* lua_Bprint from http://www.lua.org/source/5.1/lbaselib.c.html
* but with the change that fputs is only called if devilspie2_debug is
* set to TRUE
*/
int c_debug_print(lua_State *lua)
{
int n = lua_gettop(lua); /* number of arguments */
lua_getglobal(lua, "tostring");
for (int i = 1; i <= n; i++) {
lua_pushvalue(lua, -1); /* function to be called */
lua_pushvalue(lua, i); /* value to print */
lua_call(lua, 1, 1);
const char *s = lua_tostring(lua, -1); /* get result */
if (s == NULL)
return luaL_error(lua, "'tostring' must return a string to 'print'");
if (i > 1) {
if (devilspie2_debug) fputs("\t", stdout);
}
if (devilspie2_debug) fputs(s, stdout);
lua_pop(lua, 1); /* pop result */
}
if (devilspie2_debug) {
fputs("\n", stdout);
fflush(stdout);
}
return 0;
}
/**
* "Shades" the window
*/
int c_shade(lua_State *lua)
{
if (!check_param_count(lua, "shade", 0)) {
return 0;
}
if (!devilspie2_emulate) {
WnckWindow *window = get_current_window();
if (window) {
wnck_window_shade(window);
}
}
return 0;
}
/**
* "Unshades" the window
*/
int c_unshade(lua_State *lua)
{
if (!check_param_count(lua, "unshade", 0)) {
return 0;
}
if (!devilspie2_emulate) {
WnckWindow *window = get_current_window();
if (window) {
wnck_window_unshade(window);
}
}
return 0;
}
/**
* Minimizes the window
*/
int c_minimize(lua_State *lua)
{
if (!check_param_count(lua, "minimize", 0)) {
return 0;
}
if (!devilspie2_emulate) {
WnckWindow *window = get_current_window();
if (window) {
wnck_window_minimize(window);
}
}
return 0;
}
/**
* unminimizes window
*/
int c_unminimize(lua_State *lua)
{
if (!check_param_count(lua, "unminimize", 0)) {
return 0;
}
if (!devilspie2_emulate) {
WnckWindow *window = get_current_window();
if (window) {
wnck_window_unminimize (window, current_time());
}
}
return 0;
}
/**
* sets the window that the scripts are affecting
*/
void set_current_window(WnckWindow *window)
{
current_window=window;
}
/**
* gets the window that the scripts are affecting
*/
WnckWindow *get_current_window()
{
return current_window;
}
/**
* Decorates a window
*/
int c_undecorate_window(lua_State *lua)
{
if (!check_param_count(lua, "undecorate_window", 0)) {
return 0;
}
gboolean result = TRUE;
if (!devilspie2_emulate) {
WnckWindow *window = get_current_window();
if (window) {
gulong xid = wnck_window_get_xid(window);
if (!undecorate_window(xid)) {
result=FALSE;
}
}
}
lua_pushboolean(lua,result);
return 1;
}
/**
* undecorates a window
*/
int c_decorate_window(lua_State *lua)
{
if (!check_param_count(lua, "decorate_window", 0)) {
return 0;
}
gboolean result = TRUE;
if (!devilspie2_emulate) {
WnckWindow *window = get_current_window();
if (window) {
gulong xid = wnck_window_get_xid(window);
if (!decorate_window(xid)) {
result=FALSE;
}
}
}
lua_pushboolean(lua,result);
return 1;
}
/**
* Checks if a window is decorated
*/
int c_get_window_is_decorated(lua_State *lua)
{
if (!check_param_count(lua, "get_window_is_decorated", 0)) {
return 0;
}
gboolean result = TRUE;
if (!devilspie2_emulate) {
WnckWindow *window = get_current_window();
if (window) {
result = get_decorated(wnck_window_get_xid(window));
}
}
lua_pushboolean(lua,result);
return 1;
}
/**
Given a workspace name, perform a linear, case-sensitive search for
a workspace with with said name.
Returns the first found or -1
*/
int find_workspace_with_name(gchar *in_workspace_name, WnckWindow *window){
if(window == NULL) {
window = get_current_window();
}
if(window == NULL || in_workspace_name == NULL || strlen(in_workspace_name) <= 0) {
return -1;
}
WnckScreen *screen = wnck_window_get_screen(window);
for (int space = 0; space < wnck_screen_get_workspace_count(screen); space++) {
WnckWorkspace *workspace = wnck_screen_get_workspace(screen, space);
if(workspace == NULL) //Theoretically possible
continue;
if(0 == g_strcmp0(in_workspace_name, wnck_workspace_get_name(workspace))){
return space;
}
}
return -1;
}
/**
* Move a window to a specific workspace
*/
int c_set_window_workspace(lua_State *lua)
{
if (!check_param_count(lua, "set_window_workspace", 1)) {
return 0;
}
int type = lua_type(lua, 1);
if (type != LUA_TNUMBER && type != LUA_TSTRING ) {
luaL_error(lua, "set_window_workspace: %s",
number_or_string_expected_as_indata_error);
return 0;
}
int workspace_idx0 = -1;
gchar *workspace_name = NULL;
switch (type) {
case LUA_TNUMBER:
workspace_idx0 = lua_tonumber(lua, 1) - 1;
break;
case LUA_TSTRING:
workspace_name = (gchar*)lua_tostring(lua, 1);
workspace_idx0 = find_workspace_with_name(workspace_name, get_current_window());
if(workspace_idx0 == -1) {
g_warning(_("A workspace with the name '%s' does not exist!"), workspace_name);
}
break;
default: break;
}
WnckWindow *window = get_current_window();
if (window && workspace_idx0 > -1) {
WnckScreen *screen = wnck_window_get_screen(window);
WnckWorkspace *workspace = wnck_screen_get_workspace(screen, workspace_idx0);
if (!workspace) {
g_warning(_("Workspace number %d does not exist!"), workspace_idx0+1);
}
if (!devilspie2_emulate) {
wnck_window_move_to_workspace(window, workspace);
}
}
lua_pushboolean(lua,TRUE);
return 1;
}
/**
* Makes a workspace the active one
*/
int c_change_workspace(lua_State *lua)
{
if (!check_param_count(lua, "change_workspace", 1)) {
return 0;
}
int type = lua_type(lua, 1);
if (type != LUA_TNUMBER && type != LUA_TSTRING) {
luaL_error(lua,"change_workspace: %s", number_or_string_expected_as_indata_error);
return 0;
}
int workspace_idx0 = -1;
gchar *workspace_name = NULL;
switch (type) {
case LUA_TNUMBER:
workspace_idx0 = lua_tonumber(lua, 1) - 1;
break;
case LUA_TSTRING:
workspace_name = (gchar*)lua_tostring(lua, 1);
workspace_idx0 = find_workspace_with_name(workspace_name, get_current_window());
if(workspace_idx0 == -1) {
g_warning(_("A workspace with the name '%s' does not exist!"), workspace_name);
}
break;
default: break;
}
WnckWindow *window = get_current_window();
if (window && workspace_idx0 > -1) {
WnckScreen *screen = wnck_window_get_screen(window);
WnckWorkspace *workspace = wnck_screen_get_workspace(screen, workspace_idx0);
if (!workspace) {
g_warning(_("Workspace number %d does not exist!"), workspace_idx0+1);
}
gint64 timestamp = g_get_real_time();
if (!devilspie2_emulate) {
wnck_workspace_activate(workspace, timestamp / 1000000);
}
}
lua_pushboolean(lua, TRUE);
return 1;
}
/**
* Return workspace count
*/
int c_get_workspace_count(lua_State *lua)
{
if (!check_param_count(lua, "get_workspace_count", 0)) {
return 0;
}
int count = 0;
WnckWindow *window = get_current_window();
if (window) {
WnckScreen *screen = wnck_window_get_screen(window);
count = wnck_screen_get_workspace_count(screen);
}
lua_pushinteger(lua, count);
return 1;
}
/**
* Unmaximize window
*/
int c_unmaximize(lua_State *lua)
{
if (!check_param_count(lua, "unmaximize", 0)) {
return 0;
}
if (!devilspie2_emulate) {
WnckWindow *window = get_current_window();
if (window) {
wnck_window_unmaximize(window);
}
}
return 0;
}
/**
* Maximize Window
*/
int c_maximize(lua_State *lua)
{
if (!check_param_count(lua, "maximize", 0)) {
return 0;
}
if (!devilspie2_emulate) {
WnckWindow *window = get_current_window();
if (window) {
wnck_window_maximize(window);
}
}
return 0;
}
/**
* Maximize Window Vertically
*/
int c_maximize_vertically(lua_State *lua)
{
if (!check_param_count(lua, "maximize_vertically", 0)) {
return 0;
}
if (!devilspie2_emulate) {
WnckWindow *window = get_current_window();
if (window) {
wnck_window_maximize_vertically(window);
}
}
return 0;
}
/**
* Maximize the window horizontally
*/
int c_maximize_horizontally(lua_State *lua)
{
if (!check_param_count(lua, "maximize_horizontally", 0)) {
return 0;
}
if (!devilspie2_emulate) {
WnckWindow *window = get_current_window();
if (window) {
wnck_window_maximize_horizontally(window);
}
}
return 0;
}
int c_maximize_horisontally(lua_State *lua)
{
DEPRECATED();
return c_maximize_horizontally(lua);
}
/**
* Pins the window
*/
int c_pin_window(lua_State *lua)
{
if (!check_param_count(lua, "pin_window", 0)) {
return 0;
}
if (!devilspie2_emulate) {
WnckWindow *window = get_current_window();
if (window) {
wnck_window_pin(window);
}
}
return 0;
}
/**
* Unpin the window
*/
int c_unpin_window(lua_State *lua)
{
if (!check_param_count(lua, "unpin_window", 0)) {
return 0;
}
if (!devilspie2_emulate) {
WnckWindow *window = get_current_window();
if (window) {
wnck_window_unpin(window);
}
}
return 0;
}
/**
* Sticks the window
*/
int c_stick_window(lua_State *lua)
{
if (!check_param_count(lua, "stick_window", 0)) {
return 0;
}
if (!devilspie2_emulate) {
WnckWindow *window = get_current_window();
if (window) {
wnck_window_stick(window);
}
}
return 0;
}
/**
* Unstick the window
*/
int c_unstick_window(lua_State *lua)
{
if (!check_param_count(lua, "unstick_window", 0)) {
return 0;
}
if (!devilspie2_emulate) {
WnckWindow *window = get_current_window();
if (window) {
wnck_window_unstick(window);
}
}
return 0;
}
/**
* return the geometry of the current window to the Lua script
*/
int c_get_window_geometry(lua_State *lua)
{
if (!check_param_count(lua, "get_window_geometry", 0)) {
return 0;
}
int x = 0, y = 0, width = 0, height = 0;
WnckWindow *window = get_current_window();
if (window)
{
wnck_window_get_geometry(window, &x, &y, &width, &height);
}
lua_pushinteger(lua, x);
lua_pushinteger(lua, y);
lua_pushinteger(lua, width);
lua_pushinteger(lua, height);
return 4;
}
/**
* return the client geometry of the current window to the Lua script
* this is excluding the window manager frame
*/
int c_get_window_client_geometry(lua_State *lua)
{
if (!check_param_count(lua, "get_window_client_geometry", 0)) {
return 0;
}
int x = 0, y = 0, width = 0, height = 0;
WnckWindow *window = get_current_window();
if (window)
{
wnck_window_get_client_window_geometry(window, &x, &y, &width, &height);
}
lua_pushinteger(lua, x);
lua_pushinteger(lua, y);
lua_pushinteger(lua, width);
lua_pushinteger(lua, height);
return 4;
}
/**
* return the window frame extents
*/
int c_get_window_frame_extents(lua_State *lua)
{
if (!check_param_count(lua, "get_window_frame_extents", 0)) {
return 0;
}
int left = 0, right = 0, top = 0, bottom = 0;
WnckWindow *window = get_current_window();
if (window) {
// Order of preference:
// _NET_FRAME_EXTENTS
// Calculation from geometries
Display *dpy = gdk_x11_get_default_xdisplay();
gulong *extents = 0;
int len = 0;
my_wnck_get_cardinal_list (wnck_window_get_xid(window),
XInternAtom(dpy, "_NET_FRAME_EXTENTS", False),
&extents, &len);
if (len >= 4) {
// _NET_FRAME_EXTENTS
left = extents[0];
right = extents[1];
top = extents[2];
bottom = extents[3];
g_free(extents);
}
else {
// Calculation from geometries
int frame[4] = {}, client[4] = {};
wnck_window_get_geometry(window, frame, frame + 1, frame + 2, frame + 3);
wnck_window_get_client_window_geometry(window, client, client + 1, client + 2, client + 3);
left = client[0] - frame[0];
right = frame[2] - client[2] - left;
top = client[1] - frame[1];
bottom = frame[3] - client[3] - top;
}
}
lua_pushinteger(lua, left);
lua_pushinteger(lua, right);
lua_pushinteger(lua, top);
lua_pushinteger(lua, bottom);
return 4;
}
/**
*
*/
int c_set_skip_tasklist(lua_State *lua)
{
if (!check_param_count(lua, "set_skip_tasklist", 1)) {
return 0;
}
int type = lua_type(lua, 1);
if (type != LUA_TBOOLEAN) {
luaL_error(lua, "set_skip_tasklist: %s", boolean_expected_as_indata_error);
return 0;
}
int value = lua_toboolean(lua, 1);
gboolean skip_tasklist = (gboolean)(value);
if (!devilspie2_emulate) {
WnckWindow *window = get_current_window();
if (window) {
wnck_window_set_skip_tasklist(window, skip_tasklist);
}
}
return 0;
}
/**
*
*/
int c_set_skip_pager(lua_State *lua)
{
if (!check_param_count(lua, "set_skip_pager", 1)) {
return 0;
}
int type = lua_type(lua, 1);
if (type != LUA_TBOOLEAN) {
luaL_error(lua, "set_skip_pager: %s", boolean_expected_as_indata_error);
return 0;
}
int value = lua_toboolean(lua, 1);
gboolean skip_pager = (gboolean)(value);
if (!devilspie2_emulate) {
WnckWindow *window = get_current_window();
if (window) {
wnck_window_set_skip_pager(window, skip_pager);
}
}
return 0;
}
/**
*
*/
int c_get_window_is_maximized(lua_State *lua)
{
if (!check_param_count(lua, "get_window_is_maximized", 0)) {
return 0;
}
WnckWindow *window = get_current_window();
gboolean is_maximized = window ? wnck_window_is_maximized(window) : FALSE;
lua_pushboolean(lua, is_maximized);
return 1;
}
/**
*
*/
int c_get_window_is_maximized_vertically(lua_State *lua)
{
if (!check_param_count(lua, "get_window_is_maximized_vertically", 0)) {
return 0;
}
WnckWindow *window = get_current_window();
gboolean is_vertically_maximized = window ? wnck_window_is_maximized_vertically(window) : FALSE;
lua_pushboolean(lua, is_vertically_maximized);
return 1;
}
/**
*
*/
int c_get_window_is_maximized_horizontally(lua_State *lua)
{
if (!check_param_count(lua, "get_window_is_maximized_horizontally", 0)) {
return 0;
}
WnckWindow *window = get_current_window();
gboolean is_horizontally_maximized = window ? wnck_window_is_maximized_horizontally(window) : FALSE;
lua_pushboolean(lua, is_horizontally_maximized);
return 1;
}
int c_get_window_is_maximized_horisontally(lua_State *lua)
{
DEPRECATED();
return c_get_window_is_maximized_horizontally(lua);
}
/**
*
*/
int c_get_window_is_pinned(lua_State *lua)
{
if (!check_param_count(lua, "get_window_is_pinned", 0)) {
return 0;
}
WnckWindow *window = get_current_window();
gboolean is_pinned = window ? wnck_window_is_pinned(window) : FALSE;
lua_pushboolean(lua, is_pinned);
return 1;
}
/**
*
*/
int c_set_window_above(lua_State *lua)
{
if (!check_param_counts(lua, "set_window_above", 0, 1)) {
return 0;
}
int top = lua_gettop(lua);
gboolean set_above = TRUE;
if (top == 1)
{
int type = lua_type(lua, 1);
if (type != LUA_TBOOLEAN) {
luaL_error(lua, "set_window_above: %s", boolean_expected_as_indata_error);
return 0;
}
int value = lua_toboolean(lua, 1);
set_above = (gboolean)(value);
}
if (!devilspie2_emulate) {
WnckWindow *window = get_current_window();
if (window) {
if (set_above)
wnck_window_make_above(window);
else
wnck_window_unmake_above(window);
}
}
return 0;
}
/**
*
*/
int c_set_window_below(lua_State *lua)
{
if (!check_param_counts(lua, "set_window_below", 0, 1)) {
return 0;
}
int top = lua_gettop(lua);
gboolean set_below = TRUE;
if (top == 1)
{
int type = lua_type(lua, 1);
if (type != LUA_TBOOLEAN) {
luaL_error(lua, "set_window_below: %s", boolean_expected_as_indata_error);
return 0;
}
int value = lua_toboolean(lua, 1);
set_below = (gboolean)(value);
}
if (!devilspie2_emulate) {
WnckWindow *window = get_current_window();
if (window) {
if (set_below)
wnck_window_make_below(window);
else
wnck_window_unmake_below(window);
}
}
return 0;
}
/**
*
*/
int c_get_window_type(lua_State *lua)
{
if (!check_param_count(lua, "get_window_type", 0)) {
return 0;
}
WnckWindow *window = get_current_window();
const char *window_type_string;
if (window) {
WnckWindowType window_type = wnck_window_get_window_type(window);
switch (window_type) {
case WNCK_WINDOW_NORMAL:
window_type_string = "WINDOW_TYPE_NORMAL";
break;
case WNCK_WINDOW_DESKTOP:
window_type_string = "WINDOW_TYPE_DESKTOP";
break;
case WNCK_WINDOW_DOCK:
window_type_string = "WINDOW_TYPE_DOCK";
break;
case WNCK_WINDOW_DIALOG:
window_type_string = "WINDOW_TYPE_DIALOG";
break;
case WNCK_WINDOW_TOOLBAR:
window_type_string = "WINDOW_TYPE_TOOLBAR";
break;
case WNCK_WINDOW_MENU:
window_type_string = "WINDOW_TYPE_MENU";
break;
case WNCK_WINDOW_UTILITY:
window_type_string = "WINDOW_TYPE_UTILITY";
break;
case WNCK_WINDOW_SPLASHSCREEN:
window_type_string = "WINDOW_TYPE_SPLASHSCREEN";
break;
default:
window_type_string = "WINDOW_TYPE_UNRECOGNIZED";
};
} else {
window_type_string = "WINDOW_ERROR";
}
lua_pushstring(lua, window_type_string);
return 1;
}
/**
* c_get_class_instance_name
* Only available on libwnck 3+
*/
int c_get_class_instance_name(lua_State *lua)
{
if (!check_param_count(lua, "get_class_instance_name", 0)) {
return 0;
}
#ifdef HAVE_GTK3
WnckWindow *window = get_current_window();
const char *class_instance_name = window ? wnck_window_get_class_instance_name(window) : "";
// one item returned - the window class instance name as a string.
lua_pushstring(lua, class_instance_name);
#else
lua_pushnil(lua);
#endif
return 1;
}
/**
* c_get_class_group_name
* Only available on libwnck 3+
*/
int c_get_class_group_name(lua_State *lua)
{
if (!check_param_count(lua, "get_class_group_name", 0)) {
return 0;
}
#ifdef HAVE_GTK3
WnckWindow *window = get_current_window();
const char *class_group_name = window ? wnck_window_get_class_group_name(window) : "";
// one item returned - the window class instance name as a string.
lua_pushstring(lua, class_group_name);
#else
lua_pushnil(lua);
#endif
return 1;
}
/**
*
*/
static int c_get_window_property_internal(lua_State *lua, const char *func, gboolean report)
{
if (!check_param_count(lua, "get_window_property", 1)) {
return 0;
}
// gchar *property=
int ret = 0;
int type = lua_type(lua, 1);
if (type != LUA_TSTRING) {
luaL_error(lua, "%s: %s", func, string_expected_as_indata_error);
return 0;
}
const gchar *value = lua_tostring(lua, 1);
WnckWindow *window = get_current_window();
if (window) {
gboolean utf8;
char *result = my_wnck_get_string_property(wnck_window_get_xid(window), my_wnck_atom_get(value), &utf8);
if (report & 1) {
lua_pushstring(lua, result ? result : "");
ret++;
}
if (report & 2) {
lua_pushboolean(lua, utf8);
ret++;
}
g_free (result);
} else {
//lua_pushstring(lua, "NO RESULT");
lua_pushnil(lua);
ret++;
}
return ret;
}
int c_get_window_property(lua_State *lua)
{
return c_get_window_property_internal(lua, "get_window_property", 1);
}
int c_window_property_is_utf8(lua_State *lua)
{
return c_get_window_property_internal(lua, "window_property_is_utf8", 2);
}
int c_get_window_property_full(lua_State *lua)
{
return c_get_window_property_internal(lua, "get_window_property_full", 3);
}
/**
*
*/
int c_set_window_property(lua_State *lua)
{
if (!check_param_counts(lua, "set_window_property", 2, 3)) {
return 0;
}
int top = lua_gettop(lua);
WnckWindow *window = get_current_window();
int type = lua_type(lua, 1);
if (type != LUA_TSTRING) {
luaL_error(lua, "set_window_property: %s", string_expected_as_indata_error);
return 0;
}
const gchar *property = lua_tostring(lua, 1);
type = lua_type(lua, 2);
switch (type) {
case LUA_TSTRING:
gboolean use_utf8 = default_use_utf8;
if (top > 2) {
type = lua_type(lua, 3);
if (type != LUA_TBOOLEAN) {
luaL_error(lua, "set_window_property: %s", boolean_expected_as_indata_error);
return 0;
}
use_utf8 = lua_toboolean(lua, 3);
}
if (!devilspie2_emulate && window)
my_wnck_set_string_property(wnck_window_get_xid(window), my_wnck_atom_get(property),
lua_tostring(lua, 2), use_utf8);
break;
case LUA_TNUMBER:
if (!devilspie2_emulate && window)
my_wnck_set_cardinal_property(wnck_window_get_xid(window), my_wnck_atom_get(property),
(int32_t) lua_tonumber(lua, 2));
break;
case LUA_TBOOLEAN:
if (!devilspie2_emulate && window)
my_wnck_set_cardinal_property(wnck_window_get_xid(window), my_wnck_atom_get(property),
(int32_t) lua_toboolean(lua, 2));
break;
default:
luaL_error(lua, "set_window_property: %s", number_or_string_or_boolean_expected_as_indata_error);
}
return 0;
}
/**
*
*/
int c_delete_window_property(lua_State *lua)
{
if (!check_param_count(lua, "delete_window_property", 1)) {
return 0;
}
WnckWindow *window = get_current_window();
int type = lua_type(lua, 1);
if (type != LUA_TSTRING) {
luaL_error(lua, "del_window_property: %s", string_expected_as_indata_error);
return 0;
}
const gchar *property = lua_tostring(lua, 1);
if (!devilspie2_emulate)
my_wnck_delete_property(wnck_window_get_xid(window), my_wnck_atom_get(property));
return 0;
}
/**
*
*/
int c_get_window_role(lua_State *lua)
{
if (!check_param_count(lua, "get_window_role", 0)) {
return 0;
}
WnckWindow *window = get_current_window();
if (window) {
char *result = my_wnck_get_string_property(wnck_window_get_xid(window), my_wnck_atom_get("WM_WINDOW_ROLE"), NULL);
lua_pushstring(lua, result ? result : "");
g_free (result);
} else {
lua_pushstring(lua, "");
}
return 1;
}
/**
*
*/
int c_get_window_xid(lua_State *lua)
{
if (!check_param_count(lua, "get_window_xid", 0)) {
return 0;
}
WnckWindow *window = get_current_window();
gulong result = window ? wnck_window_get_xid(window) : 0;
lua_pushinteger(lua, result);
return 1;
}
/**
*
*/
int c_get_window_class(lua_State *lua)
{
if (!check_param_count(lua, "get_window_class", 0)) {
return 0;
}
WnckWindow *window = get_current_window();
const char *result = "";
if (window) {
WnckClassGroup *class_group = wnck_window_get_class_group(window);
if (class_group) {
#ifdef WNCK_MAJOR_VERSION
#if WNCK_CHECK_VERSION(3,2,0)
result = (char*)wnck_class_group_get_id(class_group);
#else
result = (char*)wnck_class_group_get_res_class (class_group);
#endif
#else
result = (char*)wnck_class_group_get_res_class (class_group);
#endif
}
}
lua_pushstring(lua, result);
return 1;
}
/**
*
*/
int c_set_window_fullscreen(lua_State *lua)
{
if (!check_param_count(lua, "set_window_fullscreen", 1)) {
return 0;
}
WnckWindow *window = get_current_window();
int type = lua_type(lua, 1);
if (type != LUA_TBOOLEAN) {
luaL_error(lua, "set_window_fullscreen: %s",
boolean_expected_as_indata_error);
return 0;
}
gboolean fullscreen = lua_toboolean(lua, 1);
if (!devilspie2_emulate && window) {
wnck_window_set_fullscreen(window, fullscreen);
}
return 0;
}
/**
*
*/
int c_set_viewport(lua_State *lua)
{
if (!check_param_counts(lua, "set_viewport", 1, 2)) {
return 0;
}
int top = lua_gettop(lua);
int width, height;
int viewport_start_x, viewport_start_y;
int win_x, win_y;
gulong xid;
WnckWindow *window;
switch (top)
{
case 1:
WnckScreen *screen;
int x;
int type = lua_type(lua, 1);
if (type != LUA_TNUMBER) {
luaL_error(lua, "set_viewport: %s", number_expected_as_indata_error);
return 0;
}
int num = lua_tonumber(lua,1);
if (num <= 0) {
g_error("set_viewport: %s", integer_greater_than_zero_expected_error);
lua_pushboolean(lua, FALSE);
return 1;
}
window = get_current_window();
if (!window) {
lua_pushboolean(lua, FALSE);
return 1;
}
screen = wnck_window_get_screen(window);
wnck_window_get_geometry(window, &win_x, &win_y, &width, &height);
xid = wnck_window_get_xid(window);
//viewport_start = devilspie2_get_viewport_start(xid);
if (devilspie2_get_viewport_start(xid, &viewport_start_x, &viewport_start_y) != 0) {
g_printerr("set_viewport: %s", could_not_find_current_viewport_error);
lua_pushboolean(lua, FALSE);
return 1;
}
x = ((num - 1) * wnck_screen_get_width(screen)) - viewport_start_x + win_x;
if (!devilspie2_emulate) {
devilspie2_error_trap_push();
XMoveResizeWindow(gdk_x11_get_default_xdisplay(),
wnck_window_get_xid(window),
x, win_y, width, height);
if (devilspie2_error_trap_pop()) {
g_printerr("set_viewport: %s", setting_viewport_failed_error);
lua_pushboolean(lua, FALSE);
return 1;
}
}
lua_pushboolean(lua, TRUE);
return 1;
case 2:
int type1 = lua_type(lua, 1);
int type2 = lua_type(lua, 2);
if (type1 != LUA_TNUMBER) {
luaL_error(lua, "set_viewport: %s", number_expected_as_indata_error);
return 0;
}
if (type2 != LUA_TNUMBER) {
luaL_error(lua, "set_viewport: %s", number_expected_as_indata_error);
return 0;
}
int new_xpos = lua_tonumber(lua, 1);
int new_ypos = lua_tonumber(lua, 2);
window = get_current_window();
if (!window) {
lua_pushboolean(lua, FALSE);
return 1;
}
wnck_window_get_geometry(window, &win_x, &win_y, &width, &height);
xid = wnck_window_get_xid(window);
//viewport_start = devilspie2_get_viewport_start(xid);
if (devilspie2_get_viewport_start(xid, &viewport_start_x, &viewport_start_y) != 0) {
g_printerr("set_viewport: %s", could_not_find_current_viewport_error);
lua_pushboolean(lua, FALSE);
return 1;
}
if (!devilspie2_emulate) {
devilspie2_error_trap_push();
XMoveResizeWindow(gdk_x11_get_default_xdisplay(),
wnck_window_get_xid(window),
new_xpos, new_ypos, width, height);
if (devilspie2_error_trap_pop()) {
g_printerr("set_viewport: %s", setting_viewport_failed_error);
lua_pushboolean(lua, FALSE);
return 1;
}
}
lua_pushboolean(lua, TRUE);
return 1;
}
return 0;
}
/**
*
*/
int c_center(lua_State *lua)
{
if (!check_param_counts_range(lua, "center", 0, 2)) {
return 0;
}
int top = lua_gettop(lua);
GdkRectangle desktop_r, window_r;
WnckWindow *window = get_current_window();
if (!window) {
lua_pushboolean(lua, FALSE);
return 1;
}
wnck_window_get_geometry(window, &window_r.x, &window_r.y, &window_r.width, &window_r.height);
int monitor_no = MONITOR_ALL;
enum { CENTRE_NONE, CENTRE_H, CENTRE_V, CENTRE_HV } centre = CENTRE_HV;
for (int i = 1; i <= top; ++i) {
int type = lua_type(lua, i);
gchar *indata;
switch (type) {
case LUA_TNUMBER:
monitor_no = lua_tonumber(lua, i) - 1;
if (monitor_no < MONITOR_ALL || monitor_no >= get_monitor_count())
monitor_no = MONITOR_WINDOW; // FIXME: primary monitor; show warning?
break;
case LUA_TSTRING:
indata = (gchar*)lua_tostring(lua, i);
switch (*indata & 0xDF) {
case 'H':
centre = CENTRE_H;
break;
case 'V':
centre = CENTRE_V;
break;
default:
centre = CENTRE_HV;
}
break;
default:
luaL_error(lua, "center: %s", number_or_string_expected_as_indata_error);
}
}
monitor_no = get_monitor_or_workspace_geometry(monitor_no, window, &desktop_r);
if (monitor_no == MONITOR_NONE) {
lua_pushboolean(lua, FALSE);
return 1;
}
if (centre & 1)
window_r.x = desktop_r.x + (desktop_r.width - window_r.width) / 2;
else if (window_r.x < desktop_r.x)
window_r.x = desktop_r.x;
else if (window_r.x + window_r.width >= desktop_r.x + desktop_r.width)
window_r.x = desktop_r.x + desktop_r.width - window_r.width;
if (centre & 2)
window_r.y = desktop_r.y + (desktop_r.height - window_r.height) / 2;
else if (window_r.y < desktop_r.y)
window_r.y = desktop_r.y;
else if (window_r.y + window_r.height >= desktop_r.y + desktop_r.height)
window_r.y = desktop_r.y + desktop_r.height - window_r.height;
if (!devilspie2_emulate) {
devilspie2_error_trap_push();
XMoveWindow (gdk_x11_get_default_xdisplay(),
wnck_window_get_xid(window),
window_r.x, window_r.y);
if (devilspie2_error_trap_pop()) {
g_printerr("center: %s", failed_string);
lua_pushboolean(lua, FALSE);
return 1;
}
}
lua_pushboolean(lua, TRUE);
return 1;
}
/**
*
*/
int c_set_window_opacity(lua_State *lua)
{
if (!check_param_count(lua, "set_window_opacity", 1)) {
return 0;
}
//WnckScreen *screen;
int type = lua_type(lua, 1);
if (type != LUA_TNUMBER) {
luaL_error(lua, "set_opacity: %s", number_expected_as_indata_error);
return 0;
}
double value = (double)lua_tonumber(lua, 1);
WnckWindow *window = get_current_window();
if (!devilspie2_emulate && window) {
gulong xid = wnck_window_get_xid(window);
my_window_set_opacity(xid, value);
}
return 0;
}
/**
*
*/
int c_set_window_type(lua_State *lua)
{
if (!check_param_count(lua, "set_window_type", 1)) {
return 0;
}
int type = lua_type(lua, 1);
if (type != LUA_TSTRING) {
luaL_error(lua, "set_window_type: %s", string_expected_as_indata_error);
return 0;
}
gchar *indata = (gchar*)lua_tostring(lua, 1);
WnckWindow *window = get_current_window();
if (!devilspie2_emulate && window) {
gulong xid = wnck_window_get_xid(window);
my_window_set_window_type(xid, indata);
}
return 0;
}
/**
* return the geometry of the screen to the Lua script
*/
int c_get_screen_geometry(lua_State *lua)
{
if (!check_param_count(lua, "get_screen_geometry", 0)) {
return 0;
}
int width = -1, height = -1;
WnckWindow *window = get_current_window();
if (window) {
WnckScreen *screen;
screen = wnck_window_get_screen(window);
width = wnck_screen_get_width(screen);
height = wnck_screen_get_height(screen);
}
lua_pushinteger(lua, width);
lua_pushinteger(lua, height);
return 2;
}
/**
*
*/
int c_focus(lua_State *lua)
{
if (!check_param_count(lua, "focus", 0)) {
return 0;
}
WnckWindow *window = get_current_window();
if (!devilspie2_emulate && window) {
wnck_window_activate(window, current_time());
}
return 0;
}
/**
*
*/
int c_close_window(lua_State *lua)
{
if (!check_param_count(lua, "close_window", 0)) {
return 0;
}
WnckWindow *window = get_current_window();
if (!devilspie2_emulate && window) {
wnck_window_close(window, current_time());
}
return 0;
}
/**
*
*/
int c_get_window_fullscreen(lua_State *lua)
{
if (!check_param_count(lua, "get_window_fullscreen", 0)) {
return 0;
}
gboolean result = FALSE;
WnckWindow *window = get_current_window();
if (window) {
result = wnck_window_is_fullscreen(window);
}
lua_pushboolean(lua, result);
return 1;
}
/**
*
*/
int c_get_monitor_index(lua_State *lua)
{
if (!check_param_count(lua, "get_monitor_index", 0)) {
return 0;
}
WnckWindow *window = get_current_window();
if (window) {
int index = get_monitor_index_geometry(window, NULL, NULL);
if (index < 0)
index = -1; // invalid? assume single monitor
lua_pushinteger(lua, index + 1);
}
return 1;
}
/**
*
*/
int c_get_monitor_geometry(lua_State *lua)
{
if (!check_param_counts(lua, "get_monitor_geometry", 0, 1)) {
return 0;
}
int top = lua_gettop(lua);
GdkRectangle geom;
if (top == 0) {
WnckWindow *window = get_current_window();
if (!window)
return 1; // =nil
get_monitor_index_geometry(window, NULL, &geom);
} else if (top == 1) {
int type = lua_type(lua, 1);
if (type!=LUA_TNUMBER) {
luaL_error(lua, "get_monitor_geometry: %s",
number_expected_as_indata_error);
return 0;
}
int index = lua_tonumber(lua, 1) - 1;
int actual = get_monitor_geometry(index, &geom);
if (actual != index)
return 0;
}
lua_pushinteger(lua, geom.x);
lua_pushinteger(lua, geom.y);
lua_pushinteger(lua, geom.width);
lua_pushinteger(lua, geom.height);
return 4;
}
/**
*
*/
int c_xy(lua_State *lua)
{
if (!check_param_counts(lua, "xy", 0, 2)) {
return 0;
}
int top = lua_gettop(lua);
switch (top)
{
case 0:
// return the xy coordinates of the window
WnckWindow *window = get_current_window();
if (window) {
int x, y, width, height;
wnck_window_get_geometry(window, &x, &y, &width, &height);
lua_pushinteger(lua, x);
lua_pushinteger(lua, y);
return 2;
}
break;
case 2:
// set the coordinates of the window
int type1 = lua_type(lua, 1);
int type2 = lua_type(lua, 2);
if ((type1 != LUA_TNUMBER) ||
(type2 != LUA_TNUMBER)) {
luaL_error(lua, "xy: %s", number_expected_as_indata_error);
return 0;
}
int x = lua_tonumber(lua, 1);
int y = lua_tonumber(lua, 2);
if (!devilspie2_emulate) {
WnckWindow *window = get_current_window();
if (window) {
if (adjusting_for_decoration)
adjust_for_decoration (window, &x, &y, NULL, NULL);
wnck_window_set_geometry(window,
WNCK_WINDOW_GRAVITY_CURRENT,
WNCK_WINDOW_CHANGE_X + WNCK_WINDOW_CHANGE_Y,
x, y, -1, -1);
}
}
break;
}
return 0;
}
/**
*
*/
int c_xywh(lua_State *lua)
{
if (!check_param_counts(lua, "xywh", 0, 4)) {
return 0;
}
int top = lua_gettop(lua);
switch (top)
{
case 0:
// Return the xywh settings of the window
WnckWindow *window = get_current_window();
if (window) {
int x, y, width, height;
wnck_window_get_geometry(window, &x, &y, &width, &height);
lua_pushinteger(lua, x);
lua_pushinteger(lua, y);
lua_pushinteger(lua, width);
lua_pushinteger(lua, height);
return 4;
}
break;
case 4:
// Set the xywh settings in the window
int type1 = lua_type(lua, 1);
int type2 = lua_type(lua, 2);
int type3 = lua_type(lua, 3);
int type4 = lua_type(lua, 4);
if ((type1 != LUA_TNUMBER) ||
(type2 != LUA_TNUMBER) ||
(type3 != LUA_TNUMBER) ||
(type4 != LUA_TNUMBER)) {
luaL_error(lua, "xywh: %s", number_expected_as_indata_error);
return 0;
}
int x = lua_tonumber(lua, 1);
int y = lua_tonumber(lua, 2);
int xsize = lua_tonumber(lua, 3);
int ysize = lua_tonumber(lua, 4);
if (!devilspie2_emulate) {
WnckWindow *window = get_current_window();
if (window) {
set_window_geometry(window, x, y, xsize, ysize, adjusting_for_decoration);
}
}
return 0;
}
return 0;
}
struct lua_callback {
lua_State *lua;
int ref;
};
static void on_geometry_changed(WnckWindow *window, struct lua_callback *callback)
{
if (callback == NULL)
return;
WnckWindow *old_window = get_current_window();
set_current_window(window);
lua_rawgeti(callback->lua, LUA_REGISTRYINDEX, callback->ref);
lua_pcall(callback->lua, 0, 0, 0);
set_current_window(old_window);
}
static void on_geometry_changed_disconnect(gpointer data, GClosure *closure G_GNUC_UNUSED)
{
g_free(data);
}
/**
*
*/
int c_on_geometry_changed(lua_State *lua)
{
if (!check_param_count(lua, "on_geometry_changed", 1)) {
return 0;
}
if (lua_type(lua, 1) != LUA_TFUNCTION) {
luaL_error(lua, "on_geometry_changed: %s", "function expected");
return 0;
}
struct lua_callback *cb = g_malloc(sizeof(struct lua_callback));
cb->lua = lua;
cb->ref = luaL_ref(lua, LUA_REGISTRYINDEX);
WnckWindow *window = get_current_window();
if (window) {
g_signal_connect_data(window, "geometry-changed", G_CALLBACK(on_geometry_changed), (gpointer)cb, (GClosureNotify)(on_geometry_changed_disconnect), 0);
}
return 0;
}
/**
* returns the process binary name
*/
static ATTR_MALLOC gchar *c_get_process_name_INT_proc(lua_State *, pid_t);
static ATTR_MALLOC gchar *c_get_process_name_INT_ps(lua_State *, pid_t);
int c_get_process_name(lua_State *lua)
{
if (!check_param_count(lua, "get_process_name", 0)) {
return 0;
}
WnckWindow *window = get_current_window();
if (window) {
pid_t pid = wnck_window_get_pid(window);
if (pid != 0) {
gchar *cmdname = c_get_process_name_INT_proc(lua, pid);
if (!cmdname)
cmdname = c_get_process_name_INT_ps(lua, pid);
/* chop off any trailing LF */
gchar *lf = cmdname + strlen(cmdname) - 1;
if (lf >= cmdname && *lf == '\n')
*lf = 0;
lua_pushstring(lua, cmdname ? cmdname : "");
g_free(cmdname);
return 1;
}
}
lua_pushstring(lua, "");
return 1;
}
static gchar *c_get_process_name_INT_proc(lua_State *lua, pid_t pid)
{
/* 16 is fine for cmdname on Linux. Could be longer elsewhere, though. */
char cmd[1024], cmdname[1024];
FILE *cmdfp;
cmdname[0] = 0;
snprintf(cmd, sizeof(cmd), "/proc/%lu/comm", (unsigned long)pid);
cmdfp = fopen(cmd, "r");
if (cmdfp == NULL) {
if (errno != ENOENT && errno != EACCES) {
luaL_error(lua, "get_process_name: Failed to open \"%s\" (%d).", cmd, errno);
}
return NULL;
}
if (fgets(cmdname, sizeof(cmdname), cmdfp) == NULL) {
fclose(cmdfp);
luaL_error(lua, "get_process_name: Failed to read from \"%s\".", cmd);
return NULL;
}
fclose(cmdfp);
return g_strdup(cmdname);
}
static gchar *c_get_process_name_INT_ps(lua_State *lua, pid_t pid)
{
char cmd[1024], cmdname[1024];
FILE *cmdfp;
/* I'd like to use "ps ho comm c %lu" here.
* Seems that FreeBSD ps outputs headers regardless.
* (Tested using procps 'ps' with PS_PERSONALITY=bsd)
*/
snprintf(cmd, sizeof(cmd), "ps o comm c %lu | tail -n 1", (unsigned long)pid);
cmdfp = popen(cmd, "r");
if (cmdfp == NULL) {
luaL_error(lua, "get_process_name: Failed to run command \"%s\".", cmd);
return 0;
}
if (fgets(cmdname, sizeof(cmdname), cmdfp) == NULL) {
pclose(cmdfp);
luaL_error(lua, "get_process_name: Failed to read output from command \"%s\".", cmd);
return 0;
}
pclose(cmdfp);
return g_strdup(cmdname);
}
/**
*
*/
int c_millisleep(lua_State *lua)
{
if (!check_param_count(lua, "millisleep", 1)) {
return 0;
}
if (lua_type(lua, 1) != LUA_TNUMBER) {
luaL_error(lua, "millisleep: %s",
number_expected_as_indata_error);
return 0;
}
int time = lua_tonumber(lua, 1);
if (time < 1 || time > 1000) {
luaL_error(lua, _("millisleep: time %d out of range (1..1000)"), time);
return 0;
}
struct timespec tv;
struct timespec left;
if (time == 1000) {
tv.tv_sec = 1;
tv.tv_nsec = 0;
} else {
tv.tv_sec = 0;
tv.tv_nsec = time * 1000000;
}
while (nanosleep(&tv, &left) && errno == EINTR)
tv = left;
return 0;
}
/*
* Devilspie:
* Focus the current window.
ESExpResult *func_focus(ESExp *f, int argc, ESExpResult **argv, Context *c) {
wnck_window_activate (c->window, current_time());
if (debug) g_printerr (_("Focusing\n"));
return e_sexp_result_new_bool (f, TRUE);
}
*/